mathjs 11.9.1 → 11.10.0

package/lib/cjs/expression/transform/subset.transform.js

@@ -8,13 +8,17 @@ var _factory = require("../../utils/factory.js");
 var _errorTransform = require("./utils/errorTransform.js");
 var _subset = require("../../function/matrix/subset.js");
 var name = 'subset';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
 var createSubsetTransform = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-    matrix = _ref.matrix;
+    matrix = _ref.matrix,
+    zeros = _ref.zeros,
+    add = _ref.add;
   var subset = (0, _subset.createSubset)({
     typed: typed,
-    matrix: matrix
+    matrix: matrix,
+    zeros: zeros,
+    add: add
   });
 
   /**

package/lib/cjs/factoriesAny.js

@@ -1485,6 +1485,12 @@ Object.defineProperty(exports, "createQuantileSeq", {
     return _quantileSeq.createQuantileSeq;
   }
 });
+Object.defineProperty(exports, "createQuantileSeqTransform", {
+  enumerable: true,
+  get: function get() {
+    return _quantileSeqTransform.createQuantileSeqTransform;
+  }
+});
 Object.defineProperty(exports, "createQuantumOfCirculation", {
   enumerable: true,
   get: function get() {
@@ -2109,6 +2115,12 @@ Object.defineProperty(exports, "createZeros", {
     return _zeros.createZeros;
   }
 });
+Object.defineProperty(exports, "createZeta", {
+  enumerable: true,
+  get: function get() {
+    return _zeta.createZeta;
+  }
+});
 Object.defineProperty(exports, "createZpk2tf", {
   enumerable: true,
   get: function get() {
@@ -2213,6 +2225,7 @@ var _fft = require("./function/matrix/fft.js");
 var _ifft = require("./function/matrix/ifft.js");
 var _solveODE = require("./function/numeric/solveODE.js");
 var _erf = require("./function/special/erf.js");
+var _zeta = require("./function/special/zeta.js");
 var _mode = require("./function/statistics/mode.js");
 var _prod = require("./function/statistics/prod.js");
 var _format = require("./function/string/format.js");
@@ -2398,5 +2411,6 @@ var _concatTransform = require("./expression/transform/concat.transform.js");
 var _diffTransform = require("./expression/transform/diff.transform.js");
 var _stdTransform = require("./expression/transform/std.transform.js");
 var _sumTransform = require("./expression/transform/sum.transform.js");
+var _quantileSeqTransform = require("./expression/transform/quantileSeq.transform.js");
 var _cumsumTransform = require("./expression/transform/cumsum.transform.js");
 var _varianceTransform = require("./expression/transform/variance.transform.js");

package/lib/cjs/factoriesNumber.js

@@ -779,6 +779,12 @@ Object.defineProperty(exports, "createVersion", {
 });
 exports.createXgcd = void 0;
 exports.createXor = void 0;
+Object.defineProperty(exports, "createZeta", {
+  enumerable: true,
+  get: function get() {
+    return _zeta.createZeta;
+  }
+});
 var _index = require("./plain/number/index.js");
 var _factory = require("./utils/factory.js");
 var _noop = require("./utils/noop.js");
@@ -855,6 +861,7 @@ var _largerEq = require("./function/relational/largerEq.js");
 var _deepEqual = require("./function/relational/deepEqual.js");
 var _unequal = require("./function/relational/unequal.js");
 var _erf = require("./function/special/erf.js");
+var _zeta = require("./function/special/zeta.js");
 var _mode = require("./function/statistics/mode.js");
 var _prod = require("./function/statistics/prod.js");
 var _max = require("./function/statistics/max.js");

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

@@ -97,7 +97,7 @@ var createConcat = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
       }
       var res = matrices.shift();
       while (matrices.length) {
-        res = _concat(res, matrices.shift(), dim, 0);
+        res = (0, _array.concat)(res, matrices.shift(), dim);
       }
       return asMatrix ? matrix(res) : res;
     },
@@ -106,31 +106,4 @@ var createConcat = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     }
   });
 });
-
-/**
- * Recursively concatenate two matrices.
- * The contents of the matrices is not cloned.
- * @param {Array} a             Multi dimensional array
- * @param {Array} b             Multi dimensional array
- * @param {number} concatDim    The dimension on which to concatenate (zero-based)
- * @param {number} dim          The current dim (zero-based)
- * @return {Array} c            The concatenated matrix
- * @private
- */
-exports.createConcat = createConcat;
-function _concat(a, b, concatDim, dim) {
-  if (dim < concatDim) {
-    // recurse into next dimension
-    if (a.length !== b.length) {
-      throw new _DimensionError.DimensionError(a.length, b.length);
-    }
-    var c = [];
-    for (var i = 0; i < a.length; i++) {
-      c[i] = _concat(a[i], b[i], concatDim, dim + 1);
-    }
-    return c;
-  } else {
-    // concatenate this dimension
-    return a.concat(b);
-  }
-}
+exports.createConcat = createConcat;

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

@@ -11,10 +11,12 @@ var _customs = require("../../utils/customs.js");
 var _DimensionError = require("../../error/DimensionError.js");
 var _factory = require("../../utils/factory.js");
 var name = 'subset';
-var dependencies = ['typed', 'matrix'];
+var dependencies = ['typed', 'matrix', 'zeros', 'add'];
 var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-    matrix = _ref.matrix;
+    matrix = _ref.matrix,
+    zeros = _ref.zeros,
+    add = _ref.add;
   /**
    * Get or set a subset of a matrix or string.
    *
@@ -26,13 +28,15 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    *     // 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(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]]
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
-   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 0, 6]]
+   *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 0, 6], [0, 7, 0]]
+   *     math.subset(g, math.index([false, true], 1), 8)          // returns [[5, 0, 6], [0, 8, 0]]
    *
    *     // get submatrix using ranges
    *     const M = [
@@ -40,7 +44,7 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *       [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]]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1, 2, 3], [4, 5, 6]]
    *
    * See also:
    *
@@ -59,36 +63,80 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *                                          math.matrix elements will be left undefined.
    * @return {Array | Matrix | string} Either the retrieved subset or the updated matrix.
    */
+
   return typed(name, {
     // get subset
-    'Array, Index': function ArrayIndex(value, index) {
-      var m = matrix(value);
-      var subset = m.subset(index); // returns a Matrix
-      return index.isScalar() ? subset : subset.valueOf(); // return an Array (like the input)
-    },
-
     'Matrix, Index': function MatrixIndex(value, index) {
+      if ((0, _array.isEmptyIndex)(index)) {
+        return matrix();
+      }
+      (0, _array.validateIndexSourceSize)(value, index);
       return value.subset(index);
     },
+    'Array, Index': typed.referTo('Matrix, Index', function (subsetRef) {
+      return function (value, index) {
+        var subsetResult = subsetRef(matrix(value), index);
+        return index.isScalar() ? subsetResult : subsetResult.valueOf();
+      };
+    }),
     'Object, Index': _getObjectProperty,
     'string, Index': _getSubstring,
     // set subset
-    'Array, Index, any': function ArrayIndexAny(value, index, replacement) {
-      return matrix((0, _object.clone)(value)).subset(index, replacement, undefined).valueOf();
-    },
-    'Array, Index, any, any': function ArrayIndexAnyAny(value, index, replacement, defaultValue) {
-      return matrix((0, _object.clone)(value)).subset(index, replacement, defaultValue).valueOf();
-    },
-    'Matrix, Index, any': function MatrixIndexAny(value, index, replacement) {
-      return value.clone().subset(index, replacement);
-    },
     'Matrix, Index, any, any': function MatrixIndexAnyAny(value, index, replacement, defaultValue) {
-      return value.clone().subset(index, replacement, defaultValue);
+      if ((0, _array.isEmptyIndex)(index)) {
+        return value;
+      }
+      (0, _array.validateIndexSourceSize)(value, index);
+      return value.clone().subset(index, _broadcastReplacement(replacement, index), defaultValue);
     },
+    'Array, Index, any, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement, defaultValue) {
+        var subsetResult = subsetRef(matrix(value), index, replacement, defaultValue);
+        return subsetResult.isMatrix ? subsetResult.valueOf() : subsetResult;
+      };
+    }),
+    'Array, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(matrix(value), index, replacement, undefined).valueOf();
+      };
+    }),
+    'Matrix, Index, any': typed.referTo('Matrix, Index, any, any', function (subsetRef) {
+      return function (value, index, replacement) {
+        return subsetRef(value, index, replacement, undefined);
+      };
+    }),
     'string, Index, string': _setSubstring,
     'string, Index, string, string': _setSubstring,
     'Object, Index, any': _setObjectProperty
   });
+
+  /**
+   * Broadcasts a replacment value to be the same size as index
+   * @param {number | BigNumber | Array | Matrix} replacement Replacement value to try to broadcast
+   * @param {*} index Index value
+   * @returns broadcasted replacement that matches the size of index
+   */
+
+  function _broadcastReplacement(replacement, index) {
+    if (typeof replacement === 'string') {
+      throw new Error('can\'t boradcast a string');
+    }
+    if (index._isScalar) {
+      return replacement;
+    }
+    var indexSize = index.size();
+    if (indexSize.every(function (d) {
+      return d > 0;
+    })) {
+      try {
+        return add(replacement, zeros(indexSize));
+      } catch (error) {
+        return replacement;
+      }
+    } else {
+      return replacement;
+    }
+  }
 });
 
 /**
@@ -104,6 +152,10 @@ function _getSubstring(str, index) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
+  if ((0, _array.isEmptyIndex)(index)) {
+    return '';
+  }
+  (0, _array.validateIndexSourceSize)(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new _DimensionError.DimensionError(index.size().length, 1);
   }
@@ -125,7 +177,7 @@ function _getSubstring(str, index) {
  * @param {string} str            string to be replaced
  * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
- * @param {string} [defaultValue] Default value to be uses when resizing
+ * @param {string} [defaultValue] Default value to be used when resizing
  *                                the string. is ' ' by default
  * @returns {string} result
  * @private
@@ -135,6 +187,10 @@ function _setSubstring(str, index, replacement, defaultValue) {
     // TODO: better error message
     throw new TypeError('Index expected');
   }
+  if ((0, _array.isEmptyIndex)(index)) {
+    return str;
+  }
+  (0, _array.validateIndexSourceSize)(Array.from(str), index);
   if (index.size().length !== 1) {
     throw new _DimensionError.DimensionError(index.size().length, 1);
   }
@@ -184,6 +240,9 @@ function _setSubstring(str, index, replacement, defaultValue) {
  * @private
  */
 function _getObjectProperty(object, index) {
+  if ((0, _array.isEmptyIndex)(index)) {
+    return undefined;
+  }
   if (index.size().length !== 1) {
     throw new _DimensionError.DimensionError(index.size(), 1);
   }
@@ -203,6 +262,9 @@ function _getObjectProperty(object, index) {
  * @private
  */
 function _setObjectProperty(object, index, replacement) {
+  if ((0, _array.isEmptyIndex)(index)) {
+    return object;
+  }
   if (index.size().length !== 1) {
     throw new _DimensionError.DimensionError(index.size(), 1);
   }

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

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createZeta = void 0;
+var _factory = require("../../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 createZeta = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    multiply = _ref.multiply,
+    pow = _ref.pow,
+    divide = _ref.divide,
+    factorial = _ref.factorial,
+    equal = _ref.equal,
+    smallerEq = _ref.smallerEq,
+    isNegative = _ref.isNegative,
+    gamma = _ref.gamma,
+    sin = _ref.sin,
+    subtract = _ref.subtract,
+    add = _ref.add,
+    Complex = _ref.Complex,
+    _BigNumber = _ref.BigNumber,
+    pi = _ref.pi;
+  /**
+   * Compute the Riemann Zeta function of a value using an infinite series for
+   * all of the complex plane using Riemann's Functional equation.
+   *
+   * Based off the paper by Xavier Gourdon and Pascal Sebah
+   * ( http://numbers.computation.free.fr/Constants/Miscellaneous/zetaevaluations.pdf )
+   *
+   * Implementation and slight modification by Anik Patel
+   *
+   * Note: the implementation is accurate up to about 6 digits.
+   *
+   * Syntax:
+   *
+   *    math.zeta(n)
+   *
+   * Examples:
+   *
+   *    math.zeta(5)       // returns 1.0369277551433895
+   *    math.zeta(-0.5)    // returns -0.2078862249773449
+   *    math.zeta(math.i)  // returns 0.0033002236853253153 - 0.4181554491413212i
+   *
+   *
+   * @param {number | Complex | BigNumber} s   A Real, Complex or BigNumber parameter to the Riemann Zeta Function
+   * @return {number | Complex | BigNumber}    The Riemann Zeta of `s`
+   */
+  return typed(name, {
+    number: function number(s) {
+      return zetaNumeric(s, function (value) {
+        return value;
+      }, function () {
+        return 20;
+      });
+    },
+    BigNumber: function BigNumber(s) {
+      return zetaNumeric(s, function (value) {
+        return new _BigNumber(value);
+      }, function () {
+        // epsilon is for example 1e-12. Extract the positive exponent 12 from that
+        return Math.abs(Math.log10(config.epsilon));
+      });
+    },
+    Complex: zetaComplex
+  });
+
+  /**
+   * @param {number | BigNumber} s
+   * @param {(value: number) => number | BigNumber} createValue
+   * @param {(value: number | BigNumber | Complex) => number} determineDigits
+   * @returns {number | BigNumber}
+   */
+  function zetaNumeric(s, createValue, determineDigits) {
+    if (equal(s, 0)) {
+      return createValue(-0.5);
+    }
+    if (equal(s, 1)) {
+      return createValue(NaN);
+    }
+    if (!isFinite(s)) {
+      return isNegative(s) ? createValue(NaN) : createValue(1);
+    }
+    return zeta(s, createValue, determineDigits, function (s) {
+      return s;
+    });
+  }
+
+  /**
+   * @param {Complex} s
+   * @returns {Complex}
+   */
+  function zetaComplex(s) {
+    if (s.re === 0 && s.im === 0) {
+      return new Complex(-0.5);
+    }
+    if (s.re === 1) {
+      return new Complex(NaN, NaN);
+    }
+    if (s.re === Infinity && s.im === 0) {
+      return new Complex(1);
+    }
+    if (s.im === Infinity || s.re === -Infinity) {
+      return new Complex(NaN, NaN);
+    }
+    return zeta(s, function (value) {
+      return value;
+    }, function (s) {
+      return Math.round(1.3 * 15 + 0.9 * Math.abs(s.im));
+    }, function (s) {
+      return s.re;
+    });
+  }
+
+  /**
+   * @param {number | BigNumber | Complex} s
+   * @param {(value: number) => number | BigNumber | Complex} createValue
+   * @param {(value: number | BigNumber | Complex) => number} determineDigits
+   * @param {(value: number | BigNumber | Complex) => number} getRe
+   * @returns {*|number}
+   */
+  function zeta(s, createValue, determineDigits, getRe) {
+    var n = determineDigits(s);
+    if (getRe(s) > -(n - 1) / 2) {
+      return f(s, createValue(n), createValue);
+    } else {
+      // Function Equation for reflection to x < 1
+      var c = multiply(pow(2, s), pow(createValue(pi), subtract(s, 1)));
+      c = multiply(c, sin(multiply(divide(createValue(pi), 2), s)));
+      c = multiply(c, gamma(subtract(1, s)));
+      return multiply(c, zeta(subtract(1, s), createValue, determineDigits, getRe));
+    }
+  }
+
+  /**
+   * Calculate a portion of the sum
+   * @param {number | BigNumber} k   a positive integer
+   * @param {number | BigNumber} n   a positive integer
+   * @return {number}    the portion of the sum
+   **/
+  function d(k, n) {
+    var S = k;
+    for (var j = k; smallerEq(j, n); j = add(j, 1)) {
+      var factor = divide(multiply(factorial(add(n, subtract(j, 1))), pow(4, j)), multiply(factorial(subtract(n, j)), factorial(multiply(2, j))));
+      S = add(S, factor);
+    }
+    return multiply(n, S);
+  }
+
+  /**
+   * Calculate the positive Riemann Zeta function
+   * @param {number} s   a real or complex number with s.re > 1
+   * @param {number} n   a positive integer
+   * @param {(number) => number | BigNumber | Complex} createValue
+   * @return {number}    Riemann Zeta of s
+   **/
+  function f(s, n, createValue) {
+    var c = divide(1, multiply(d(createValue(0), n), subtract(1, pow(2, subtract(1, s)))));
+    var S = createValue(0);
+    for (var k = createValue(1); smallerEq(k, n); k = add(k, 1)) {
+      S = add(S, divide(multiply(Math.pow(-1, k - 1), d(k, n)), pow(k, s)));
+    }
+    return multiply(c, S);
+  }
+});
+exports.createZeta = createZeta;

package/lib/cjs/function/statistics/quantileSeq.js

@@ -5,17 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createQuantileSeq = void 0;
 var _is = require("../../utils/is.js");
-var _number = require("../../utils/number.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
+var _apply = require("../matrix/apply.js");
 var name = 'quantileSeq';
-var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare'];
+var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare', 'isInteger'];
 var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     add = _ref.add,
     multiply = _ref.multiply,
     partitionSelect = _ref.partitionSelect,
-    compare = _ref.compare;
+    compare = _ref.compare,
+    isInteger = _ref.isInteger;
   /**
    * Compute the prob order quantile of a matrix or a list with values.
    * The sequence is sorted and the middle value is returned.
@@ -50,6 +51,40 @@ var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @param {Boolean} sorted=false              is data sorted in ascending order
    * @return {Number, BigNumber, Unit, Array}   Quantile(s)
    */
+
+  var apply = (0, _apply.createApply)({
+    typed: typed,
+    isInteger: isInteger
+  });
+  /**
+   * Check if array value types are valid, throw error otherwise.
+   * @param {number | BigNumber | Unit} x
+   * @param {number | BigNumber | Unit} x
+   * @private
+   */
+  var validate = typed({
+    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
+      return x;
+    }
+  });
+  return typed(name, {
+    'Array|Matrix, number|BigNumber|Array': function ArrayMatrixNumberBigNumberArray(data, prob) {
+      return quantileSeq(data, prob, false);
+    },
+    'Array|Matrix, number|BigNumber|Array, boolean': quantileSeq,
+    'Array|Matrix, number|BigNumber|Array, number': function ArrayMatrixNumberBigNumberArrayNumber(data, prob, dim) {
+      return _quantileSeqDim(data, prob, false, dim);
+    },
+    'Array|Matrix, number|BigNumber|Array, boolean, number': function ArrayMatrixNumberBigNumberArrayBooleanNumber(data, prob, sorted, dim) {
+      return _quantileSeqDim(data, prob, sorted, dim);
+    }
+  });
+  function _quantileSeqDim(data, prob, sorted, dim) {
+    // return [1.3, 1.2]
+    return apply(data, dim, function (x) {
+      return quantileSeq(x, prob, sorted);
+    });
+  }
   function quantileSeq(data, probOrN, sorted) {
     var probArr, dataArr, one;
     if (arguments.length < 2 || arguments.length > 3) {
@@ -69,7 +104,7 @@ var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
           }
           if (probOrN > 1) {
             // quantileSeq([a, b, c, d, ...], N[,sorted])
-            if (!(0, _number.isInteger)(probOrN)) {
+            if (!isInteger(probOrN)) {
               throw new Error('N must be a positive integer');
             }
             var nPlusOne = probOrN + 1;
@@ -223,18 +258,5 @@ var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     var one = new fracPart.constructor(1);
     return add(multiply(left, one.minus(fracPart)), multiply(right, fracPart));
   }
-
-  /**
-   * Check if array value types are valid, throw error otherwise.
-   * @param {number | BigNumber | Unit} x
-   * @param {number | BigNumber | Unit} x
-   * @private
-   */
-  var validate = typed({
-    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
-      return x;
-    }
-  });
-  return quantileSeq;
 });
 exports.createQuantileSeq = createQuantileSeq;

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 11.9.1
- * @date    2023-07-24
+ * @version 11.10.0
+ * @date    2023-08-23
  *
  * @license
  * Copyright (C) 2013-2023 Jos de Jong <wjosdejong@gmail.com>

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

@@ -339,6 +339,18 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
     } else {
       // set a submatrix
 
+      // broadcast submatrix
+      if (!(0, _object.deepStrictEqual)(sSize, iSize)) {
+        try {
+          if (sSize.length === 0) {
+            submatrix = (0, _array.broadcastTo)([submatrix], iSize);
+          } else {
+            submatrix = (0, _array.broadcastTo)(submatrix, iSize);
+          }
+          sSize = (0, _array.arraySize)(submatrix);
+        } catch (_unused) {}
+      }
+
       // validate dimensions
       if (iSize.length < matrix._size.length) {
         throw new _DimensionError.DimensionError(iSize.length, matrix._size.length, '<');
@@ -975,19 +987,17 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
 
   /**
    * Preprocess data, which can be an Array or DenseMatrix with nested Arrays and
-   * Matrices. Replaces all nested Matrices with Arrays
+   * Matrices. Clones all (nested) Arrays, and replaces all nested Matrices with Arrays
    * @memberof DenseMatrix
-   * @param {Array} data
+   * @param {Array | Matrix} data
    * @return {Array} data
    */
   function preprocess(data) {
-    for (var i = 0, ii = data.length; i < ii; i++) {
-      var elem = data[i];
-      if ((0, _is.isArray)(elem)) {
-        data[i] = preprocess(elem);
-      } else if (elem && elem.isMatrix === true) {
-        data[i] = preprocess(elem.valueOf());
-      }
+    if ((0, _is.isMatrix)(data)) {
+      return preprocess(data.valueOf());
+    }
+    if ((0, _is.isArray)(data)) {
+      return data.map(preprocess);
     }
     return data;
   }