Change subset

dvd101x · dvd101x · commit 8c436c2221eb · 2025-05-30T21:28:25.000-06:00
diff --git a/src/function/algebra/sylvester.js b/src/function/algebra/sylvester.js
@@ -110,7 +110,7 @@ export const createSylvester = /* #__PURE__ */ factory(name, dependencies, (
 
     for (let k = 0; k < n; k++) {
       if (k < (n - 1) && abs(subset(G, index(k + 1, k))) > 1e-5) {
-        let RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)))
+        let RHS = vc(subset(D, index(all, [k])), subset(D, index(all, [k + 1])))
         for (let j = 0; j < k; j++) {
           RHS = add(RHS,
             vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1))))
@@ -125,11 +125,11 @@ export const createSylvester = /* #__PURE__ */ factory(name, dependencies, (
           hc(gkm, add(F, gmm))
         )
         const yAux = lusolve(LHS, RHS)
-        y[k] = yAux.subset(index(range(0, m), 0))
-        y[k + 1] = yAux.subset(index(range(m, 2 * m), 0))
+        y[k] = yAux.subset(index(range(0, m), [0]))
+        y[k + 1] = yAux.subset(index(range(m, 2 * m), [0]))
         k++
       } else {
-        let RHS = subset(D, index(all, k))
+        let RHS = subset(D, index(all, [k]))
         for (let j = 0; j < k; j++) { RHS = add(RHS, multiply(y[j], subset(G, index(j, k)))) }
         const gkk = subset(G, index(k, k))
         const LHS = subtract(F, multiply(gkk, identity(m)))
diff --git a/src/function/matrix/column.js b/src/function/matrix/column.js
@@ -51,7 +51,7 @@ export const createColumn = /* #__PURE__ */ factory(name, dependencies, ({ typed
     validateIndex(column, value.size()[1])
 
     const rowRange = range(0, value.size()[0])
-    const index = new Index(rowRange, column)
+    const index = new Index(rowRange, [column])
     const result = value.subset(index)
     return isMatrix(result)
       ? result
diff --git a/src/function/matrix/row.js b/src/function/matrix/row.js
@@ -51,7 +51,7 @@ export const createRow = /* #__PURE__ */ factory(name, dependencies, ({ typed, I
     validateIndex(row, value.size()[0])
 
     const columnRange = range(0, value.size()[1])
-    const index = new Index(row, columnRange)
+    const index = new Index([row], columnRange)
     const result = value.subset(index)
     return isMatrix(result)
       ? result
diff --git a/src/function/matrix/subset.js b/src/function/matrix/subset.js
@@ -115,7 +115,7 @@ export const createSubset = /* #__PURE__ */ factory(name, dependencies, ({ typed
     if (typeof replacement === 'string') {
       throw new Error('can\'t boradcast a string')
     }
-    if (index._isScalar) {
+    if (index.isScalar()) {
       return replacement
     }
 
diff --git a/src/type/matrix/DenseMatrix.js b/src/type/matrix/DenseMatrix.js
@@ -238,7 +238,7 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
       }
 
       // retrieve submatrix
-      const returnMatrix = new DenseMatrix([])
+      const returnMatrix = new DenseMatrix()
       const submatrix = _getSubmatrix(matrix._data, index)
       returnMatrix._size = submatrix.size
       returnMatrix._datatype = matrix._datatype
@@ -259,11 +259,10 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
   function _getSubmatrix (data, index) {
     const maxDepth = index.size().length - 1
     const size = Array(maxDepth)
-    return { data: getSubmatrixRecursive(data), size }
+    return { data: getSubmatrixRecursive(data), size: size.filter(x => x !== null) }
 
     function getSubmatrixRecursive (data, depth = 0) {
       const ranges = index.dimension(depth)
-      if (ranges === null) { console.log('null range') }
       function callback (rangeIndex) {
         validateIndex(rangeIndex, data.length)
         return getSubmatrixRecursive(data[rangeIndex], depth + 1)
@@ -272,16 +271,16 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
         validateIndex(rangeIndex, data.length)
         return data[rangeIndex]
       }
-      if (Number.isInteger(ranges)) {
-        size[depth] = 1
+      if (isNumber(ranges)) {
+        size[depth] = null
       } else {
         size[depth] = ranges.size()[0]
       }
       if (depth < maxDepth) {
-        if (Number.isInteger(ranges)) return [callback(ranges)]
+        if (isNumber(ranges)) return callback(ranges)
         else return ranges.map(callback).valueOf()
       } else {
-        if (Number.isInteger(ranges)) return [finalCallback(ranges)]
+        if (isNumber(ranges)) return finalCallback(ranges)
         else return ranges.map(finalCallback).valueOf()
       }
     }
@@ -309,34 +308,35 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
     const isScalar = index.isScalar()
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    let sSize
+    let submatrixSize
     if (isMatrix(submatrix)) {
-      sSize = submatrix.size()
+      submatrixSize = submatrix.size()
       submatrix = submatrix.valueOf()
     } else {
-      sSize = arraySize(submatrix)
+      submatrixSize = arraySize(submatrix)
     }
 
     if (isScalar) {
       // set a scalar
 
       // check whether submatrix is a scalar
-      if (sSize.length !== 0) {
+      if (submatrixSize.length !== 0) {
         throw new TypeError('Scalar expected')
       }
       matrix.set(index.min(), submatrix, defaultValue)
     } else {
       // set a submatrix
 
       // broadcast submatrix
-      if (!deepStrictEqual(sSize, iSize)) {
+      if (!deepStrictEqual(submatrixSize, iSize)) {
+        // TODO: remove try catch if possible
         try {
-          if (sSize.length === 0) {
+          if (submatrixSize.length === 0) {
             submatrix = broadcastTo([submatrix], iSize)
           } else {
             submatrix = broadcastTo(submatrix, iSize)
           }
-          sSize = arraySize(submatrix)
+          submatrixSize = arraySize(submatrix)
         } catch {
         }
       }
@@ -346,11 +346,11 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
         throw new DimensionError(iSize.length, matrix._size.length, '<')
       }
 
-      if (sSize.length < iSize.length) {
+      if (submatrixSize.length < iSize.length) {
         // calculate number of missing outer dimensions
         let i = 0
         let outer = 0
-        while (iSize[i] === 1 && sSize[i] === 1) {
+        while (iSize[i] === 1 && submatrixSize[i] === 1) {
           i++
         }
         while (iSize[i] === 1) {
@@ -359,12 +359,12 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
         }
 
         // unsqueeze both outer and inner dimensions
-        submatrix = unsqueeze(submatrix, iSize.length, outer, sSize)
+        submatrix = unsqueeze(submatrix, iSize.length, outer, submatrixSize)
       }
 
       // check whether the size of the submatrix matches the index size
-      if (!deepStrictEqual(iSize, sSize)) {
-        throw new DimensionError(iSize, sSize, '>')
+      if (!deepStrictEqual(iSize, submatrixSize)) {
+        throw new DimensionError(iSize, submatrixSize, '>')
       }
 
       // enlarge matrix when needed
@@ -405,10 +405,10 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
       }
 
       if (depth < maxDepth) {
-        if (Number.isInteger(range)) recursiveCallback(range, [0])
+        if (isNumber(range)) recursiveCallback(range, [0])
         else range.forEach(recursiveCallback)
       } else {
-        if (Number.isInteger(range)) finalCallback(range, [0])
+        if (isNumber(range)) finalCallback(range, [0])
         else range.forEach(finalCallback)
       }
     }
diff --git a/src/type/matrix/MatrixIndex.js b/src/type/matrix/MatrixIndex.js
@@ -1,4 +1,4 @@
-import { isArray, isMatrix, isRange } from '../../utils/is.js'
+import { isArray, isMatrix, isRange, isNumber, isString } from '../../utils/is.js'
 import { clone } from '../../utils/object.js'
 import { isInteger } from '../../utils/number.js'
 import { factory } from '../../utils/factory.js'
@@ -36,7 +36,6 @@ export const createIndexClass = /* #__PURE__ */ factory(name, dependencies, ({ I
 
     this._dimensions = []
     this._sourceSize = []
-    this._isScalar = true
 
     for (let i = 0, ii = ranges.length; i < ii; i++) {
       const arg = ranges[i]
@@ -46,7 +45,6 @@ export const createIndexClass = /* #__PURE__ */ factory(name, dependencies, ({ I
       let sourceSize = null
       if (isRange(arg)) {
         this._dimensions.push(arg)
-        this._isScalar = false
       } else if (argIsArray || argIsMatrix) {
         // create matrix
         let m
@@ -60,12 +58,6 @@ export const createIndexClass = /* #__PURE__ */ factory(name, dependencies, ({ I
         }
 
         this._dimensions.push(m)
-        // size
-        const size = m.size()
-        // scalar
-        if (size.length !== 1 || size[0] !== 1 || sourceSize !== null) {
-          this._isScalar = false
-        }
       } else if (argType === 'number') {
         this._dimensions.push(arg)
       } else if (argType === 'bigint') {
@@ -109,7 +101,6 @@ export const createIndexClass = /* #__PURE__ */ factory(name, dependencies, ({ I
   Index.prototype.clone = function () {
     const index = new Index()
     index._dimensions = clone(this._dimensions)
-    index._isScalar = this._isScalar
     index._sourceSize = this._sourceSize
     return index
   }
@@ -228,7 +219,7 @@ export const createIndexClass = /* #__PURE__ */ factory(name, dependencies, ({ I
    * @return {boolean} isScalar
    */
   Index.prototype.isScalar = function () {
-    return this._isScalar
+    return this._dimensions.every(dim => isNumber(dim) || isString(dim))
   }
 
   /**
diff --git a/test/unit-tests/expression/node/AccessorNode.test.js b/test/unit-tests/expression/node/AccessorNode.test.js
@@ -73,7 +73,7 @@ describe('AccessorNode', function () {
     const scope = {
       a: [[1, 2], [3, 4]]
     }
-    assert.deepStrictEqual(expr.evaluate(scope), [[3, 4]])
+    assert.deepStrictEqual(expr.evaluate(scope), [3, 4])
   })
 
   it('should compile a AccessorNode with "end" in an expression', function () {
@@ -185,7 +185,7 @@ describe('AccessorNode', function () {
     const scope = {
       a: [[1, 2], [3, 4]]
     }
-    assert.deepStrictEqual(expr.evaluate(scope), [[4, 3]])
+    assert.deepStrictEqual(expr.evaluate(scope), [4, 3])
   })
 
   it('should compile a AccessorNode with "end" both as value and in a range', function () {
@@ -203,7 +203,7 @@ describe('AccessorNode', function () {
     const scope = {
       a: [[1, 2], [3, 4]]
     }
-    assert.deepStrictEqual(expr.evaluate(scope), [[3, 4]])
+    assert.deepStrictEqual(expr.evaluate(scope), [3, 4])
   })
 
   it('should use the inner context when using "end" in a nested index', function () {
diff --git a/test/unit-tests/expression/parse.test.js b/test/unit-tests/expression/parse.test.js
@@ -697,18 +697,18 @@ describe('parse', function () {
           [7, 8, 9]
         ])
       }
-      assert.deepStrictEqual(parseAndEval('a[2, :]', scope), math.matrix([[4, 5, 6]]))
-      assert.deepStrictEqual(parseAndEval('a[2, :2]', scope), math.matrix([[4, 5]]))
-      assert.deepStrictEqual(parseAndEval('a[2, :end-1]', scope), math.matrix([[4, 5]]))
-      assert.deepStrictEqual(parseAndEval('a[2, 2:]', scope), math.matrix([[5, 6]]))
-      assert.deepStrictEqual(parseAndEval('a[2, 2:3]', scope), math.matrix([[5, 6]]))
-      assert.deepStrictEqual(parseAndEval('a[2, 1:2:3]', scope), math.matrix([[4, 6]]))
-      assert.deepStrictEqual(parseAndEval('a[:, 2]', scope), math.matrix([[2], [5], [8]]))
-      assert.deepStrictEqual(parseAndEval('a[:2, 2]', scope), math.matrix([[2], [5]]))
-      assert.deepStrictEqual(parseAndEval('a[:end-1, 2]', scope), math.matrix([[2], [5]]))
-      assert.deepStrictEqual(parseAndEval('a[2:, 2]', scope), math.matrix([[5], [8]]))
-      assert.deepStrictEqual(parseAndEval('a[2:3, 2]', scope), math.matrix([[5], [8]]))
-      assert.deepStrictEqual(parseAndEval('a[1:2:3, 2]', scope), math.matrix([[2], [8]]))
+      assert.deepStrictEqual(parseAndEval('a[2, :]', scope), math.matrix([4, 5, 6]))
+      assert.deepStrictEqual(parseAndEval('a[2, :2]', scope), math.matrix([4, 5]))
+      assert.deepStrictEqual(parseAndEval('a[2, :end-1]', scope), math.matrix([4, 5]))
+      assert.deepStrictEqual(parseAndEval('a[2, 2:]', scope), math.matrix([5, 6]))
+      assert.deepStrictEqual(parseAndEval('a[2, 2:3]', scope), math.matrix([5, 6]))
+      assert.deepStrictEqual(parseAndEval('a[2, 1:2:3]', scope), math.matrix([4, 6]))
+      assert.deepStrictEqual(parseAndEval('a[:, 2]', scope), math.matrix([2, 5, 8]))
+      assert.deepStrictEqual(parseAndEval('a[:2, [2]]', scope), math.matrix([[2], [5]]))
+      assert.deepStrictEqual(parseAndEval('a[:end-1, [2]]', scope), math.matrix([[2], [5]]))
+      assert.deepStrictEqual(parseAndEval('a[2:, [2]]', scope), math.matrix([[5], [8]]))
+      assert.deepStrictEqual(parseAndEval('a[2:3, [2]]', scope), math.matrix([[5], [8]]))
+      assert.deepStrictEqual(parseAndEval('a[1:2:3, [2]]', scope), math.matrix([[2], [8]]))
     })
 
     it('should get a matrix subset of a matrix subset', function () {
@@ -719,7 +719,7 @@ describe('parse', function () {
           [7, 8, 9]
         ])
       }
-      assert.deepStrictEqual(parseAndEval('a[2, :][1,1]', scope), 4)
+      assert.deepStrictEqual(parseAndEval('a[[2], :][1,1]', scope), 4)
     })
 
     it('should get BigNumber value from an array', function () {
@@ -768,7 +768,7 @@ describe('parse', function () {
       assert.deepStrictEqual(parseAndEval('a[1:3,1:2]', scope), math.matrix([[100, 2], [3, 10], [0, 12]]))
 
       scope.b = [[1, 2], [3, 4]]
-      assert.deepStrictEqual(parseAndEval('b[1,:]', scope), [[1, 2]])
+      assert.deepStrictEqual(parseAndEval('b[1,:]', scope), [1, 2])
     })
 
     it('should get/set the matrix correctly for 3d matrices', function () {
@@ -789,10 +789,10 @@ describe('parse', function () {
       ]))
 
       assert.deepStrictEqual(parseAndEval('size(f)', scope), math.matrix([2, 2, 2], 'dense', 'number'))
-      assert.deepStrictEqual(parseAndEval('f[:,:,1]', scope), math.matrix([[[1], [2]], [[3], [4]]]))
-      assert.deepStrictEqual(parseAndEval('f[:,:,2]', scope), math.matrix([[[5], [6]], [[7], [8]]]))
-      assert.deepStrictEqual(parseAndEval('f[:,2,:]', scope), math.matrix([[[2, 6]], [[4, 8]]]))
-      assert.deepStrictEqual(parseAndEval('f[2,:,:]', scope), math.matrix([[[3, 7], [4, 8]]]))
+      assert.deepStrictEqual(parseAndEval('f[:,:,1]', scope), math.matrix([[1, 2], [3, 4]]))
+      assert.deepStrictEqual(parseAndEval('f[:,:,2]', scope), math.matrix([[5, 6], [7, 8]]))
+      assert.deepStrictEqual(parseAndEval('f[:,2,:]', scope), math.matrix([[2, 6], [4, 8]]))
+      assert.deepStrictEqual(parseAndEval('f[2,:,:]', scope), math.matrix([[3, 7], [4, 8]]))
 
       parseAndEval('a=diag([1,2,3,4])', scope)
       assert.deepStrictEqual(parseAndEval('a[3:end, 3:end]', scope), math.matrix([[3, 0], [0, 4]]))
diff --git a/test/unit-tests/function/matrix/map.test.js b/test/unit-tests/function/matrix/map.test.js
@@ -281,7 +281,7 @@ describe('map', function () {
   it('should operate from the parser with multiple inputs that need broadcasting and one based indices and the broadcasted arrays', function () {
     // this is a convoluted way of calculating f(a,b,idx) = 2a+2b+index
     // 2(1) + 2([3,4]) + [1, 2] # yields [9, 12]
-    const arr2 = math.evaluate('map([1],[3,4], f(a,b,idx,A,B)= a + A[idx] + b + B[idx] + idx[1])')
+    const arr2 = math.evaluate('map([1],[3,4], f(a,b,idx,A,B)= a + A[idx[1]] + b + B[idx[1]] + idx[1])')
     const expected = math.matrix([9, 12])
     assert.deepStrictEqual(arr2, expected)
   })
diff --git a/test/unit-tests/function/matrix/subset.test.js b/test/unit-tests/function/matrix/subset.test.js
@@ -11,13 +11,13 @@ describe('subset', function () {
   const b = math.matrix(a)
 
   it('should get the right subset of an array', function () {
-    assert.deepStrictEqual(subset(a, index(new Range(0, 2), 1)), [[2], [4]])
+    assert.deepStrictEqual(subset(a, index(new Range(0, 2), 1)), [2, 4])
     assert.deepStrictEqual(subset(a, index(1, 0)), 3)
     assert.deepStrictEqual(subset([math.bignumber(2)], index(0)), math.bignumber(2))
   })
 
   it('should get the right subset of an array of booleans', function () {
-    assert.deepStrictEqual(subset(a, index([true, true], 1)), [[2], [4]])
+    assert.deepStrictEqual(subset(a, index([true, true], [1])), [[2], [4]])
     assert.deepStrictEqual(subset(a, index([false, true], [true, false])), [[3]])
     assert.deepStrictEqual(subset([math.bignumber(2)], index([true])), [math.bignumber(2)])
   })
@@ -32,7 +32,7 @@ describe('subset', function () {
   })
 
   it('should get the right subset of an array of booleans in the parser', function () {
-    assert.deepStrictEqual(math.evaluate('a[[true, true], 2]', { a }), [[2], [4]])
+    assert.deepStrictEqual(math.evaluate('a[[true, true], 2]', { a }), [2, 4])
     assert.deepStrictEqual(math.evaluate('a[[false, true], [true, false]]', { a }), [[3]])
     assert.deepStrictEqual(math.evaluate('[bignumber(2)][[true]]'), math.matrix([math.bignumber(2)]))
   })
@@ -75,7 +75,7 @@ describe('subset', function () {
   })
 
   it('should get the right subset of a matrix', function () {
-    assert.deepStrictEqual(subset(b, index(new Range(0, 2), 1)), matrix([[2], [4]]))
+    assert.deepStrictEqual(subset(b, index(new Range(0, 2), 1)), matrix([2, 4]))
     assert.deepStrictEqual(subset(b, index(1, 0)), 3)
   })
 
diff --git a/test/unit-tests/type/matrix/DenseMatrix.test.js b/test/unit-tests/type/matrix/DenseMatrix.test.js
diff --git a/test/unit-tests/type/matrix/ImmutableDenseMatrix.test.js b/test/unit-tests/type/matrix/ImmutableDenseMatrix.test.js
diff --git a/test/unit-tests/type/matrix/Index.test.js b/test/unit-tests/type/matrix/Index.test.js

Original file line number	Diff line number	Diff line change
`@@ -115,7 +115,7 @@ export const createSubset = /* #__PURE__ */ factory(name, dependencies, ({ typed`
`115`	`115`	`if (typeof replacement === 'string') {`
`116`	`116`	`throw new Error('can\'t boradcast a string')`
`117`	`117`	`}`
`118`		`- if (index._isScalar) {`
	`118`	`+ if (index.isScalar()) {`
`119`	`119`	`return replacement`
`120`	`120`	`}`
`121`	`121`