mathjs 10.0.0 → 10.6.4

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

@@ -14,14 +14,15 @@ var _string = require("../../utils/string.js");
 var _factory = require("../../utils/factory.js");
 
 var name = 'det';
-var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'unaryMinus', 'lup'];
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
 var createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       matrix = _ref.matrix,
       subtract = _ref.subtract,
       multiply = _ref.multiply,
-      unaryMinus = _ref.unaryMinus,
-      lup = _ref.lup;
+      divideScalar = _ref.divideScalar,
+      isZero = _ref.isZero,
+      unaryMinus = _ref.unaryMinus;
 
   /**
    * Calculate the determinant of a matrix.
@@ -115,42 +116,47 @@ var createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
       return subtract(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
     } else {
-      // Compute the LU decomposition
-      var decomp = lup(matrix); // The determinant is the product of the diagonal entries of U (and those of L, but they are all 1)
-
-      var det = decomp.U[0][0];
-
-      for (var _i = 1; _i < rows; _i++) {
-        det = multiply(det, decomp.U[_i][_i]);
-      } // The determinant will be multiplied by 1 or -1 depending on the parity of the permutation matrix.
-      // This can be determined by counting the cycles. This is roughly a linear time algorithm.
-
-
-      var evenCycles = 0;
-      var i = 0;
-      var visited = [];
+      // Bareiss algorithm
+      // this algorithm have same complexity as LUP decomposition (O(n^3))
+      // but it preserve precision of floating point more relative to the LUP decomposition
+      var negated = false;
+      var rowIndices = new Array(rows).fill(0).map(function (_, i) {
+        return i;
+      }); // matrix index of row i
+
+      for (var k = 0; k < rows; k++) {
+        var k_ = rowIndices[k];
+
+        if (isZero(matrix[k_][k])) {
+          var _k = void 0;
+
+          for (_k = k + 1; _k < rows; _k++) {
+            if (!isZero(matrix[rowIndices[_k]][k])) {
+              k_ = rowIndices[_k];
+              rowIndices[_k] = rowIndices[k];
+              rowIndices[k] = k_;
+              negated = !negated;
+              break;
+            }
+          }
 
-      while (true) {
-        while (visited[i]) {
-          i++;
+          if (_k === rows) return matrix[k_][k]; // some zero of the type
         }
 
-        if (i >= rows) break;
-        var j = i;
-        var cycleLen = 0;
+        var piv = matrix[k_][k];
+        var piv_ = k === 0 ? 1 : matrix[rowIndices[k - 1]][k - 1];
 
-        while (!visited[decomp.p[j]]) {
-          visited[decomp.p[j]] = true;
-          j = decomp.p[j];
-          cycleLen++;
-        }
+        for (var i = k + 1; i < rows; i++) {
+          var i_ = rowIndices[i];
 
-        if (cycleLen % 2 === 0) {
-          evenCycles++;
+          for (var j = k + 1; j < rows; j++) {
+            matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
+          }
         }
       }
 
-      return evenCycles % 2 === 0 ? det : unaryMinus(det);
+      var det = matrix[rowIndices[rows - 1]][rows - 1];
+      return negated ? unaryMinus(det) : det;
     }
   }
 });

package/lib/cjs/function/matrix/eigs/complexEigs.js

@@ -11,7 +11,7 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 
 var _object = require("../../../utils/object.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -54,33 +54,37 @@ function createComplexEigs(_ref) {
     } // TODO check if any row/col are zero except the diagonal
     // make sure corresponding rows and columns have similar magnitude
     // important because of numerical stability
+    // MODIFIES arr by side effect!
 
 
     var R = balance(arr, N, prec, type, findVectors); // R is the row transformation matrix
-    // A' = R A R⁻¹, A is the original matrix
+    // arr = A' = R A R⁻¹, A is the original matrix
     // (if findVectors is false, R is undefined)
+    // (And so to return to original matrix: A = R⁻¹ arr R)
     // TODO if magnitudes of elements vary over many orders,
     // move greatest elements to the top left corner
     // using similarity transformations, reduce the matrix
     // to Hessenberg form (upper triangular plus one subdiagonal row)
     // updates the transformation matrix R with new row operationsq
+    // MODIFIES arr by side effect!
 
-    reduceToHessenberg(arr, N, prec, type, findVectors, R); // find eigenvalues
+    reduceToHessenberg(arr, N, prec, type, findVectors, R); // still true that original A = R⁻¹ arr R)
+    // find eigenvalues
 
     var _iterateUntilTriangul = iterateUntilTriangular(arr, N, prec, type, findVectors),
         values = _iterateUntilTriangul.values,
         C = _iterateUntilTriangul.C; // values is the list of eigenvalues, C is the column
-    // transformation matrix that transforms the hessenberg
-    // matrix to upper triangular
-    // compose transformations A → hess. and hess. → triang.
+    // transformation matrix that transforms arr, the hessenberg
+    // matrix, to upper triangular
+    // (So U = C⁻¹ arr C and the relationship between current arr
+    // and original A is unchanged.)
 
 
-    C = multiply(inv(R), C);
     var vectors;
 
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, values, prec, type);
-      vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2["default"])(vectors));
+      vectors = findEigenvectors(arr, N, C, R, values, prec, type);
+      vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2.default)(vectors));
     }
 
     return {
@@ -100,8 +104,9 @@ function createComplexEigs(_ref) {
   function balance(arr, N, prec, type, findVectors) {
     var big = type === 'BigNumber';
     var cplx = type === 'Complex';
-    var zero = big ? bignumber(0) : cplx ? complex(0) : 0;
-    var one = big ? bignumber(1) : cplx ? complex(1) : 1; // base of the floating-point arithmetic
+    var realzero = big ? bignumber(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    var realone = big ? bignumber(1) : 1; // base of the floating-point arithmetic
 
     var radix = big ? bignumber(10) : 2;
     var radixSq = multiplyScalar(radix, radix); // the diagonal transformation matrix R
@@ -122,12 +127,13 @@ function createComplexEigs(_ref) {
       for (var i = 0; i < N; i++) {
         // compute the taxicab norm of i-th column and row
         // TODO optimize for complex numbers
-        var colNorm = zero;
-        var rowNorm = zero;
+        var colNorm = realzero;
+        var rowNorm = realzero;
 
         for (var j = 0; j < N; j++) {
           if (i === j) continue;
-          var c = abs(arr[i][j]);
+          var c = abs(arr[i][j]); // should be real
+
           colNorm = addScalar(colNorm, c);
           rowNorm = addScalar(rowNorm, c);
         }
@@ -136,7 +142,7 @@ function createComplexEigs(_ref) {
           // find integer power closest to balancing the matrix
           // (we want to scale only by integer powers of radix,
           // so that we don't lose any precision due to round-off)
-          var f = one;
+          var f = realone;
           var _c = colNorm;
           var rowDivRadix = divideScalar(rowNorm, radix);
           var rowMulRadix = multiplyScalar(rowNorm, radix);
@@ -360,7 +366,7 @@ function createComplexEigs(_ref) {
       } else if (n === 2 || smaller(abs(arr[n - 2][n - 3]), prec)) {
         lastConvergenceBefore = 0;
         var ll = eigenvalues2x2(arr[n - 2][n - 2], arr[n - 2][n - 1], arr[n - 1][n - 2], arr[n - 1][n - 1]);
-        lambdas.push.apply(lambdas, (0, _toConsumableArray2["default"])(ll)); // keep track of transformations
+        lambdas.push.apply(lambdas, (0, _toConsumableArray2.default)(ll)); // keep track of transformations
 
         if (findVectors) {
           Sdiag.unshift(jordanBase2x2(arr[n - 2][n - 2], arr[n - 2][n - 1], arr[n - 1][n - 2], arr[n - 1][n - 1], ll[0], ll[1], prec, type));
@@ -410,16 +416,17 @@ function createComplexEigs(_ref) {
     };
   }
   /**
-   * @param {Matrix} A original matrix
+   * @param {Matrix} A hessenberg-form matrix
    * @param {number} N size of A
    * @param {Matrix} C column transformation matrix that turns A into upper triangular
+   * @param {Matrix} R similarity that turns original matrix into A
    * @param {number[]} values array of eigenvalues of A
    * @param {'number'|'BigNumber'|'Complex'} type
    * @returns {number[][]} eigenvalues
    */
 
 
-  function findEigenvectors(A, N, C, values, prec, type) {
+  function findEigenvectors(A, N, C, R, values, prec, type) {
     var Cinv = inv(C);
     var U = multiply(Cinv, A, C);
     var big = type === 'BigNumber';
@@ -436,12 +443,12 @@ function createComplexEigs(_ref) {
 
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _λ = _step.value;
+        var λ = _step.value;
 
-        var _i4 = indexOf(uniqueValues, _λ, equal);
+        var _i4 = indexOf(uniqueValues, λ, equal);
 
         if (_i4 === -1) {
-          uniqueValues.push(_λ);
+          uniqueValues.push(λ);
           multiplicities.push(1);
         } else {
           multiplicities[_i4] += 1;
@@ -463,21 +470,16 @@ function createComplexEigs(_ref) {
 
     var failedLambdas = [];
 
-    for (var i = 0; i < len; i++) {
+    var _loop = function _loop(i) {
       var λ = uniqueValues[i];
+      var S = subtract(U, multiply(λ, E)); // the characteristic matrix
 
-      var _A = subtract(U, multiply(λ, E)); // the characteristic matrix
-
-
-      var solutions = usolveAll(_A, b);
-      solutions = solutions.map(function (v) {
-        return multiply(C, v);
-      });
+      var solutions = usolveAll(S, b);
       solutions.shift(); // ignore the null vector
       // looks like we missed something, try inverse iteration
 
       while (solutions.length < multiplicities[i]) {
-        var approxVec = inverseIterate(_A, N, solutions, prec, type);
+        var approxVec = inverseIterate(S, N, solutions, prec, type);
 
         if (approxVec == null) {
           // no more vectors were found
@@ -486,11 +488,20 @@ function createComplexEigs(_ref) {
         }
 
         solutions.push(approxVec);
-      }
+      } // Transform back into original array coordinates
+
 
-      vectors.push.apply(vectors, (0, _toConsumableArray2["default"])(solutions.map(function (v) {
+      var correction = multiply(inv(R), C);
+      solutions = solutions.map(function (v) {
+        return multiply(correction, v);
+      });
+      vectors.push.apply(vectors, (0, _toConsumableArray2.default)(solutions.map(function (v) {
         return flatten(v);
       })));
+    };
+
+    for (var i = 0; i < len; i++) {
+      _loop(i);
     }
 
     if (failedLambdas.length !== 0) {
@@ -568,7 +579,7 @@ function createComplexEigs(_ref) {
     for (var i = 0; i < arr.length; i++) {
       var _arr$i;
 
-      (_arr$i = arr[i]).push.apply(_arr$i, (0, _toConsumableArray2["default"])(Array(N - arr[i].length).fill(0)));
+      (_arr$i = arr[i]).push.apply(_arr$i, (0, _toConsumableArray2.default)(Array(N - arr[i].length).fill(0)));
     } // add rows
 
 

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

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFft = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'fft';
+var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'divideScalar', 'exp', 'tau', 'i'];
+var createFft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      matrix = _ref.matrix,
+      addScalar = _ref.addScalar,
+      multiplyScalar = _ref.multiplyScalar,
+      divideScalar = _ref.divideScalar,
+      exp = _ref.exp,
+      tau = _ref.tau,
+      I = _ref.i;
+
+  /**
+   * Calculate N-dimensional fourier transform
+   *
+   * Syntax:
+   *
+   *     math.fft(arr)
+   *
+   * Examples:
+   *
+   *    math.fft([[1, 0], [1, 0]]) // returns [[{re:2, im:0}, {re:2, im:0}], [{re:0, im:0}, {re:0, im:0}]]
+   *
+   *
+   * See Also:
+   *
+   *      ifft
+   *
+   * @param {Array | Matrix} arr    An array or matrix
+   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   */
+  return typed(name, {
+    Array: _ndFft,
+    Matrix: function Matrix(matrix) {
+      return matrix.create(_ndFft(matrix.toArray()));
+    }
+  });
+  /**
+   * Perform an N-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @return {Array}         resulting array
+   */
+
+  function _ndFft(arr) {
+    var size = (0, _array.arraySize)(arr);
+    if (size.length === 1) return _fft(arr, size[0]); // ndFft along dimension 1,...,N-1 then 1dFft along dimension 0
+
+    return _1dFft(arr.map(function (slice) {
+      return _ndFft(slice, size.slice(1));
+    }), 0);
+  }
+  /**
+   * Perform an 1-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @param {number} dim     dimension of the array to perform on
+   * @return {Array}         resulting array
+   */
+
+
+  function _1dFft(arr, dim) {
+    var size = (0, _array.arraySize)(arr);
+    if (dim !== 0) return new Array(size[0]).fill(0).map(function (_, i) {
+      return _1dFft(arr[i], dim - 1);
+    });
+    if (size.length === 1) return _fft(arr);
+
+    function _transpose(arr) {
+      // Swap first 2 dimensions
+      var size = (0, _array.arraySize)(arr);
+      return new Array(size[1]).fill(0).map(function (_, j) {
+        return new Array(size[0]).fill(0).map(function (_, i) {
+          return arr[i][j];
+        });
+      });
+    }
+
+    return _transpose(_1dFft(_transpose(arr), 1));
+  }
+  /**
+   * Perform an 1-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @return {Array}         resulting array
+   */
+
+
+  function _fft(arr) {
+    var len = arr.length;
+    if (len === 1) return [arr[0]];
+
+    if (len % 2 === 0) {
+      var ret = [].concat((0, _toConsumableArray2.default)(_fft(arr.filter(function (_, i) {
+        return i % 2 === 0;
+      }), len / 2)), (0, _toConsumableArray2.default)(_fft(arr.filter(function (_, i) {
+        return i % 2 === 1;
+      }), len / 2)));
+
+      for (var k = 0; k < len / 2; k++) {
+        var p = ret[k];
+        var q = multiplyScalar(ret[k + len / 2], exp(multiplyScalar(multiplyScalar(tau, I), divideScalar(-k, len))));
+        ret[k] = addScalar(p, q);
+        ret[k + len / 2] = addScalar(p, multiplyScalar(-1, q));
+      }
+
+      return ret;
+    }
+
+    throw new Error('Can only calculate FFT of power-of-two size');
+  }
+});
+exports.createFft = createFft;

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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIfft = void 0;
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _is = require("../../utils/is.js");
+
+var name = 'ifft';
+var dependencies = ['typed', 'fft', 'dotDivide', 'conj'];
+var createIfft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      fft = _ref.fft,
+      dotDivide = _ref.dotDivide,
+      conj = _ref.conj;
+
+  /**
+   * Calculate N-dimensional inverse fourier transform
+   *
+   * Syntax:
+   *
+   *     math.ifft(arr)
+   *
+   * Examples:
+   *
+   *    math.ifft([[2, 2], [0, 0]]) // returns [[{re:1, im:0}, {re:0, im:0}], [{re:1, im:0}, {re:0, im:0}]]
+   *
+   * See Also:
+   *
+   *      fft
+   *
+   * @param {Array | Matrix} arr    An array or matrix
+   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(arr) {
+      var size = (0, _is.isMatrix)(arr) ? arr.size() : (0, _array.arraySize)(arr);
+      return dotDivide(conj(fft(conj(arr))), size.reduce(function (acc, curr) {
+        return acc * curr;
+      }, 1));
+    }
+  });
+});
+exports.createIfft = createIfft;

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

@@ -15,8 +15,15 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   var typed = _ref.typed;
 
   /**
-   * Create a new matrix or array with the results of the callback function executed on
-   * each entry of the matrix/array.
+   * Create a new matrix or array with the results of a callback function executed on
+   * each entry of a given matrix/array.
+   *
+   * For each entry of the input, the callback is invoked with three arguments:
+   * the value of the entry, the index at which that entry occurs, and the full
+   * matrix/array being traversed. Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
    *
    * Syntax:
    *
@@ -28,15 +35,25 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
+   *    // The calling convention for the callback can cause subtleties:
+   *    math.map([1, 2, 3], math.format)
+   *    // throws TypeError: map attempted to call 'format(1,[0])' but argument 2 of type Array does not match expected type number or function or Object or string or boolean
+   *    // [This happens because `format` _can_ take a second argument,
+   *    // but its semantics don't match that of the 2nd argument `map` provides]
+   *
+   *    // To avoid this error, use a function that takes exactly the
+   *    // desired arguments:
+   *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *
    * See also:
    *
    *    filter, forEach, sort
    *
-   * @param {Matrix | Array} x    The matrix to iterate on.
-   * @param {Function} callback   The callback method is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the matrix being traversed.
-   * @return {Matrix | array}     Transformed map of x
+   * @param {Matrix | Array} x    The input to iterate on.
+   * @param {Function} callback
+   *     The function to call (as described above) on each entry of the input
+   * @return {Matrix | array}
+   *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
     'Array, function': _map,
@@ -66,14 +83,35 @@ function _map(array, callback) {
         return recurse(child, index.concat(i));
       });
     } else {
-      // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        return callback(value);
-      } else if (args === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, array);
+      try {
+        // invoke the callback function with the right number of arguments
+        if (args === 1) {
+          return callback(value);
+        } else if (args === 2) {
+          return callback(value, index);
+        } else {
+          // 3 or -1
+          return callback(value, index, array);
+        }
+      } catch (err) {
+        // But maybe the arguments still weren't right
+        if (err instanceof TypeError && 'data' in err && err.data.category === 'wrongType') {
+          var newmsg = "map attempted to call '".concat(err.data.fn, "(").concat(value);
+          var indexString = JSON.stringify(index);
+
+          if (args === 2) {
+            newmsg += ',' + indexString;
+          } else if (args !== 1) {
+            newmsg += ",".concat(indexString, ",").concat(array);
+          }
+
+          newmsg += ")' but argument ".concat(err.data.index + 1, " of type ");
+          newmsg += "".concat(err.data.actual, " does not match expected type ");
+          newmsg += err.data.expected.join(' or ');
+          throw new TypeError(newmsg);
+        }
+
+        throw err;
       }
     }
   };

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

@@ -7,7 +7,7 @@ exports.createMatrixFromColumns = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 

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

@@ -7,7 +7,7 @@ exports.createMatrixFromRows = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }