Improve some functions in util (#647)

Author: ishii-norimi

lib/util/complex.js

@@ -134,4 +134,23 @@ export default class Complex {
 			new Complex(Math.cos(th + (4 * Math.PI) / 3) * s, Math.sin(th + (4 * Math.PI) / 3) * s),
 		]
 	}
+
+	/**
+	 * Returns value of complex exponential function.
+	 *
+	 * @returns {Complex} Exponential value
+	 */
+	exp() {
+		const a = Math.exp(this._real)
+		return new Complex(a * Math.cos(this._imag), a * Math.sin(this._imag))
+	}
+
+	/**
+	 * Returns value of complex log function.
+	 *
+	 * @returns {Complex} Principal log value
+	 */
+	log() {
+		return new Complex(Math.log(this.abs()), Math.atan2(this._imag, this._real))
+	}
 }

lib/util/graph.js

@@ -1825,6 +1825,26 @@ export default class Graph {
 		return false
 	}
 
+	/**
+	 * Returns if this is oriented graph or not.
+	 *
+	 * @returns {boolean} `true` if this is oriented graph
+	 */
+	isOriented() {
+		const n = this._nodes.length
+		const amat = Array.from({ length: n }, () => Array(n).fill(false))
+		for (const e of this._edges) {
+			if (!e.direct) {
+				return false
+			}
+			if (amat[e[0]][e[1]]) {
+				return false
+			}
+			amat[e[0]][e[1]] = amat[e[1]][e[0]] = true
+		}
+		return true
+	}
+
 	/**
 	 * Returns if this is weighted graph or not.
 	 *

lib/util/tensor.js

@@ -339,20 +339,30 @@ export default class Tensor {
 	 * @returns {Tensor} Selected tensor
 	 */
 	select(idx, axis = 0) {
-		if (axis !== 0) {
-			throw new MatrixException('Invalid axis. Only 0 is accepted.')
+		if (axis < 0 || this.dimension <= axis) {
+			throw new MatrixException('Invalid axis.')
 		}
 		if (!Array.isArray(idx)) {
 			idx = [idx]
 		}
-		let s = 1
-		for (let d = 1; d < this.dimension; d++) {
-			s *= this._size[d]
+		let step = 1
+		let sublen = 1
+		for (let d = 0; d < axis; d++) {
+			step *= this._size[d]
+		}
+		for (let d = axis + 1; d < this.dimension; d++) {
+			sublen *= this._size[d]
 		}
-		const t = new Tensor([idx.length, ...this._size.slice(1)])
+		const newSizes = this._size.concat()
+		newSizes[axis] = idx.length
+		const t = new Tensor(newSizes)
 		for (let i = 0; i < idx.length; i++) {
-			for (let j = 0; j < s; j++) {
-				t._value[i * s + j] = this._value[idx[i] * s + j]
+			for (let k = 0; k < step; k++) {
+				const toff1 = k * idx.length * sublen + i * sublen
+				const toff2 = k * this._size[axis] * sublen + idx[i] * sublen
+				for (let l = 0; l < sublen; l++) {
+					t._value[toff1 + l] = this._value[toff2 + l]
+				}
 			}
 		}
 		return t
@@ -375,17 +385,14 @@ export default class Tensor {
 		} else if (to < from) {
 			throw new MatrixException('Invalid index.')
 		}
-		let s = 1
-		for (let d = 0; d < this.dimension; d++) {
-			if (d === axis) {
-				continue
-			}
-			s *= this._size[d]
-		}
 		const newSizes = this._size.concat()
 		newSizes[axis] = to - from
 		const t = new Tensor(newSizes)
 		if (axis === 0) {
+			let s = 1
+			for (let d = 1; d < this.dimension; d++) {
+				s *= this._size[d]
+			}
 			t._value = this._value.slice(from * s, to * s)
 		} else {
 			for (let i = 0; i < t.length; i++) {

tests/lib/util/complex.test.js

@@ -128,4 +128,28 @@ describe('Complex', () => {
 			expect(r.imaginary).toBeCloseTo(complex.imaginary)
 		}
 	})
+
+	test('exp', () => {
+		const complex = new Complex(Math.random(), Math.random())
+		const exp = complex.exp()
+		expect(exp.real).toBeCloseTo(Math.exp(complex.real) * Math.cos(complex.imaginary))
+		expect(exp.imaginary).toBeCloseTo(Math.exp(complex.real) * Math.sin(complex.imaginary))
+
+		const log = exp.log()
+		expect(log.real).toBeCloseTo(complex.real)
+		expect(log.imaginary).toBeCloseTo(complex.imaginary)
+	})
+
+	test('log', () => {
+		const complex = new Complex(Math.random(), Math.random())
+		const log = complex.log()
+		expect(log.real).toBeCloseTo(Math.log(Math.sqrt(complex.real ** 2 + complex.imaginary ** 2)))
+		expect(log.imaginary).toBeLessThanOrEqual(Math.PI)
+		expect(log.imaginary).toBeGreaterThan(-Math.PI)
+		expect(log.imaginary).toBeCloseTo(Math.atan2(complex.imaginary, complex.real))
+
+		const exp = log.exp()
+		expect(exp.real).toBeCloseTo(complex.real)
+		expect(exp.imaginary).toBeCloseTo(complex.imaginary)
+	})
 })

tests/lib/util/graph.test.js

@@ -1672,6 +1672,34 @@ describe('graph', () => {
 		})
 	})
 
+	describe('isOriented', () => {
+		test('oriented', () => {
+			const graph = new Graph(3, [
+				{ 0: 0, 1: 1, direct: true },
+				{ 0: 1, 1: 2, direct: true },
+			])
+			expect(graph.isOriented()).toBeTruthy()
+		})
+
+		test('empty', () => {
+			const graph = new Graph(3)
+			expect(graph.isOriented()).toBeTruthy()
+		})
+
+		test('undirected', () => {
+			const graph = new Graph(3, [[0, 1]])
+			expect(graph.isOriented()).toBeFalsy()
+		})
+
+		test('directed', () => {
+			const graph = new Graph(3, [
+				{ 0: 0, 1: 1, direct: true },
+				{ 0: 1, 1: 0, direct: true },
+			])
+			expect(graph.isOriented()).toBeFalsy()
+		})
+	})
+
 	describe('isWeighted', () => {
 		test('weighted', () => {
 			const graph = new Graph(3, [{ 0: 0, 1: 1, value: 2 }])

tests/lib/util/tensor.test.js

@@ -433,7 +433,59 @@ describe('Tensor', () => {
 			})
 		})
 
-		test.each([-1, 1])('axis %i', i => {
+		describe('axis 1', () => {
+			test.each([0, 1, 2])('scalar %p', k => {
+				const ten = Tensor.randn([3, 4, 5])
+				const slice = ten.select(k, 1)
+				expect(slice.sizes).toEqual([3, 1, 5])
+				for (let i = 0; i < 3; i++) {
+					for (let j = 0; j < 5; j++) {
+						expect(slice.at(i, 0, j)).toBe(ten.at(i, k, j))
+					}
+				}
+			})
+
+			test.each([[[0]], [[1]], [[2]], [[0, 0]], [[1, 2]], [[2, 0]]])('array %p', k => {
+				const ten = Tensor.randn([3, 4, 5])
+				const slice = ten.select(k, 1)
+				expect(slice.sizes).toEqual([3, k.length, 5])
+				for (let t = 0; t < k.length; t++) {
+					for (let i = 0; i < 3; i++) {
+						for (let j = 0; j < 5; j++) {
+							expect(slice.at(i, t, j)).toBe(ten.at(i, k[t], j))
+						}
+					}
+				}
+			})
+		})
+
+		describe('axis 2', () => {
+			test.each([0, 1, 2])('scalar %p', k => {
+				const ten = Tensor.randn([3, 4, 5])
+				const slice = ten.select(k, 2)
+				expect(slice.sizes).toEqual([3, 4, 1])
+				for (let i = 0; i < 3; i++) {
+					for (let j = 0; j < 4; j++) {
+						expect(slice.at(i, j, 0)).toBe(ten.at(i, j, k))
+					}
+				}
+			})
+
+			test.each([[[0]], [[1]], [[2]], [[0, 0]], [[1, 2]], [[2, 0]]])('array %p', k => {
+				const ten = Tensor.randn([3, 4, 5])
+				const slice = ten.select(k, 2)
+				expect(slice.sizes).toEqual([3, 4, k.length])
+				for (let t = 0; t < k.length; t++) {
+					for (let i = 0; i < 3; i++) {
+						for (let j = 0; j < 4; j++) {
+							expect(slice.at(i, j, t)).toBe(ten.at(i, j, k[t]))
+						}
+					}
+				}
+			})
+		})
+
+		test.each([-1, 3])('axis %i', i => {
 			const ten = new Tensor([2, 3, 4])
 			expect(() => ten.select(0, i)).toThrow('Invalid axis.')
 		})
@@ -618,7 +670,61 @@ describe('Tensor', () => {
 			}
 		})
 
-		test.each([-1, 1])('fail invalid axis %p', axis => {
+		test('axis 1', () => {
+			const org = Tensor.randn([3, 4, 5])
+			const ten = org.copy()
+			ten.shuffle(1)
+
+			const expidx = []
+			for (let t = 0; t < org.sizes[1]; t++) {
+				for (let i = 0; i < org.sizes[1]; i++) {
+					let flg = true
+					for (let j = 0; j < org.sizes[0]; j++) {
+						for (let k = 0; k < org.sizes[2]; k++) {
+							flg &= ten.at(j, t, k) === org.at(j, i, k)
+						}
+					}
+					if (flg) {
+						expidx.push(i)
+						break
+					}
+				}
+			}
+			expidx.sort((a, b) => a - b)
+			expect(expidx).toHaveLength(org.sizes[1])
+			for (let i = 0; i < org.sizes[1]; i++) {
+				expect(expidx[i]).toBe(i)
+			}
+		})
+
+		test('axis 2', () => {
+			const org = Tensor.randn([3, 4, 5])
+			const ten = org.copy()
+			ten.shuffle(2)
+
+			const expidx = []
+			for (let t = 0; t < org.sizes[2]; t++) {
+				for (let i = 0; i < org.sizes[2]; i++) {
+					let flg = true
+					for (let j = 0; j < org.sizes[0]; j++) {
+						for (let k = 0; k < org.sizes[1]; k++) {
+							flg &= ten.at(j, k, t) === org.at(j, k, i)
+						}
+					}
+					if (flg) {
+						expidx.push(i)
+						break
+					}
+				}
+			}
+			expidx.sort((a, b) => a - b)
+			expect(expidx).toHaveLength(org.sizes[2])
+			for (let i = 0; i < org.sizes[2]; i++) {
+				expect(expidx[i]).toBe(i)
+			}
+		})
+
+		test.each([-1, 3])('fail invalid axis %p', axis => {
 			const mat = Tensor.randn([2, 3, 4])
 			expect(() => mat.shuffle(axis)).toThrow('Invalid axis.')
 		})