mathjs 12.4.2 → 13.0.0

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

@@ -5,16 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 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 _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); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-var name = 'matrixFromColumns';
-var dependencies = ['typed', 'matrix', 'flatten', 'size'];
-var createMatrixFromColumns = exports.createMatrixFromColumns = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    flatten = _ref.flatten,
-    size = _ref.size;
+const name = 'matrixFromColumns';
+const dependencies = ['typed', 'matrix', 'flatten', 'size'];
+const createMatrixFromColumns = exports.createMatrixFromColumns = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    flatten,
+    size
+  } = _ref;
   /**
    * Create a dense matrix from vectors as individual columns.
    * If you pass row vectors, they will be transposed (but not conjugated!)
@@ -38,53 +37,42 @@ var createMatrixFromColumns = exports.createMatrixFromColumns = /* #__PURE__ */(
    * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
    */
   return typed(name, {
-    '...Array': function Array(arr) {
+    '...Array': function (arr) {
       return _createArray(arr);
     },
-    '...Matrix': function Matrix(arr) {
-      return matrix(_createArray(arr.map(function (m) {
-        return m.toArray();
-      })));
+    '...Matrix': function (arr) {
+      return matrix(_createArray(arr.map(m => m.toArray())));
     }
 
     // TODO implement this properly for SparseMatrix
   });
   function _createArray(arr) {
     if (arr.length === 0) throw new TypeError('At least one column is needed to construct a matrix.');
-    var N = checkVectorTypeAndReturnLength(arr[0]);
+    const N = checkVectorTypeAndReturnLength(arr[0]);
 
     // create an array with empty rows
-    var result = [];
-    for (var i = 0; i < N; i++) {
+    const result = [];
+    for (let i = 0; i < N; i++) {
       result[i] = [];
     }
 
     // loop columns
-    var _iterator = _createForOfIteratorHelper(arr),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var col = _step.value;
-        var colLength = checkVectorTypeAndReturnLength(col);
-        if (colLength !== N) {
-          throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (colLength | 0));
-        }
-        var f = flatten(col);
+    for (const col of arr) {
+      const colLength = checkVectorTypeAndReturnLength(col);
+      if (colLength !== N) {
+        throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (colLength | 0));
+      }
+      const f = flatten(col);
 
-        // push a value to each row
-        for (var _i = 0; _i < N; _i++) {
-          result[_i].push(f[_i]);
-        }
+      // push a value to each row
+      for (let i = 0; i < N; i++) {
+        result[i].push(f[i]);
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
     return result;
   }
   function checkVectorTypeAndReturnLength(vec) {
-    var s = size(vec);
+    const s = size(vec);
     if (s.length === 1) {
       // 1D vector
       return s[0];

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

@@ -5,12 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createMatrixFromFunction = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'matrixFromFunction';
-var dependencies = ['typed', 'matrix', 'isZero'];
-var createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    isZero = _ref.isZero;
+const name = 'matrixFromFunction';
+const dependencies = ['typed', 'matrix', 'isZero'];
+const createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    isZero
+  } = _ref;
   /**
    * Create a matrix by evaluating a generating function at each index.
    * The simplest overload returns a multi-dimensional array as long as `size` is an array.
@@ -41,27 +43,27 @@ var createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__ *
    * @return {Array | Matrix} Returns the created matrix
    */
   return typed(name, {
-    'Array | Matrix, function, string, string': function ArrayMatrixFunctionStringString(size, fn, format, datatype) {
+    'Array | Matrix, function, string, string': function (size, fn, format, datatype) {
       return _create(size, fn, format, datatype);
     },
-    'Array | Matrix, function, string': function ArrayMatrixFunctionString(size, fn, format) {
+    'Array | Matrix, function, string': function (size, fn, format) {
       return _create(size, fn, format);
     },
-    'Matrix, function': function MatrixFunction(size, fn) {
+    'Matrix, function': function (size, fn) {
       return _create(size, fn, 'dense');
     },
-    'Array, function': function ArrayFunction(size, fn) {
+    'Array, function': function (size, fn) {
       return _create(size, fn, 'dense').toArray();
     },
-    'Array | Matrix, string, function': function ArrayMatrixStringFunction(size, format, fn) {
+    'Array | Matrix, string, function': function (size, format, fn) {
       return _create(size, fn, format);
     },
-    'Array | Matrix, string, string, function': function ArrayMatrixStringStringFunction(size, format, datatype, fn) {
+    'Array | Matrix, string, string, function': function (size, format, datatype, fn) {
       return _create(size, fn, format, datatype);
     }
   });
   function _create(size, fn, format, datatype) {
-    var m;
+    let m;
     if (datatype !== undefined) {
       m = matrix(format, datatype);
     } else {
@@ -69,7 +71,7 @@ var createMatrixFromFunction = exports.createMatrixFromFunction = /* #__PURE__ *
     }
     m.resize(size);
     m.forEach(function (_, index) {
-      var val = fn(index);
+      const val = fn(index);
       if (isZero(val)) return;
       m.set(index, val);
     });

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

@@ -5,16 +5,15 @@ Object.defineProperty(exports, "__esModule", {
 });
 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 _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); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-var name = 'matrixFromRows';
-var dependencies = ['typed', 'matrix', 'flatten', 'size'];
-var createMatrixFromRows = exports.createMatrixFromRows = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    flatten = _ref.flatten,
-    size = _ref.size;
+const name = 'matrixFromRows';
+const dependencies = ['typed', 'matrix', 'flatten', 'size'];
+const createMatrixFromRows = exports.createMatrixFromRows = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    flatten,
+    size
+  } = _ref;
   /**
    * Create a dense matrix from vectors as individual rows.
    * If you pass column vectors, they will be transposed (but not conjugated!)
@@ -38,41 +37,30 @@ var createMatrixFromRows = exports.createMatrixFromRows = /* #__PURE__ */(0, _fa
    * @return { number[][] | Matrix } if at least one of the arguments is an array, an array will be returned
    */
   return typed(name, {
-    '...Array': function Array(arr) {
+    '...Array': function (arr) {
       return _createArray(arr);
     },
-    '...Matrix': function Matrix(arr) {
-      return matrix(_createArray(arr.map(function (m) {
-        return m.toArray();
-      })));
+    '...Matrix': function (arr) {
+      return matrix(_createArray(arr.map(m => m.toArray())));
     }
 
     // TODO implement this properly for SparseMatrix
   });
   function _createArray(arr) {
     if (arr.length === 0) throw new TypeError('At least one row is needed to construct a matrix.');
-    var N = checkVectorTypeAndReturnLength(arr[0]);
-    var result = [];
-    var _iterator = _createForOfIteratorHelper(arr),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var row = _step.value;
-        var rowLength = checkVectorTypeAndReturnLength(row);
-        if (rowLength !== N) {
-          throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (rowLength | 0));
-        }
-        result.push(flatten(row));
+    const N = checkVectorTypeAndReturnLength(arr[0]);
+    const result = [];
+    for (const row of arr) {
+      const rowLength = checkVectorTypeAndReturnLength(row);
+      if (rowLength !== N) {
+        throw new TypeError('The vectors had different length: ' + (N | 0) + ' ≠ ' + (rowLength | 0));
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+      result.push(flatten(row));
     }
     return result;
   }
   function checkVectorTypeAndReturnLength(vec) {
-    var s = size(vec);
+    const s = size(vec);
     if (s.length === 1) {
       // 1D vector
       return s[0];

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

@@ -8,13 +8,15 @@ 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 name = 'ones';
-var dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
-var createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    matrix = _ref.matrix,
-    BigNumber = _ref.BigNumber;
+const name = 'ones';
+const dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
+const createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    matrix,
+    BigNumber
+  } = _ref;
   /**
    * Create a matrix filled with ones. The created matrix can have one or
    * multiple dimensions.
@@ -50,15 +52,15 @@ var createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {Array | Matrix | number}  A matrix filled with ones
    */
   return typed('ones', {
-    '': function _() {
+    '': function () {
       return config.matrix === 'Array' ? _ones([]) : _ones([], 'default');
     },
     // math.ones(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
-    '...number | BigNumber | string': function numberBigNumberString(size) {
-      var last = size[size.length - 1];
+    '...number | BigNumber | string': function (size) {
+      const last = size[size.length - 1];
       if (typeof last === 'string') {
-        var format = size.pop();
+        const format = size.pop();
         return _ones(size, format);
       } else if (config.matrix === 'Array') {
         return _ones(size);
@@ -67,11 +69,11 @@ var createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name,
       }
     },
     Array: _ones,
-    Matrix: function Matrix(size) {
-      var format = size.storage();
+    Matrix: function (size) {
+      const format = size.storage();
       return _ones(size.valueOf(), format);
     },
-    'Array | Matrix, string': function ArrayMatrixString(size, format) {
+    'Array | Matrix, string': function (size, format) {
       return _ones(size.valueOf(), format);
     }
   });
@@ -84,19 +86,19 @@ var createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name,
    * @private
    */
   function _ones(size, format) {
-    var hasBigNumbers = _normalize(size);
-    var defaultValue = hasBigNumbers ? new BigNumber(1) : 1;
+    const hasBigNumbers = _normalize(size);
+    const defaultValue = hasBigNumbers ? new BigNumber(1) : 1;
     _validate(size);
     if (format) {
       // return a matrix
-      var m = matrix(format);
+      const m = matrix(format);
       if (size.length > 0) {
         return m.resize(size, defaultValue);
       }
       return m;
     } else {
       // return an Array
-      var arr = [];
+      const arr = [];
       if (size.length > 0) {
         return (0, _array.resize)(arr, size, defaultValue);
       }
@@ -106,7 +108,7 @@ var createOnes = exports.createOnes = /* #__PURE__ */(0, _factory.factory)(name,
 
   // replace BigNumbers with numbers, returns true if size contained BigNumbers
   function _normalize(size) {
-    var hasBigNumbers = false;
+    let hasBigNumbers = false;
     size.forEach(function (value, index, arr) {
       if ((0, _is.isBigNumber)(value)) {
         hasBigNumbers = true;

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

@@ -7,17 +7,17 @@ exports.createPartitionSelect = void 0;
 var _is = require("../../utils/is.js");
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
-var name = 'partitionSelect';
-var dependencies = ['typed', 'isNumeric', 'isNaN', 'compare'];
-var createPartitionSelect = exports.createPartitionSelect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    isNumeric = _ref.isNumeric,
-    isNaN = _ref.isNaN,
-    compare = _ref.compare;
-  var asc = compare;
-  var desc = function desc(a, b) {
-    return -compare(a, b);
-  };
+const name = 'partitionSelect';
+const dependencies = ['typed', 'isNumeric', 'isNaN', 'compare'];
+const createPartitionSelect = exports.createPartitionSelect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isNumeric,
+    isNaN,
+    compare
+  } = _ref;
+  const asc = compare;
+  const desc = (a, b) => -compare(a, b);
 
   /**
    * Partition-based selection of an array or 1D matrix.
@@ -57,10 +57,10 @@ var createPartitionSelect = exports.createPartitionSelect = /* #__PURE__ */(0, _
    * @return {*} Returns the kth lowest value.
    */
   return typed(name, {
-    'Array | Matrix, number': function ArrayMatrixNumber(x, k) {
+    'Array | Matrix, number': function (x, k) {
       return _partitionSelect(x, k, asc);
     },
-    'Array | Matrix, number, string': function ArrayMatrixNumberString(x, k, compare) {
+    'Array | Matrix, number, string': function (x, k, compare) {
       if (compare === 'asc') {
         return _partitionSelect(x, k, asc);
       } else if (compare === 'desc') {
@@ -76,7 +76,7 @@ var createPartitionSelect = exports.createPartitionSelect = /* #__PURE__ */(0, _
       throw new Error('k must be a non-negative integer');
     }
     if ((0, _is.isMatrix)(x)) {
-      var size = x.size();
+      const size = x.size();
       if (size.length > 1) {
         throw new Error('Only one dimensional matrices supported');
       }
@@ -103,26 +103,26 @@ var createPartitionSelect = exports.createPartitionSelect = /* #__PURE__ */(0, _
     }
 
     // check for NaN values since these can cause an infinite while loop
-    for (var i = 0; i < arr.length; i++) {
+    for (let i = 0; i < arr.length; i++) {
       if (isNumeric(arr[i]) && isNaN(arr[i])) {
         return arr[i]; // return NaN
       }
     }
-    var from = 0;
-    var to = arr.length - 1;
+    let from = 0;
+    let to = arr.length - 1;
 
     // if from == to we reached the kth element
     while (from < to) {
-      var r = from;
-      var w = to;
-      var pivot = arr[Math.floor(Math.random() * (to - from + 1)) + from];
+      let r = from;
+      let w = to;
+      const pivot = arr[Math.floor(Math.random() * (to - from + 1)) + from];
 
       // stop if the reader and writer meets
       while (r < w) {
         // arr[r] >= pivot
         if (compare(arr[r], pivot) >= 0) {
           // put the large values at the end
-          var tmp = arr[w];
+          const tmp = arr[w];
           arr[w] = arr[r];
           arr[r] = tmp;
           --w;

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

@@ -9,21 +9,23 @@ var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
-var name = 'pinv';
-var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
-var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    inv = _ref.inv,
-    deepEqual = _ref.deepEqual,
-    equal = _ref.equal,
-    dotDivide = _ref.dotDivide,
-    dot = _ref.dot,
-    ctranspose = _ref.ctranspose,
-    divideScalar = _ref.divideScalar,
-    multiply = _ref.multiply,
-    add = _ref.add,
-    Complex = _ref.Complex;
+const name = 'pinv';
+const dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+const createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    inv,
+    deepEqual,
+    equal,
+    dotDivide,
+    dot,
+    ctranspose,
+    divideScalar,
+    multiply,
+    add,
+    Complex
+  } = _ref;
   /**
    * Calculate the Moore–Penrose inverse of a matrix.
    *
@@ -45,8 +47,8 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {number | Complex | Array | Matrix} The inverse of `x`.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(x) {
-      var size = (0, _is.isMatrix)(x) ? x.size() : (0, _array.arraySize)(x);
+    'Array | Matrix': function (x) {
+      const size = (0, _is.isMatrix)(x) ? x.size() : (0, _array.arraySize)(x);
       switch (size.length) {
         case 1:
           // vector
@@ -60,8 +62,8 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
           // two dimensional array
           {
             if (_isZeros(x)) return ctranspose(x); // zero matrixx
-            var rows = size[0];
-            var cols = size[1];
+            const rows = size[0];
+            const cols = size[1];
             if (rows === cols) {
               try {
                 return inv(x); // invertible matrix
@@ -85,7 +87,7 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
           throw new RangeError('Matrix must be two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
       }
     },
-    any: function any(x) {
+    any: function (x) {
       // scalar
       if (equal(x, 0)) return (0, _object.clone)(x); // zero
       return divideScalar(1, x);
@@ -101,11 +103,12 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
    * @private
    */
   function _pinv(mat, rows, cols) {
-    var _rankFact2 = _rankFact(mat, rows, cols),
-      C = _rankFact2.C,
-      F = _rankFact2.F; // TODO: Use SVD instead (may improve precision)
-    var Cpinv = multiply(inv(multiply(ctranspose(C), C)), ctranspose(C));
-    var Fpinv = multiply(ctranspose(F), inv(multiply(F, ctranspose(F))));
+    const {
+      C,
+      F
+    } = _rankFact(mat, rows, cols); // TODO: Use SVD instead (may improve precision)
+    const Cpinv = multiply(inv(multiply(ctranspose(C), C)), ctranspose(C));
+    const Fpinv = multiply(ctranspose(F), inv(multiply(F, ctranspose(F))));
     return multiply(Fpinv, Cpinv);
   }
 
@@ -121,13 +124,13 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
    * @private
    */
   function _rref(mat, rows, cols) {
-    var M = (0, _object.clone)(mat);
-    var lead = 0;
-    for (var r = 0; r < rows; r++) {
+    const M = (0, _object.clone)(mat);
+    let lead = 0;
+    for (let r = 0; r < rows; r++) {
       if (cols <= lead) {
         return M;
       }
-      var i = r;
+      let i = r;
       while (_isZero(M[i][lead])) {
         i++;
         if (rows === i) {
@@ -138,18 +141,16 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
           }
         }
       }
-      var _ref2 = [M[r], M[i]];
-      M[i] = _ref2[0];
-      M[r] = _ref2[1];
-      var val = M[r][lead];
-      for (var j = 0; j < cols; j++) {
+      [M[i], M[r]] = [M[r], M[i]];
+      let val = M[r][lead];
+      for (let j = 0; j < cols; j++) {
         M[r][j] = dotDivide(M[r][j], val);
       }
-      for (var _i = 0; _i < rows; _i++) {
-        if (_i === r) continue;
-        val = M[_i][lead];
-        for (var _j = 0; _j < cols; _j++) {
-          M[_i][_j] = add(M[_i][_j], multiply(-1, multiply(val, M[r][_j])));
+      for (let i = 0; i < rows; i++) {
+        if (i === r) continue;
+        val = M[i][lead];
+        for (let j = 0; j < cols; j++) {
+          M[i][j] = add(M[i][j], multiply(-1, multiply(val, M[r][j])));
         }
       }
       lead++;
@@ -167,18 +168,12 @@ var createPinv = exports.createPinv = /* #__PURE__ */(0, _factory.factory)(name,
    * @private
    */
   function _rankFact(mat, rows, cols) {
-    var rref = _rref(mat, rows, cols);
-    var C = mat.map(function (_, i) {
-      return _.filter(function (_, j) {
-        return j < rows && !_isZero(dot(rref[j], rref[j]));
-      });
-    });
-    var F = rref.filter(function (_, i) {
-      return !_isZero(dot(rref[i], rref[i]));
-    });
+    const rref = _rref(mat, rows, cols);
+    const C = mat.map((_, i) => _.filter((_, j) => j < rows && !_isZero(dot(rref[j], rref[j]))));
+    const F = rref.filter((_, i) => !_isZero(dot(rref[i], rref[i])));
     return {
-      C: C,
-      F: F
+      C,
+      F
     };
   }
   function _isZero(x) {