mathjs 14.9.1 → 15.0.0

package/lib/cjs/function/matrix/dot.js

@@ -44,8 +44,8 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     'SparseMatrix, SparseMatrix': _sparseDot
   });
   function _validateDim(x, y) {
-    const xSize = _size(x);
-    const ySize = _size(y);
+    const xSize = size(x);
+    const ySize = size(y);
     let xLen, yLen;
     if (xSize.length === 1) {
       xLen = xSize[0];
@@ -73,8 +73,8 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     const bdt = (0, _is.isMatrix)(b) ? b._datatype || b.getDataType() : undefined;
 
     // are these 2-dimensional column vectors? (as opposed to 1-dimensional vectors)
-    const aIsColumn = _size(a).length === 2;
-    const bIsColumn = _size(b).length === 2;
+    const aIsColumn = size(a).length === 2;
+    const bIsColumn = size(b).length === 2;
     let add = addScalar;
     let mul = multiplyScalar;
 
@@ -154,9 +154,4 @@ const createDot = exports.createDot = /* #__PURE__ */(0, _factory.factory)(name,
     }
     return c;
   }
-
-  // TODO remove this once #1771 is fixed
-  function _size(x) {
-    return (0, _is.isMatrix)(x) ? x.size() : size(x);
-  }
 });

package/lib/cjs/function/matrix/flatten.js

@@ -28,17 +28,20 @@ const createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factor
    *
    *    concat, resize, size, squeeze
    *
-   * @param {Matrix | Array} x   Matrix to be flattened
-   * @return {Matrix | Array} Returns the flattened matrix
+   * @param {DenseMatrix | Array} x   Matrix to be flattened
+   * @return {DenseMatrix | Array} Returns the flattened matrix
    */
   return typed(name, {
     Array: function (x) {
       return (0, _array.flatten)(x);
     },
-    Matrix: function (x) {
+    DenseMatrix: function (x) {
       // Return the same matrix type as x (Dense or Sparse Matrix)
       // Return the same data type as x
       return x.create((0, _array.flatten)(x.valueOf(), true), x.datatype());
+    },
+    SparseMatrix: function (_x) {
+      throw new TypeError('SparseMatrix is not supported by function flatten ' + 'because it does not support 1D vectors. ' + 'Convert to a DenseMatrix or Array first. Example: flatten(x.toArray())');
     }
   });
 });

package/lib/cjs/function/matrix/kron.js

@@ -31,7 +31,7 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
      *    // returns [ [ 1, 2, 0, 0 ], [ 3, 4, 0, 0 ], [ 0, 0, 1, 2 ], [ 0, 0, 3, 4 ] ]
      *
      *    math.kron([1,1], [2,3,4])
-     *    // returns [ [ 2, 3, 4, 2, 3, 4 ] ]
+     *    // returns [2, 3, 4, 2, 3, 4]
      *
      * See also:
      *
@@ -55,37 +55,38 @@ const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(nam
   });
 
   /**
-     * Calculate the Kronecker product of two matrices / vectors
-     * @param {Array} a  First vector
-     * @param {Array} b  Second vector
-     * @returns {Array} Returns the Kronecker product of x and y
-     * @private
+   * Calculate the Kronecker product of two (1-dimensional) vectors,
+   * with no dimension checking
+   * @param {Array} a  First vector
+   * @param {Array} b  Second vector
+   * @returns {Array}  the 1-dimensional Kronecker product of a and b
+   * @private
+   */
+  function _kron1d(a, b) {
+    // TODO in core overhaul: would be faster to see if we can choose a
+    // particular implementation of multiplyScalar at the beginning,
+    // rather than re-dispatch for _every_ ordered pair of entries.
+    return a.flatMap(x => b.map(y => multiplyScalar(x, y)));
+  }
+
+  /**
+   * Calculate the Kronecker product of two possibly multidimensional arrays
+   * @param {Array} a  First array
+   * @param {Array} b  Second array
+   * @param {number} [d]  common dimension; if missing, compute and match args
+   * @returns {Array} Returns the Kronecker product of x and y
+   * @private
      */
   function _kron(a, b) {
-    // Deal with the dimensions of the matricies.
-    if ((0, _array.arraySize)(a).length === 1) {
-      // Wrap it in a 2D Matrix
-      a = [a];
-    }
-    if ((0, _array.arraySize)(b).length === 1) {
-      // Wrap it in a 2D Matrix
-      b = [b];
-    }
-    if ((0, _array.arraySize)(a).length > 2 || (0, _array.arraySize)(b).length > 2) {
-      throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
+    let d = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    if (d < 0) {
+      let adim = (0, _array.arraySize)(a).length;
+      let bdim = (0, _array.arraySize)(b).length;
+      d = Math.max(adim, bdim);
+      while (adim++ < d) a = [a];
+      while (bdim++ < d) b = [b];
     }
-    const t = [];
-    let r = [];
-    return a.map(function (a) {
-      return b.map(function (b) {
-        r = [];
-        t.push(r);
-        return a.map(function (y) {
-          return b.map(function (x) {
-            return r.push(multiplyScalar(y, x));
-          });
-        });
-      });
-    }) && t;
+    if (d === 1) return _kron1d(a, b);
+    return a.flatMap(aSlice => b.map(bSlice => _kron(aSlice, bSlice, d - 1)));
   }
 });

package/lib/cjs/function/matrix/row.js

@@ -58,8 +58,9 @@ const createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name,
     }
     (0, _array.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);
+    // once config.legacySubset just return result
     return (0, _is.isMatrix)(result) ? result : matrix([[result]]);
   }
 });

package/lib/cjs/function/matrix/size.js

@@ -6,17 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.createSize = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var _noop = require("../../utils/noop.js");
 const name = 'size';
-const dependencies = ['typed', 'config', '?matrix'];
+const dependencies = ['typed'];
 const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    typed,
-    config,
-    matrix
+    typed
   } = _ref;
   /**
-   * Calculate the size of a matrix or scalar.
+   * Calculate the size of a matrix or scalar. Always returns an Array containing numbers.
+   *
+   * Note that in mathjs v14 and older, function size could return a Matrix depending on
+   * the input type and configuration.
    *
    * Syntax:
    *
@@ -36,19 +36,13 @@ const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(nam
    *     count, resize, squeeze, subset
    *
    * @param {boolean | number | Complex | Unit | string | Array | Matrix} x  A matrix
-   * @return {Array | Matrix} A vector with size of `x`.
+   * @return {Array} A vector with size of `x`.
    */
   return typed(name, {
-    Matrix: function (x) {
-      return x.create(x.size(), 'number');
-    },
+    Matrix: x => x.size(),
     Array: _array.arraySize,
-    string: function (x) {
-      return config.matrix === 'Array' ? [x.length] : matrix([x.length], 'dense', 'number');
-    },
-    'number | Complex | BigNumber | Unit | boolean | null': function (x) {
-      // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : (0, _noop.noMatrix)();
-    }
+    string: x => [x.length],
+    // scalar
+    'number | Complex | BigNumber | Unit | boolean | null': _x => []
   });
 });

package/lib/cjs/function/matrix/subset.js

@@ -31,8 +31,8 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
    *     // get a subset
    *     const d = [[1, 2], [3, 4]]
    *     math.subset(d, math.index(1, 0))             // returns 3
-   *     math.subset(d, math.index([0, 1], 1))        // returns [[2], [4]]
-   *     math.subset(d, math.index([false, true], 0)) // returns [[3]]
+   *     math.subset(d, math.index([0, 1], [1]))        // returns [[2], [4]]
+   *     math.subset(d, math.index([false, true], [0])) // returns [[3]]
    *
    *     // replace a subset
    *     const e = []
@@ -42,9 +42,9 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
    *
    *     // get submatrix using ranges
    *     const M = [
-   *       [1,2,3],
-   *       [4,5,6],
-   *       [7,8,9]
+   *       [1, 2, 3],
+   *       [4, 5, 6],
+   *       [7, 8, 9]
    *     ]
    *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
    *
@@ -123,7 +123,7 @@ const createSubset = exports.createSubset = /* #__PURE__ */(0, _factory.factory)
     if (typeof replacement === 'string') {
       throw new Error('can\'t boradcast a string');
     }
-    if (index._isScalar) {
+    if (index.isScalar()) {
       return replacement;
     }
     const indexSize = index.size();
@@ -165,9 +165,14 @@ function _getSubstring(str, index) {
   (0, _array.validateIndex)(index.max()[0], strLen);
   const range = index.dimension(0);
   let substr = '';
-  range.forEach(function (v) {
+  function callback(v) {
     substr += str.charAt(v);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range);
+  } else {
+    range.forEach(callback);
+  }
   return substr;
 }
 
@@ -201,7 +206,7 @@ function _setSubstring(str, index, replacement, defaultValue) {
     defaultValue = ' ';
   }
   const range = index.dimension(0);
-  const len = range.size()[0];
+  const len = Number.isInteger(range) ? 1 : range.size()[0];
   if (len !== replacement.length) {
     throw new _DimensionError.DimensionError(range.size()[0], replacement.length);
   }
@@ -216,9 +221,14 @@ function _setSubstring(str, index, replacement, defaultValue) {
   for (let i = 0; i < strLen; i++) {
     chars[i] = str.charAt(i);
   }
-  range.forEach(function (v, i) {
+  function callback(v, i) {
     chars[v] = replacement.charAt(i[0]);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range, [0]);
+  } else {
+    range.forEach(callback);
+  }
 
   // initialize undefined characters with a space
   if (chars.length > strLen) {

package/lib/cjs/header.js

@@ -6,7 +6,7 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 14.9.1
+ * @version 15.0.0
  * @date    2025-10-10
  *
  * @license

package/lib/cjs/type/matrix/DenseMatrix.js

@@ -15,10 +15,11 @@ var _optimizeCallback = require("../../utils/optimizeCallback.js");
 // deno-lint-ignore-file no-this-alias
 
 const name = 'DenseMatrix';
-const dependencies = ['Matrix'];
+const dependencies = ['Matrix', 'config'];
 const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
   let {
-    Matrix
+    Matrix,
+    config
   } = _ref;
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
@@ -228,7 +229,7 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     if (!(0, _is.isIndex)(index)) {
       throw new TypeError('Invalid index');
     }
-    const isScalar = index.isScalar();
+    const isScalar = config.legacySubset ? index.size().every(idx => idx === 1) : index.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
@@ -248,12 +249,12 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       }
 
       // retrieve submatrix
-      const returnMatrix = new DenseMatrix([]);
+      const returnMatrix = new DenseMatrix();
       const submatrix = _getSubmatrix(matrix._data, index);
       returnMatrix._size = submatrix.size;
       returnMatrix._datatype = matrix._datatype;
       returnMatrix._data = submatrix.data;
-      return returnMatrix;
+      return config.legacySubset ? returnMatrix.reshape(index.size()) : returnMatrix;
     }
   }
 
@@ -271,22 +272,30 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     const size = Array(maxDepth);
     return {
       data: getSubmatrixRecursive(data),
-      size
+      size: size.filter(x => x !== null)
     };
     function getSubmatrixRecursive(data) {
       let depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      const ranges = index.dimension(depth);
-      size[depth] = ranges.size()[0];
+      const dims = index.dimension(depth);
+      function _mapIndex(dim, callback) {
+        // applies a callback for when the index is a Number or a Matrix
+        if ((0, _is.isNumber)(dim)) return callback(dim);else return dim.map(callback).valueOf();
+      }
+      if ((0, _is.isNumber)(dims)) {
+        size[depth] = null;
+      } else {
+        size[depth] = dims.size()[0];
+      }
       if (depth < maxDepth) {
-        return ranges.map(rangeIndex => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          (0, _array.validateIndex)(dimIndex, data.length);
+          return getSubmatrixRecursive(data[dimIndex], depth + 1);
+        });
       } else {
-        return ranges.map(rangeIndex => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          return data[rangeIndex];
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          (0, _array.validateIndex)(dimIndex, data.length);
+          return data[dimIndex];
+        });
       }
     }
   }
@@ -313,18 +322,18 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     const isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    let sSize;
+    let submatrixSize;
     if ((0, _is.isMatrix)(submatrix)) {
-      sSize = submatrix.size();
+      submatrixSize = submatrix.size();
       submatrix = submatrix.valueOf();
     } else {
-      sSize = (0, _array.arraySize)(submatrix);
+      submatrixSize = (0, _array.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);
@@ -332,26 +341,26 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
       // set a submatrix
 
       // broadcast submatrix
-      if (!(0, _object.deepStrictEqual)(sSize, iSize)) {
-        try {
-          if (sSize.length === 0) {
-            submatrix = (0, _array.broadcastTo)([submatrix], iSize);
-          } else {
+      if (!(0, _object.deepStrictEqual)(submatrixSize, iSize)) {
+        if (submatrixSize.length === 0) {
+          submatrix = (0, _array.broadcastTo)([submatrix], iSize);
+        } else {
+          try {
             submatrix = (0, _array.broadcastTo)(submatrix, iSize);
-          }
-          sSize = (0, _array.arraySize)(submatrix);
-        } catch (_unused) {}
+          } catch (error) {}
+        }
+        submatrixSize = (0, _array.arraySize)(submatrix);
       }
 
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new _DimensionError.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) {
@@ -360,12 +369,12 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
         }
 
         // unsqueeze both outer and inner dimensions
-        submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, sSize);
+        submatrix = (0, _array.unsqueeze)(submatrix, iSize.length, outer, submatrixSize);
       }
 
       // check whether the size of the submatrix matches the index size
-      if (!(0, _object.deepStrictEqual)(iSize, sSize)) {
-        throw new _DimensionError.DimensionError(iSize, sSize, '>');
+      if (!(0, _object.deepStrictEqual)(iSize, submatrixSize)) {
+        throw new _DimensionError.DimensionError(iSize, submatrixSize, '>');
       }
 
       // enlarge matrix when needed
@@ -394,16 +403,18 @@ const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(
     function setSubmatrixRecursive(data, submatrix) {
       let depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       const range = index.dimension(depth);
+      const recursiveCallback = (rangeIndex, i) => {
+        (0, _array.validateIndex)(rangeIndex, data.length);
+        setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+      };
+      const finalCallback = (rangeIndex, i) => {
+        (0, _array.validateIndex)(rangeIndex, data.length);
+        data[rangeIndex] = submatrix[i[0]];
+      };
       if (depth < maxDepth) {
-        range.forEach((rangeIndex, i) => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
-        });
+        if ((0, _is.isNumber)(range)) recursiveCallback(range, [0]);else range.forEach(recursiveCallback);
       } else {
-        range.forEach((rangeIndex, i) => {
-          (0, _array.validateIndex)(rangeIndex, data.length);
-          data[rangeIndex] = submatrix[i[0]];
-        });
+        if ((0, _is.isNumber)(range)) finalCallback(range, [0]);else range.forEach(finalCallback);
       }
     }
   }

package/lib/cjs/type/matrix/MatrixIndex.js

@@ -37,7 +37,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @Constructor Index
    * @param {...*} ranges
    */
-  function Index(ranges) {
+  function Index() {
     if (!(this instanceof Index)) {
       throw new SyntaxError('Constructor must be called with the new operator');
     }
@@ -45,7 +45,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     this._sourceSize = [];
     this._isScalar = true;
     for (let i = 0, ii = arguments.length; i < ii; i++) {
-      const arg = arguments[i];
+      const arg = i < 0 || arguments.length <= i ? undefined : arguments[i];
       const argIsArray = (0, _is.isArray)(arg);
       const argIsMatrix = (0, _is.isMatrix)(arg);
       const argType = typeof arg;
@@ -56,6 +56,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
       } else if (argIsArray || argIsMatrix) {
         // create matrix
         let m;
+        this._isScalar = false;
         if (getMatrixDataType(arg) === 'boolean') {
           if (argIsArray) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg).valueOf());
           if (argIsMatrix) m = _createImmutableMatrix(_booleansArrayToNumbersForIndex(arg._data).valueOf());
@@ -64,16 +65,10 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
           m = _createImmutableMatrix(arg.valueOf());
         }
         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(_createImmutableMatrix([arg]));
+        this._dimensions.push(arg);
       } else if (argType === 'bigint') {
-        this._dimensions.push(_createImmutableMatrix([Number(arg)]));
+        this._dimensions.push(Number(arg));
       } else if (argType === 'string') {
         // object property (arguments.count should be 1)
         this._dimensions.push(arg);
@@ -93,12 +88,15 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
   function _createImmutableMatrix(arg) {
     // loop array elements
     for (let i = 0, l = arg.length; i < l; i++) {
-      if (typeof arg[i] !== 'number' || !(0, _number.isInteger)(arg[i])) {
+      if (!(0, _is.isNumber)(arg[i]) || !(0, _number.isInteger)(arg[i])) {
         throw new TypeError('Index parameters must be positive integer numbers');
       }
     }
     // create matrix
-    return new ImmutableDenseMatrix(arg);
+    const matrix = new ImmutableDenseMatrix();
+    matrix._data = arg;
+    matrix._size = [arg.length];
+    return matrix;
   }
 
   /**
@@ -136,7 +134,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const size = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const d = this._dimensions[i];
-      size[i] = typeof d === 'string' ? 1 : d.size()[0];
+      size[i] = (0, _is.isString)(d) || (0, _is.isNumber)(d) ? 1 : d.size()[0];
     }
     return size;
   };
@@ -150,7 +148,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const values = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.max();
+      values[i] = (0, _is.isString)(range) || (0, _is.isNumber)(range) ? range : range.max();
     }
     return values;
   };
@@ -164,7 +162,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const values = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const range = this._dimensions[i];
-      values[i] = typeof range === 'string' ? range : range.min();
+      values[i] = (0, _is.isString)(range) || (0, _is.isNumber)(range) ? range : range.min();
     }
     return values;
   };
@@ -189,10 +187,11 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @returns {Range | null} range
    */
   Index.prototype.dimension = function (dim) {
-    if (typeof dim !== 'number') {
+    var _this$_dimensions$dim;
+    if (!(0, _is.isNumber)(dim)) {
       return null;
     }
-    return this._dimensions[dim] || null;
+    return (_this$_dimensions$dim = this._dimensions[dim]) !== null && _this$_dimensions$dim !== void 0 ? _this$_dimensions$dim : null;
   };
 
   /**
@@ -200,7 +199,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
    * @returns {boolean} Returns true if the index is an object property
    */
   Index.prototype.isObjectProperty = function () {
-    return this._dimensions.length === 1 && typeof this._dimensions[0] === 'string';
+    return this._dimensions.length === 1 && (0, _is.isString)(this._dimensions[0]);
   };
 
   /**
@@ -234,7 +233,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const array = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const dimension = this._dimensions[i];
-      array.push(typeof dimension === 'string' ? dimension : dimension.toArray());
+      array.push((0, _is.isString)(dimension) || (0, _is.isNumber)(dimension) ? dimension : dimension.toArray());
     }
     return array;
   };
@@ -256,7 +255,7 @@ const createIndexClass = exports.createIndexClass = /* #__PURE__ */(0, _factory.
     const strings = [];
     for (let i = 0, ii = this._dimensions.length; i < ii; i++) {
       const dimension = this._dimensions[i];
-      if (typeof dimension === 'string') {
+      if ((0, _is.isString)(dimension)) {
         strings.push(JSON.stringify(dimension));
       } else {
         strings.push(dimension.toString());

package/lib/cjs/type/matrix/SparseMatrix.js

@@ -304,12 +304,13 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     const pv = [];
 
     // loop rows in resulting matrix
-    rows.forEach(function (i, r) {
+    function rowsCallback(i, r) {
       // update permutation vector
       pv[i] = r[0];
       // mark i in workspace
       w[i] = true;
-    });
+    }
+    if (Number.isInteger(rows)) rowsCallback(rows, [0]);else rows.forEach(rowsCallback);
 
     // result matrix arrays
     const values = mvalues ? [] : undefined;
@@ -317,7 +318,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
     const ptr = [];
 
     // loop columns in result matrix
-    columns.forEach(function (j) {
+    function columnsCallback(j) {
       // update ptr
       ptr.push(index.length);
       // loop values in column j
@@ -334,7 +335,8 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
           }
         }
       }
-    });
+    }
+    if (Number.isInteger(columns)) columnsCallback(columns);else columns.forEach(columnsCallback);
     // update ptr
     ptr.push(index.length);
 
@@ -408,7 +410,7 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       if (iSize.length === 1) {
         // if the replacement index only has 1 dimension, go trough each one and set its value
         const range = index.dimension(0);
-        range.forEach(function (dataIndex, subIndex) {
+        _forEachIndex(range, (dataIndex, subIndex) => {
           (0, _array.validateIndex)(dataIndex);
           matrix.set([dataIndex, 0], submatrix[subIndex[0]], defaultValue);
         });
@@ -416,9 +418,9 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
         // if the replacement index has 2 dimensions, go through each one and set the value in the correct index
         const firstDimensionRange = index.dimension(0);
         const secondDimensionRange = index.dimension(1);
-        firstDimensionRange.forEach(function (firstDataIndex, firstSubIndex) {
+        _forEachIndex(firstDimensionRange, (firstDataIndex, firstSubIndex) => {
           (0, _array.validateIndex)(firstDataIndex);
-          secondDimensionRange.forEach(function (secondDataIndex, secondSubIndex) {
+          _forEachIndex(secondDimensionRange, (secondDataIndex, secondSubIndex) => {
             (0, _array.validateIndex)(secondDataIndex);
             matrix.set([firstDataIndex, secondDataIndex], submatrix[firstSubIndex[0]][secondSubIndex[0]], defaultValue);
           });
@@ -426,6 +428,10 @@ const createSparseMatrixClass = exports.createSparseMatrixClass = /* #__PURE__ *
       }
     }
     return matrix;
+    function _forEachIndex(index, callback) {
+      // iterate cases where index is a Matrix or a Number
+      if ((0, _is.isNumber)(index)) callback(index, [0]);else index.forEach(callback);
+    }
   }
 
   /**

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-const version = exports.version = '14.9.1';
+const version = exports.version = '15.0.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.