mathjs 12.4.2 → 13.0.0

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

@@ -1,29 +1,29 @@
 "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', 'dotDivide', 'conj', 'pow', 'ceil', 'log2'];
-var createFft = exports.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,
-    dotDivide = _ref.dotDivide,
-    conj = _ref.conj,
-    pow = _ref.pow,
-    ceil = _ref.ceil,
-    log2 = _ref.log2;
+const name = 'fft';
+const dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'divideScalar', 'exp', 'tau', 'i', 'dotDivide', 'conj', 'pow', 'ceil', 'log2'];
+const createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    addScalar,
+    multiplyScalar,
+    divideScalar,
+    exp,
+    tau,
+    i: I,
+    dotDivide,
+    conj,
+    pow,
+    ceil,
+    log2
+  } = _ref;
   /**
    * Calculate N-dimensional fourier transform
    *
@@ -45,7 +45,7 @@ var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, d
    */
   return typed(name, {
     Array: _ndFft,
-    Matrix: function Matrix(matrix) {
+    Matrix: function (matrix) {
       return matrix.create(_ndFft(matrix.toArray()));
     }
   });
@@ -57,12 +57,10 @@ var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, d
    * @return {Array}         resulting array
    */
   function _ndFft(arr) {
-    var size = (0, _array.arraySize)(arr);
+    const 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);
+    return _1dFft(arr.map(slice => _ndFft(slice, size.slice(1))), 0);
   }
 
   /**
@@ -73,19 +71,13 @@ var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, d
    * @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);
-    });
+    const size = (0, _array.arraySize)(arr);
+    if (dim !== 0) return new Array(size[0]).fill(0).map((_, i) => _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];
-        });
-      });
+      const size = (0, _array.arraySize)(arr);
+      return new Array(size[1]).fill(0).map((_, j) => new Array(size[0]).fill(0).map((_, i) => arr[i][j]));
     }
     return _transpose(_1dFft(_transpose(arr), 1));
   }
@@ -96,28 +88,22 @@ var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, d
    * @return {Array}         resulting array
    */
   function _czt(arr) {
-    var n = arr.length;
-    var w = exp(divideScalar(multiplyScalar(-1, multiplyScalar(I, tau)), n));
-    var chirp = [];
-    for (var i = 1 - n; i < n; i++) {
+    const n = arr.length;
+    const w = exp(divideScalar(multiplyScalar(-1, multiplyScalar(I, tau)), n));
+    const chirp = [];
+    for (let i = 1 - n; i < n; i++) {
       chirp.push(pow(w, divideScalar(pow(i, 2), 2)));
     }
-    var N2 = pow(2, ceil(log2(n + n - 1)));
-    var xp = [].concat((0, _toConsumableArray2["default"])(new Array(n).fill(0).map(function (_, i) {
-      return multiplyScalar(arr[i], chirp[n - 1 + i]);
-    })), (0, _toConsumableArray2["default"])(new Array(N2 - n).fill(0)));
-    var ichirp = [].concat((0, _toConsumableArray2["default"])(new Array(n + n - 1).fill(0).map(function (_, i) {
-      return divideScalar(1, chirp[i]);
-    })), (0, _toConsumableArray2["default"])(new Array(N2 - (n + n - 1)).fill(0)));
-    var fftXp = _fft(xp);
-    var fftIchirp = _fft(ichirp);
-    var fftProduct = new Array(N2).fill(0).map(function (_, i) {
-      return multiplyScalar(fftXp[i], fftIchirp[i]);
-    });
-    var ifftProduct = dotDivide(conj(_ndFft(conj(fftProduct))), N2);
-    var ret = [];
-    for (var _i = n - 1; _i < n + n - 1; _i++) {
-      ret.push(multiplyScalar(ifftProduct[_i], chirp[_i]));
+    const N2 = pow(2, ceil(log2(n + n - 1)));
+    const xp = [...new Array(n).fill(0).map((_, i) => multiplyScalar(arr[i], chirp[n - 1 + i])), ...new Array(N2 - n).fill(0)];
+    const ichirp = [...new Array(n + n - 1).fill(0).map((_, i) => divideScalar(1, chirp[i])), ...new Array(N2 - (n + n - 1)).fill(0)];
+    const fftXp = _fft(xp);
+    const fftIchirp = _fft(ichirp);
+    const fftProduct = new Array(N2).fill(0).map((_, i) => multiplyScalar(fftXp[i], fftIchirp[i]));
+    const ifftProduct = dotDivide(conj(_ndFft(conj(fftProduct))), N2);
+    const ret = [];
+    for (let i = n - 1; i < n + n - 1; i++) {
+      ret.push(multiplyScalar(ifftProduct[i], chirp[i]));
     }
     return ret;
   }
@@ -128,17 +114,13 @@ var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, d
    * @return {Array}         resulting array
    */
   function _fft(arr) {
-    var len = arr.length;
+    const 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))));
+      const ret = [..._fft(arr.filter((_, i) => i % 2 === 0), len / 2), ..._fft(arr.filter((_, i) => i % 2 === 1), len / 2)];
+      for (let k = 0; k < len / 2; k++) {
+        const p = ret[k];
+        const 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));
       }

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

@@ -7,10 +7,12 @@ exports.createFilter = void 0;
 var _applyCallback = require("../../utils/applyCallback.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'filter';
-var dependencies = ['typed'];
-var createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'filter';
+const dependencies = ['typed'];
+const createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Filter the items in an array or one dimensional matrix.
    *
@@ -42,11 +44,11 @@ var createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)(n
    */
   return typed('filter', {
     'Array, function': _filterCallback,
-    'Matrix, function': function MatrixFunction(x, test) {
+    'Matrix, function': function (x, test) {
       return x.create(_filterCallback(x.toArray(), test));
     },
     'Array, RegExp': _array.filterRegExp,
-    'Matrix, RegExp': function MatrixRegExp(x, test) {
+    'Matrix, RegExp': function (x, test) {
       return x.create((0, _array.filterRegExp)(x.toArray(), test));
     }
   });

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

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createFlatten = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'flatten';
-var dependencies = ['typed', 'matrix'];
-var createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix;
+const name = 'flatten';
+const dependencies = ['typed', 'matrix'];
+const createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix
+  } = _ref;
   /**
    * Flatten a multidimensional matrix into a single dimensional matrix.
    * A new matrix is returned, the original matrix is left untouched.
@@ -31,11 +33,11 @@ var createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factory)
    * @return {Matrix | Array} Returns the flattened matrix
    */
   return typed(name, {
-    Array: function Array(x) {
+    Array: function (x) {
       return (0, _array.flatten)(x);
     },
-    Matrix: function Matrix(x) {
-      var flat = (0, _array.flatten)(x.toArray());
+    Matrix: function (x) {
+      const flat = (0, _array.flatten)(x.toArray());
       // TODO: return the same matrix type as x (Dense or Sparse Matrix)
       return matrix(flat);
     }

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

@@ -7,10 +7,12 @@ exports.createForEach = void 0;
 var _applyCallback = require("../../utils/applyCallback.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'forEach';
-var dependencies = ['typed'];
-var createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'forEach';
+const dependencies = ['typed'];
+const createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Iterate over all elements of a matrix/array, and executes the given callback function.
    *
@@ -36,7 +38,7 @@ var createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)
    */
   return typed(name, {
     'Array, function': _forEach,
-    'Matrix, function': function MatrixFunction(x, callback) {
+    'Matrix, function': function (x, callback) {
       x.forEach(callback);
     }
   });
@@ -49,7 +51,7 @@ var createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)
  * @private
  */
 function _forEach(array, callback) {
-  var recurse = function recurse(value, index) {
+  const recurse = function (value, index) {
     if (Array.isArray(value)) {
       (0, _array.forEach)(value, function (child, i) {
         // we create a copy of the index array and append the new index value

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

@@ -7,10 +7,12 @@ exports.createGetMatrixDataType = void 0;
 var _factory = require("../../utils/factory.js");
 var _array = require("../../utils/array.js");
 var _is = require("../../utils/is.js");
-var name = 'getMatrixDataType';
-var dependencies = ['typed'];
-var createGetMatrixDataType = exports.createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'getMatrixDataType';
+const dependencies = ['typed'];
+const createGetMatrixDataType = exports.createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Find the data type of all elements in a matrix or array,
    * for example 'number' if all items are a number and 'Complex' if all values
@@ -46,10 +48,10 @@ var createGetMatrixDataType = exports.createGetMatrixDataType = /* #__PURE__ */(
    * @return {string} A string representation of the matrix type
    */
   return typed(name, {
-    Array: function Array(x) {
+    Array: function (x) {
       return (0, _array.getArrayDataType)(x, _is.typeOf);
     },
-    Matrix: function Matrix(x) {
+    Matrix: function (x) {
       return x.getDataType();
     }
   });

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

@@ -8,15 +8,17 @@ var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
-var name = 'identity';
-var dependencies = ['typed', 'config', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix'];
-var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    matrix = _ref.matrix,
-    BigNumber = _ref.BigNumber,
-    DenseMatrix = _ref.DenseMatrix,
-    SparseMatrix = _ref.SparseMatrix;
+const name = 'identity';
+const dependencies = ['typed', 'config', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix'];
+const createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    matrix,
+    BigNumber,
+    DenseMatrix,
+    SparseMatrix
+  } = _ref;
   /**
    * Create a 2-dimensional identity matrix with size m x n or n x n.
    * The matrix has ones on the diagonal and zeros elsewhere.
@@ -48,34 +50,34 @@ var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factor
    * @return {Matrix | Array | number} A matrix with ones on the diagonal.
    */
   return typed(name, {
-    '': function _() {
+    '': function () {
       return config.matrix === 'Matrix' ? matrix([]) : [];
     },
-    string: function string(format) {
+    string: function (format) {
       return matrix(format);
     },
-    'number | BigNumber': function numberBigNumber(rows) {
+    'number | BigNumber': function (rows) {
       return _identity(rows, rows, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber, string': function numberBigNumberString(rows, format) {
+    'number | BigNumber, string': function (rows, format) {
       return _identity(rows, rows, format);
     },
-    'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(rows, cols) {
+    'number | BigNumber, number | BigNumber': function (rows, cols) {
       return _identity(rows, cols, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber, number | BigNumber, string': function numberBigNumberNumberBigNumberString(rows, cols, format) {
+    'number | BigNumber, number | BigNumber, string': function (rows, cols, format) {
       return _identity(rows, cols, format);
     },
-    Array: function Array(size) {
+    Array: function (size) {
       return _identityVector(size);
     },
-    'Array, string': function ArrayString(size, format) {
+    'Array, string': function (size, format) {
       return _identityVector(size, format);
     },
-    Matrix: function Matrix(size) {
+    Matrix: function (size) {
       return _identityVector(size.valueOf(), size.storage());
     },
-    'Matrix, string': function MatrixString(size, format) {
+    'Matrix, string': function (size, format) {
       return _identityVector(size.valueOf(), format);
     }
   });
@@ -102,7 +104,7 @@ var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factor
    */
   function _identity(rows, cols, format) {
     // BigNumber constructor with the right precision
-    var Big = (0, _is.isBigNumber)(rows) || (0, _is.isBigNumber)(cols) ? BigNumber : null;
+    const Big = (0, _is.isBigNumber)(rows) || (0, _is.isBigNumber)(cols) ? BigNumber : null;
     if ((0, _is.isBigNumber)(rows)) rows = rows.toNumber();
     if ((0, _is.isBigNumber)(cols)) cols = cols.toNumber();
     if (!(0, _number.isInteger)(rows) || rows < 1) {
@@ -111,9 +113,9 @@ var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factor
     if (!(0, _number.isInteger)(cols) || cols < 1) {
       throw new Error('Parameters in function identity must be positive integers');
     }
-    var one = Big ? new BigNumber(1) : 1;
-    var defaultValue = Big ? new Big(0) : 0;
-    var size = [rows, cols];
+    const one = Big ? new BigNumber(1) : 1;
+    const defaultValue = Big ? new Big(0) : 0;
+    const size = [rows, cols];
 
     // check we need to return a matrix
     if (format) {
@@ -124,15 +126,15 @@ var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factor
       if (format === 'dense') {
         return DenseMatrix.diagonal(size, one, 0, defaultValue);
       }
-      throw new TypeError("Unknown matrix type \"".concat(format, "\""));
+      throw new TypeError(`Unknown matrix type "${format}"`);
     }
 
     // create and resize array
-    var res = (0, _array.resize)([], size, defaultValue);
+    const res = (0, _array.resize)([], size, defaultValue);
     // fill in ones on the diagonal
-    var minimum = rows < cols ? rows : cols;
+    const minimum = rows < cols ? rows : cols;
     // fill diagonal
-    for (var d = 0; d < minimum; d++) {
+    for (let d = 0; d < minimum; d++) {
       res[d][d] = one;
     }
     return res;

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

@@ -7,13 +7,15 @@ 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 = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    fft = _ref.fft,
-    dotDivide = _ref.dotDivide,
-    conj = _ref.conj;
+const name = 'ifft';
+const dependencies = ['typed', 'fft', 'dotDivide', 'conj'];
+const createIfft = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    fft,
+    dotDivide,
+    conj
+  } = _ref;
   /**
    * Calculate N-dimensional inverse fourier transform
    *
@@ -33,11 +35,9 @@ var createIfft = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(name,
    * @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));
+    'Array | Matrix': function (arr) {
+      const size = (0, _is.isMatrix)(arr) ? arr.size() : (0, _array.arraySize)(arr);
+      return dotDivide(conj(fft(conj(arr))), size.reduce((acc, curr) => acc * curr, 1));
     }
   });
 });

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

@@ -8,18 +8,20 @@ var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _string = require("../../utils/string.js");
-var name = 'inv';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'addScalar', 'multiply', 'unaryMinus', 'det', 'identity', 'abs'];
-var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    divideScalar = _ref.divideScalar,
-    addScalar = _ref.addScalar,
-    multiply = _ref.multiply,
-    unaryMinus = _ref.unaryMinus,
-    det = _ref.det,
-    identity = _ref.identity,
-    abs = _ref.abs;
+const name = 'inv';
+const dependencies = ['typed', 'matrix', 'divideScalar', 'addScalar', 'multiply', 'unaryMinus', 'det', 'identity', 'abs'];
+const createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    divideScalar,
+    addScalar,
+    multiply,
+    unaryMinus,
+    det,
+    identity,
+    abs
+  } = _ref;
   /**
    * Calculate the inverse of a square matrix.
    *
@@ -41,8 +43,8 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
    * @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
@@ -58,8 +60,8 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
         case 2:
           // two dimensional array
           {
-            var rows = size[0];
-            var cols = size[1];
+            const rows = size[0];
+            const cols = size[1];
             if (rows === cols) {
               if ((0, _is.isMatrix)(x)) {
                 return matrix(_inv(x.valueOf(), rows, cols), x.storage());
@@ -76,7 +78,7 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
           throw new RangeError('Matrix must be two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
       }
     },
-    any: function any(x) {
+    any: function (x) {
       // scalar
       return divideScalar(1, x); // FIXME: create a BigNumber one when configured for bignumbers
     }
@@ -91,7 +93,7 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
    * @private
    */
   function _inv(mat, rows, cols) {
-    var r, s, f, value, temp;
+    let r, s, f, value, temp;
     if (rows === 1) {
       // this is a 1 x 1 matrix
       value = mat[0][0];
@@ -101,7 +103,7 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
       return [[divideScalar(1, value)]];
     } else if (rows === 2) {
       // this is a 2 x 2 matrix
-      var d = det(mat);
+      const d = det(mat);
       if (d === 0) {
         throw Error('Cannot calculate inverse, determinant is zero');
       }
@@ -114,20 +116,20 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
       //      http://math.uww.edu/~mcfarlat/inverse.htm
 
       // make a copy of the matrix (only the arrays, not of the elements)
-      var A = mat.concat();
+      const A = mat.concat();
       for (r = 0; r < rows; r++) {
         A[r] = A[r].concat();
       }
 
       // create an identity matrix which in the end will contain the
       // matrix inverse
-      var B = identity(rows).valueOf();
+      const B = identity(rows).valueOf();
 
       // loop over all columns, and perform row reductions
-      for (var c = 0; c < cols; c++) {
+      for (let c = 0; c < cols; c++) {
         // Pivoting: Swap row c with row r, where row r contains the largest element A[r][c]
-        var ABig = abs(A[c][c]);
-        var rBig = c;
+        let ABig = abs(A[c][c]);
+        let rBig = c;
         r = c + 1;
         while (r < rows) {
           if (abs(A[r][c]) > ABig) {
@@ -150,11 +152,11 @@ var createInv = exports.createInv = /* #__PURE__ */(0, _factory.factory)(name, d
         }
 
         // eliminate non-zero values on the other rows at column c
-        var Ac = A[c];
-        var Bc = B[c];
+        const Ac = A[c];
+        const Bc = B[c];
         for (r = 0; r < rows; r++) {
-          var Ar = A[r];
-          var Br = B[r];
+          const Ar = A[r];
+          const Br = B[r];
           if (r !== c) {
             // eliminate value at column c and row r
             if (Ar[c] !== 0) {

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

@@ -6,12 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.createKron = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'kron';
-var dependencies = ['typed', 'matrix', 'multiplyScalar'];
-var createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    multiplyScalar = _ref.multiplyScalar;
+const name = 'kron';
+const dependencies = ['typed', 'matrix', 'multiplyScalar'];
+const createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    multiplyScalar
+  } = _ref;
   /**
      * Calculates the kronecker product of 2 matrices or vectors.
      *
@@ -40,13 +42,13 @@ var createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(name,
      * @return {Array | Matrix}       Returns the kronecker product of `x` and `y`
      */
   return typed(name, {
-    'Matrix, Matrix': function MatrixMatrix(x, y) {
+    'Matrix, Matrix': function (x, y) {
       return matrix(_kron(x.toArray(), y.toArray()));
     },
-    'Matrix, Array': function MatrixArray(x, y) {
+    'Matrix, Array': function (x, y) {
       return matrix(_kron(x.toArray(), y));
     },
-    'Array, Matrix': function ArrayMatrix(x, y) {
+    'Array, Matrix': function (x, y) {
       return matrix(_kron(x, y.toArray()));
     },
     'Array, Array': _kron
@@ -72,8 +74,8 @@ var createKron = exports.createKron = /* #__PURE__ */(0, _factory.factory)(name,
     if ((0, _array.arraySize)(a).length > 2 || (0, _array.arraySize)(b).length > 2) {
       throw new RangeError('Vectors with dimensions greater then 2 are not supported expected ' + '(Size x = ' + JSON.stringify(a.length) + ', y = ' + JSON.stringify(b.length) + ')');
     }
-    var t = [];
-    var r = [];
+    const t = [];
+    let r = [];
     return a.map(function (a) {
       return b.map(function (b) {
         r = [];

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createMap = void 0;
 var _applyCallback = require("../../utils/applyCallback.js");
 var _factory = require("../../utils/factory.js");
-var name = 'map';
-var dependencies = ['typed'];
-var createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'map';
+const dependencies = ['typed'];
+const createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Create a new matrix or array with the results of a callback function executed on
    * each entry of a given matrix/array.
@@ -48,7 +50,7 @@ var createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name, d
    */
   return typed(name, {
     'Array, function': _map,
-    'Matrix, function': function MatrixFunction(x, callback) {
+    'Matrix, function': function (x, callback) {
       return x.map(callback);
     }
   });
@@ -62,7 +64,7 @@ var createMap = exports.createMap = /* #__PURE__ */(0, _factory.factory)(name, d
  * @private
  */
 function _map(array, callback) {
-  var recurse = function recurse(value, index) {
+  const recurse = function (value, index) {
     if (Array.isArray(value)) {
       return value.map(function (child, i) {
         // we create a copy of the index array and append the new index value