mathjs 14.9.1 → 15.1.0

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

@@ -52,8 +52,9 @@ export var createRow = /* #__PURE__ */factory(name, dependencies, _ref => {
     }
     validateIndex(row, value.size()[0]);
     var columnRange = range(0, value.size()[1]);
-    var index = new Index(row, columnRange);
+    var index = new Index([row], columnRange);
     var result = value.subset(index);
+    // once config.legacySubset just return result
     return isMatrix(result) ? result : matrix([[result]]);
   }
 });

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

@@ -1,16 +1,16 @@
 import { arraySize } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
-import { noMatrix } from '../../utils/noop.js';
 var name = 'size';
-var dependencies = ['typed', 'config', '?matrix'];
+var dependencies = ['typed'];
 export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    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:
    *
@@ -30,19 +30,13 @@ export var createSize = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     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 Matrix(x) {
-      return x.create(x.size(), 'number');
-    },
+    Matrix: x => x.size(),
     Array: arraySize,
-    string: function string(x) {
-      return config.matrix === 'Array' ? [x.length] : matrix([x.length], 'dense', 'number');
-    },
-    'number | Complex | BigNumber | Unit | boolean | null': function number__Complex__BigNumber__Unit__boolean__null(x) {
-      // scalar
-      return config.matrix === 'Array' ? [] : matrix ? matrix([], 'dense', 'number') : noMatrix();
-    }
+    string: x => [x.length],
+    // scalar
+    'number | Complex | BigNumber | Unit | boolean | null': _x => []
   });
 });

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

@@ -25,8 +25,8 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *     // 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 = []
@@ -36,9 +36,9 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     // 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]]
    *
@@ -117,7 +117,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
     if (typeof replacement === 'string') {
       throw new Error('can\'t boradcast a string');
     }
-    if (index._isScalar) {
+    if (index.isScalar()) {
       return replacement;
     }
     var indexSize = index.size();
@@ -159,9 +159,14 @@ function _getSubstring(str, index) {
   validateIndex(index.max()[0], strLen);
   var range = index.dimension(0);
   var substr = '';
-  range.forEach(function (v) {
+  function callback(v) {
     substr += str.charAt(v);
-  });
+  }
+  if (Number.isInteger(range)) {
+    callback(range);
+  } else {
+    range.forEach(callback);
+  }
   return substr;
 }
 
@@ -195,7 +200,7 @@ function _setSubstring(str, index, replacement, defaultValue) {
     defaultValue = ' ';
   }
   var range = index.dimension(0);
-  var len = range.size()[0];
+  var len = Number.isInteger(range) ? 1 : range.size()[0];
   if (len !== replacement.length) {
     throw new DimensionError(range.size()[0], replacement.length);
   }
@@ -210,9 +215,14 @@ function _setSubstring(str, index, replacement, defaultValue) {
   for (var 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/esm/function/probability/bernoulli.js

@@ -0,0 +1,102 @@
+import { factory } from '../../utils/factory.js';
+import { isInteger } from '../../utils/number.js';
+var name = 'bernoulli';
+var dependencies = ['typed', 'config', 'isInteger', 'number', '?BigNumber', '?Fraction'];
+export var createBernoulli = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    number,
+    BigNumber: _BigNumber,
+    Fraction
+  } = _ref;
+  /**
+   * Return the `n`th Bernoulli number, for positive integers `n`
+   *
+   * Syntax:
+   *
+   *     math.bernoulli(n)
+   *
+   * Examples:
+   *
+   *     math.bernoulli(1)                  // returns -0.5
+   *     // All other odd Bernoulli numbers are 0:
+   *     math.bernoulli(7)                  // returns 0
+   *     math.bernoulli(math.bignumber(6))  // value bignumber(1).div(42)
+   *     // Produces exact rationals for bigint or fraction input:
+   *     math.bernoulli(8n)                 // Fraction -1,30
+   *     math.bernoulli(math.fraction(10))  // Fraction 5,66
+   *
+   * See also:
+   *
+   *     combinations, gamma, stirlingS2
+   *
+   * @param {number | BigNumber | bigint | Fraction} n
+   *    Index of the Bernoulli number
+   * @return {number | BigNumber | Fraction}
+   *    nth Bernoulli number, of a type corresponding to the argument n
+   */
+
+  var numberCache = [undefined];
+  var fractionCache = [undefined];
+  var bigCache = [undefined];
+  var cachedPrecision = 50;
+  return typed(name, {
+    number: index => _bernoulli(index, n => n, numberCache, (a, b) => a + b, (a, b) => a * b, (a, b) => a / b),
+    'bigint | Fraction': index => _bernoulli(number(index), n => new Fraction(n), fractionCache, (a, b) => a.add(b), (a, b) => a.mul(b), (a, b) => a.div(b)),
+    BigNumber: index => {
+      if (config.precision !== cachedPrecision) {
+        bigCache = [undefined];
+        cachedPrecision = config.precision;
+      }
+      return _bernoulli(number(index), n => new _BigNumber(n), bigCache, (a, b) => a.add(b), (a, b) => a.mul(b), (a, b) => a.div(b));
+    }
+  });
+});
+
+/**
+ * Underlying implementation, with all operations passed in.
+ * Parameters:
+ * 1. index: a (positive integer) number specifying which Bernoulli number
+ *    to compute.
+ * 2. promote: a function that takes an integer number and returns
+ *    the desired type for the Bernoulli number values.
+ * 3. A: a cache array of partial computation data that _bernoulli should use.
+ *    Different cache arrays should be provided for different types.
+ * 4. plus: a function that adds two values of the desired type.
+ * 5. times: a function that multiplies two values of the desired type.
+ * 6. divide: a function that divides one value of the desired type by another.
+ */
+function _bernoulli(index, promote, A, plus, times, divide) {
+  if (index < 0 || !isInteger(index)) {
+    throw new RangeError('Bernoulli index must be nonnegative integer');
+  }
+  if (index === 0) return promote(1);
+  if (index === 1) return divide(promote(-1), promote(2));
+  if (index % 2 === 1) return promote(0);
+  // We proceed as in https://math.stackexchange.com/a/2844337
+  // (by no means the most efficient, but very simple to implement)
+  // A cache entry consists of a triple
+  // [cotangent coefficient a_n, prefactor, Bernouilli number B_2n]
+  var one = promote(1);
+  if (A.length === 1) {
+    A.push([divide(one, promote(-3)), divide(one, promote(-2)), divide(one, promote(6))]);
+  }
+  var half = index / 2;
+  var zero = promote(0);
+  var two = promote(2);
+  while (A.length <= half) {
+    var i = A.length; // next cotangent coefficient to compute
+    var lim = Math.floor((i + 1) / 2);
+    var a = zero;
+    for (var m = 1; m < lim; ++m) {
+      a = plus(a, times(A[m][0], A[i - m][0]));
+    }
+    a = times(a, two);
+    if (i % 2 === 0) a = plus(a, times(A[lim][0], A[lim][0]));
+    a = divide(a, promote(-(2 * i + 1)));
+    var prefactor = divide(times(A[i - 1][1], promote(-i * (2 * i - 1))), two);
+    A.push([a, prefactor, times(prefactor, a)]);
+  }
+  return A[half][2];
+}

package/lib/esm/function/relational/equal.js

@@ -4,7 +4,7 @@ import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
 import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
 import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'equal';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat', 'SparseMatrix'];
+var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'SparseMatrix'];
 export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -27,8 +27,7 @@ export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
   });
   var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
     typed,
-    matrix,
-    concat
+    matrix
   });
 
   /**

package/lib/esm/function/special/zeta.js

@@ -1,6 +1,6 @@
 import { factory } from '../../utils/factory.js';
 var name = 'zeta';
-var dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
+var dependencies = ['typed', 'config', 'multiply', 'pow', 'divide', 'factorial', 'equal', 'smallerEq', 'isBounded', 'isNegative', 'gamma', 'sin', 'subtract', 'add', '?Complex', '?BigNumber', 'pi'];
 export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,6 +11,7 @@ export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
     factorial,
     equal,
     smallerEq,
+    isBounded,
     isNegative,
     gamma,
     sin,
@@ -69,7 +70,7 @@ export var createZeta = /* #__PURE__ */factory(name, dependencies, _ref => {
     if (equal(s, 1)) {
       return createValue(NaN);
     }
-    if (!isFinite(s)) {
+    if (!isBounded(s)) {
       return isNegative(s) ? createValue(NaN) : createValue(1);
     }
     return zeta(s, createValue, determineDigits, s => s);

package/lib/esm/function/utils/isBounded.js

@@ -0,0 +1,48 @@
+import { factory } from '../../utils/factory.js';
+var name = 'isBounded';
+var dependencies = ['typed'];
+export var createIsBounded = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Test whether a value is bounded. For scalars, this test is equivalent
+   * to the isFinite finiteness test. On the other hand, a Matrix or Array
+   * is defined to be bounded if every entry is finite.
+   *
+   * Syntax:
+   *
+   *     math.isBounded(x)
+   *
+   * Examples:
+   *
+   *    math.isBounded(0)                        // returns true
+   *    math.isBounded(NaN)                      // returns false
+   *    math.isBounded(math.bignumber(Infinity)) // returns false
+   *    math.isBounded(math.fraction(1,3))       // returns true
+   *    math.isBounded(math.complex('2 - 4i'))   // returns true
+   *    math.isBounded(-10000000000000000n)      // returns true
+   *    math.isBounded(undefined)                // returns false
+   *    math.isBounded(null)                     // returns false
+   *    math.isBounded([0.001, -3n, 0])          // returns true
+   *    math.isBounded([2, -Infinity, -3])       // returns false
+   *
+   * See also:
+   *
+   *    isFinite, isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean}  Returns true when `x` is bounded.
+   */
+  return typed(name, {
+    number: n => Number.isFinite(n),
+    'BigNumber | Complex': x => x.isFinite(),
+    'bigint | Fraction': () => true,
+    'null | undefined': () => false,
+    Unit: typed.referToSelf(self => x => self(x.value)),
+    'Array | Matrix': typed.referToSelf(self => A => {
+      if (!Array.isArray(A)) A = A.valueOf();
+      return A.every(entry => self(entry));
+    })
+  });
+});

package/lib/esm/function/utils/isFinite.js

@@ -0,0 +1,44 @@
+import { factory } from '../../utils/factory.js';
+var name = 'isFinite';
+var dependencies = ['typed', 'isBounded', 'map'];
+export var createIsFinite = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isBounded,
+    map
+  } = _ref;
+  /**
+   * Test whether a value is finite.
+   *
+   * Operates elementwise on Array and Matrix values. To test if all entries
+   * of an Array or Matrix are finite, use isBounded.
+   *
+   * Syntax:
+   *
+   *     math.isFinite(x)
+   *
+   * Examples:
+   *
+   *    math.isFinite(0)                        // returns true
+   *    math.isFinite(NaN)                      // returns false
+   *    math.isFinite(math.bignumber(Infinity)) // returns false
+   *    math.isFinite(math.fraction(1,3))       // returns true
+   *    math.isFinite(math.complex('2 - 4i'))   // returns true
+   *    math.isFinite(-10000000000000000n)      // returns true
+   *    math.isFinite(undefined)                // returns false
+   *    math.isFinite(null)                     // returns false
+   *    math.isFinite([0.001, -3n, 0])          // Array [true, true, true]
+   *    math.isFinite([2, -Infinity, -3])       // Array [true, false, true]
+   *
+   * See also:
+   *
+   *    isBounded isNumeric, isPositive, isNegative, isNaN
+   *
+   * @param {number | BigNumber | bigint | Complex | Fraction | Unit | Array | Matrix} x       Value to be tested
+   * @return {boolean | Array | Matrix}
+   */
+  return typed(name, {
+    'Array | Matrix': A => map(A, isBounded),
+    any: x => isBounded(x)
+  });
+});

package/lib/esm/function/utils/isInteger.js

@@ -1,11 +1,11 @@
 import { deepMap } from '../../utils/collection.js';
-import { isInteger as isIntegerNumber } from '../../utils/number.js';
 import { factory } from '../../utils/factory.js';
 var name = 'isInteger';
-var dependencies = ['typed'];
+var dependencies = ['typed', 'equal'];
 export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    typed
+    typed,
+    equal
   } = _ref;
   /**
    * Test whether a value is an integer number.
@@ -37,18 +37,10 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
    *                    Throws an error in case of an unknown data type.
    */
   return typed(name, {
-    number: isIntegerNumber,
-    // TODO: what to do with isInteger(add(0.1, 0.2))  ?
-
-    BigNumber: function BigNumber(x) {
-      return x.isInt();
-    },
-    bigint: function bigint(x) {
-      return true;
-    },
-    Fraction: function Fraction(x) {
-      return x.d === 1n;
-    },
+    number: n => Number.isFinite(n) ? equal(n, Math.round(n)) : false,
+    BigNumber: b => b.isFinite() ? equal(b.round(), b) : false,
+    bigint: b => true,
+    Fraction: r => r.d === 1n,
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/function/utils/isNaN.js

@@ -30,7 +30,7 @@ export var createIsNaN = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * See also:
    *
-   *    isNumeric, isNegative, isPositive, isZero, isInteger
+   *    isNumeric, isNegative, isPositive, isZero, isInteger, isFinite, isBounded
    *
    * @param {number | BigNumber | bigint | Fraction | Unit | Array | Matrix} x  Value to be tested
    * @return {boolean}  Returns true when `x` is NaN.

package/lib/esm/function/utils/isNumeric.js

@@ -29,7 +29,7 @@ export var createIsNumeric = /* #__PURE__ */factory(name, dependencies, _ref =>
    *
    * See also:
    *
-   *    isZero, isPositive, isNegative, isInteger, hasNumericValue
+   *    isZero, isPositive, isNegative, isInteger, hasNumericValue, isFinite, isBounded
    *
    * @param {*} x       Value to be tested
    * @return {boolean}  Returns true when `x` is a `number`, `BigNumber`,

package/lib/esm/json/replacer.js

@@ -16,7 +16,7 @@ export var createReplacer = /* #__PURE__ */factory(name, dependencies, () => {
    */
   return function replacer(key, value) {
     // the numeric values Infinitiy, -Infinity, and NaN cannot be serialized to JSON
-    if (typeof value === 'number' && (!isFinite(value) || isNaN(value))) {
+    if (typeof value === 'number' && (!Number.isFinite(value) || isNaN(value))) {
       return {
         mathjs: 'number',
         value: String(value)

package/lib/esm/plain/number/probability.js

@@ -6,7 +6,7 @@ export function gammaNumber(n) {
   var x;
   if (isInteger(n)) {
     if (n <= 0) {
-      return isFinite(n) ? Infinity : NaN;
+      return Number.isFinite(n) ? Infinity : NaN;
     }
     if (n > 171) {
       return Infinity; // Will overflow
@@ -53,7 +53,7 @@ export var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941
 export function lgammaNumber(n) {
   if (n < 0) return NaN;
   if (n === 0) return Infinity;
-  if (!isFinite(n)) return n;
+  if (!Number.isFinite(n)) return n;
   if (n < 0.5) {
     // Use Euler's reflection formula:
     // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))

package/lib/esm/plain/number/trigonometry.js

@@ -14,7 +14,7 @@ export function acotNumber(x) {
 }
 acotNumber.signature = n1;
 export function acothNumber(x) {
-  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+  return Number.isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
 }
 acothNumber.signature = n1;
 export function acscNumber(x) {

package/lib/esm/type/fraction/function/fraction.js

@@ -46,7 +46,7 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed('fraction', {
     number: function number(x) {
-      if (!isFinite(x) || isNaN(x)) {
+      if (!Number.isFinite(x) || isNaN(x)) {
         throw new Error(x + ' cannot be represented as a fraction');
       }
       return new Fraction(x);

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

@@ -8,10 +8,11 @@ import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
 import { optimizeCallback } from '../../utils/optimizeCallback.js';
 var name = 'DenseMatrix';
-var dependencies = ['Matrix'];
+var dependencies = ['Matrix', 'config'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
-    Matrix
+    Matrix,
+    config
   } = _ref;
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
@@ -221,7 +222,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     if (!isIndex(index)) {
       throw new TypeError('Invalid index');
     }
-    var isScalar = index.isScalar();
+    var isScalar = config.legacySubset ? index.size().every(idx => idx === 1) : index.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
@@ -241,12 +242,12 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       }
 
       // retrieve submatrix
-      var returnMatrix = new DenseMatrix([]);
+      var returnMatrix = new DenseMatrix();
       var 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;
     }
   }
 
@@ -264,22 +265,30 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var size = Array(maxDepth);
     return {
       data: getSubmatrixRecursive(data),
-      size
+      size: size.filter(x => x !== null)
     };
     function getSubmatrixRecursive(data) {
       var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var ranges = index.dimension(depth);
-      size[depth] = ranges.size()[0];
+      var dims = index.dimension(depth);
+      function _mapIndex(dim, callback) {
+        // applies a callback for when the index is a Number or a Matrix
+        if (isNumber(dim)) return callback(dim);else return dim.map(callback).valueOf();
+      }
+      if (isNumber(dims)) {
+        size[depth] = null;
+      } else {
+        size[depth] = dims.size()[0];
+      }
       if (depth < maxDepth) {
-        return ranges.map(rangeIndex => {
-          validateIndex(rangeIndex, data.length);
-          return getSubmatrixRecursive(data[rangeIndex], depth + 1);
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          validateIndex(dimIndex, data.length);
+          return getSubmatrixRecursive(data[dimIndex], depth + 1);
+        });
       } else {
-        return ranges.map(rangeIndex => {
-          validateIndex(rangeIndex, data.length);
-          return data[rangeIndex];
-        }).valueOf();
+        return _mapIndex(dims, dimIndex => {
+          validateIndex(dimIndex, data.length);
+          return data[dimIndex];
+        });
       }
     }
   }
@@ -306,18 +315,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     var isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    var sSize;
+    var 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);
@@ -325,26 +334,26 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
       // set a submatrix
 
       // broadcast submatrix
-      if (!deepStrictEqual(sSize, iSize)) {
-        try {
-          if (sSize.length === 0) {
-            submatrix = broadcastTo([submatrix], iSize);
-          } else {
+      if (!deepStrictEqual(submatrixSize, iSize)) {
+        if (submatrixSize.length === 0) {
+          submatrix = broadcastTo([submatrix], iSize);
+        } else {
+          try {
             submatrix = broadcastTo(submatrix, iSize);
-          }
-          sSize = arraySize(submatrix);
-        } catch (_unused) {}
+          } catch (error) {}
+        }
+        submatrixSize = arraySize(submatrix);
       }
 
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new DimensionError(iSize.length, matrix._size.length, '<');
       }
-      if (sSize.length < iSize.length) {
+      if (submatrixSize.length < iSize.length) {
         // calculate number of missing outer dimensions
         var i = 0;
         var outer = 0;
-        while (iSize[i] === 1 && sSize[i] === 1) {
+        while (iSize[i] === 1 && submatrixSize[i] === 1) {
           i++;
         }
         while (iSize[i] === 1) {
@@ -353,12 +362,12 @@ export var 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
@@ -387,16 +396,18 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
     function setSubmatrixRecursive(data, submatrix) {
       var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       var range = index.dimension(depth);
+      var recursiveCallback = (rangeIndex, i) => {
+        validateIndex(rangeIndex, data.length);
+        setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
+      };
+      var finalCallback = (rangeIndex, i) => {
+        validateIndex(rangeIndex, data.length);
+        data[rangeIndex] = submatrix[i[0]];
+      };
       if (depth < maxDepth) {
-        range.forEach((rangeIndex, i) => {
-          validateIndex(rangeIndex, data.length);
-          setSubmatrixRecursive(data[rangeIndex], submatrix[i[0]], depth + 1);
-        });
+        if (isNumber(range)) recursiveCallback(range, [0]);else range.forEach(recursiveCallback);
       } else {
-        range.forEach((rangeIndex, i) => {
-          validateIndex(rangeIndex, data.length);
-          data[rangeIndex] = submatrix[i[0]];
-        });
+        if (isNumber(range)) finalCallback(range, [0]);else range.forEach(finalCallback);
       }
     }
   }