mathjs 12.4.3 → 13.0.0

package/lib/cjs/function/algebra/sparse/csReach.js

@@ -27,21 +27,21 @@ var _csDfs = require("./csDfs.js");
  */
 function csReach(g, b, k, xi, pinv) {
   // g arrays
-  var gptr = g._ptr;
-  var gsize = g._size;
+  const gptr = g._ptr;
+  const gsize = g._size;
   // b arrays
-  var bindex = b._index;
-  var bptr = b._ptr;
+  const bindex = b._index;
+  const bptr = b._ptr;
   // columns
-  var n = gsize[1];
+  const n = gsize[1];
   // vars
-  var p, p0, p1;
+  let p, p0, p1;
   // initialize top
-  var top = n;
+  let top = n;
   // loop column indeces in B
   for (p0 = bptr[k], p1 = bptr[k + 1], p = p0; p < p1; p++) {
     // node i
-    var i = bindex[p];
+    const i = bindex[p];
     // check node i is marked
     if (!(0, _csMarked.csMarked)(gptr, i)) {
       // start a dfs at unmarked node i

package/lib/cjs/function/algebra/sparse/csSpsolve.js

@@ -10,12 +10,14 @@ var _factory = require("../../../utils/factory.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csSpsolve';
-var dependencies = ['divideScalar', 'multiply', 'subtract'];
-var createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var divideScalar = _ref.divideScalar,
-    multiply = _ref.multiply,
-    subtract = _ref.subtract;
+const name = 'csSpsolve';
+const dependencies = ['divideScalar', 'multiply', 'subtract'];
+const createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    divideScalar,
+    multiply,
+    subtract
+  } = _ref;
   /**
    * The function csSpsolve() computes the solution to G * x = bk, where bk is the
    * kth column of B. When lo is true, the function assumes G = L is lower triangular with the
@@ -35,20 +37,20 @@ var createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.fact
    */
   return function csSpsolve(g, b, k, xi, x, pinv, lo) {
     // g arrays
-    var gvalues = g._values;
-    var gindex = g._index;
-    var gptr = g._ptr;
-    var gsize = g._size;
+    const gvalues = g._values;
+    const gindex = g._index;
+    const gptr = g._ptr;
+    const gsize = g._size;
     // columns
-    var n = gsize[1];
+    const n = gsize[1];
     // b arrays
-    var bvalues = b._values;
-    var bindex = b._index;
-    var bptr = b._ptr;
+    const bvalues = b._values;
+    const bindex = b._index;
+    const bptr = b._ptr;
     // vars
-    var p, p0, p1, q;
+    let p, p0, p1, q;
     // xi[top..n-1] = csReach(B(:,k))
-    var top = (0, _csReach.csReach)(g, b, k, xi, pinv);
+    const top = (0, _csReach.csReach)(g, b, k, xi, pinv);
     // clear x
     for (p = top; p < n; p++) {
       x[xi[p]] = 0;
@@ -58,11 +60,11 @@ var createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.fact
       x[bindex[p]] = bvalues[p];
     }
     // loop columns
-    for (var px = top; px < n; px++) {
+    for (let px = top; px < n; px++) {
       // x array index for px
-      var j = xi[px];
+      const j = xi[px];
       // apply permutation vector (U x = b), j maps to column J of G
-      var J = pinv ? pinv[j] : j;
+      const J = pinv ? pinv[j] : j;
       // check column J is empty
       if (J < 0) {
         continue;
@@ -78,7 +80,7 @@ var createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.fact
       // loop
       for (; p < q; p++) {
         // row
-        var i = gindex[p];
+        const i = gindex[p];
         // x(i) -= G(i,j) * x(j)
         x[i] = subtract(x[i], multiply(gvalues[p], x[j]));
       }

package/lib/cjs/function/algebra/sparse/csSqr.js

@@ -14,19 +14,21 @@ var _factory = require("../../../utils/factory.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csSqr';
-var dependencies = ['add', 'multiply', 'transpose'];
-var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var add = _ref.add,
-    multiply = _ref.multiply,
-    transpose = _ref.transpose;
-  var csAmd = (0, _csAmd.createCsAmd)({
-    add: add,
-    multiply: multiply,
-    transpose: transpose
+const name = 'csSqr';
+const dependencies = ['add', 'multiply', 'transpose'];
+const createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    add,
+    multiply,
+    transpose
+  } = _ref;
+  const csAmd = (0, _csAmd.createCsAmd)({
+    add,
+    multiply,
+    transpose
   });
-  var csCounts = (0, _csCounts.createCsCounts)({
-    transpose: transpose
+  const csCounts = (0, _csCounts.createCsCounts)({
+    transpose
   });
 
   /**
@@ -41,14 +43,14 @@ var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(nam
    */
   return function csSqr(order, a, qr) {
     // a arrays
-    var aptr = a._ptr;
-    var asize = a._size;
+    const aptr = a._ptr;
+    const asize = a._size;
     // columns
-    var n = asize[1];
+    const n = asize[1];
     // vars
-    var k;
+    let k;
     // symbolic analysis result
-    var s = {};
+    const s = {};
     // fill-reducing ordering
     s.q = csAmd(order, a);
     // validate results
@@ -58,11 +60,11 @@ var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(nam
     // QR symbolic analysis
     if (qr) {
       // apply permutations if needed
-      var c = order ? (0, _csPermute.csPermute)(a, null, s.q, 0) : a;
+      const c = order ? (0, _csPermute.csPermute)(a, null, s.q, 0) : a;
       // etree of C'*C, where C=A(:,q)
       s.parent = (0, _csEtree.csEtree)(c, 1);
       // post order elimination tree
-      var post = (0, _csPost.csPost)(s.parent, n);
+      const post = (0, _csPost.csPost)(s.parent, n);
       // col counts chol(C'*C)
       s.cp = csCounts(c, s.parent, post, 1);
       // check we have everything needed to calculate number of nonzero elements
@@ -86,27 +88,27 @@ var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(nam
    */
   function _vcount(a, s) {
     // a arrays
-    var aptr = a._ptr;
-    var aindex = a._index;
-    var asize = a._size;
+    const aptr = a._ptr;
+    const aindex = a._index;
+    const asize = a._size;
     // rows & columns
-    var m = asize[0];
-    var n = asize[1];
+    const m = asize[0];
+    const n = asize[1];
     // initialize s arrays
     s.pinv = []; // (m + n)
     s.leftmost = []; // (m)
     // vars
-    var parent = s.parent;
-    var pinv = s.pinv;
-    var leftmost = s.leftmost;
+    const parent = s.parent;
+    const pinv = s.pinv;
+    const leftmost = s.leftmost;
     // workspace, next: first m entries, head: next n entries, tail: next n entries, nque: next n entries
-    var w = []; // (m + 3 * n)
-    var next = 0;
-    var head = m;
-    var tail = m + n;
-    var nque = m + 2 * n;
+    const w = []; // (m + 3 * n)
+    const next = 0;
+    const head = m;
+    const tail = m + n;
+    const nque = m + 2 * n;
     // vars
-    var i, k, p, p0, p1;
+    let i, k, p, p0, p1;
     // initialize w
     for (k = 0; k < n; k++) {
       // queue k is empty
@@ -164,7 +166,7 @@ var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(nam
       // nque[k] is nnz (V(k+1:m,k))
       s.lnz += w[nque + k];
       // move all rows to parent of k
-      var pa = parent[k];
+      const pa = parent[k];
       if (pa !== -1) {
         if (w[nque + pa] === 0) {
           w[tail + pa] = w[tail + k];

package/lib/cjs/function/algebra/sparse/csSymperm.js

@@ -10,11 +10,13 @@ var _factory = require("../../../utils/factory.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csSymperm';
-var dependencies = ['conj', 'SparseMatrix'];
-var createCsSymperm = exports.createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var conj = _ref.conj,
-    SparseMatrix = _ref.SparseMatrix;
+const name = 'csSymperm';
+const dependencies = ['conj', 'SparseMatrix'];
+const createCsSymperm = exports.createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    conj,
+    SparseMatrix
+  } = _ref;
   /**
    * Computes the symmetric permutation of matrix A accessing only
    * the upper triangular part of A.
@@ -29,20 +31,20 @@ var createCsSymperm = exports.createCsSymperm = /* #__PURE__ */(0, _factory.fact
    */
   return function csSymperm(a, pinv, values) {
     // A matrix arrays
-    var avalues = a._values;
-    var aindex = a._index;
-    var aptr = a._ptr;
-    var asize = a._size;
+    const avalues = a._values;
+    const aindex = a._index;
+    const aptr = a._ptr;
+    const asize = a._size;
     // columns
-    var n = asize[1];
+    const n = asize[1];
     // C matrix arrays
-    var cvalues = values && avalues ? [] : null;
-    var cindex = []; // (nz)
-    var cptr = []; // (n + 1)
+    const cvalues = values && avalues ? [] : null;
+    const cindex = []; // (nz)
+    const cptr = []; // (n + 1)
     // variables
-    var i, i2, j, j2, p, p0, p1;
+    let i, i2, j, j2, p, p0, p1;
     // create workspace vector
-    var w = []; // (n)
+    const w = []; // (n)
     // count entries in each column of C
     for (j = 0; j < n; j++) {
       // column j of A is column j2 of C
@@ -78,7 +80,7 @@ var createCsSymperm = exports.createCsSymperm = /* #__PURE__ */(0, _factory.fact
         // row i of A is row i2 of C
         i2 = pinv ? pinv[i] : i;
         // C index for column j2
-        var q = w[Math.max(i2, j2)]++;
+        const q = w[Math.max(i2, j2)]++;
         // update C index for entry q
         cindex[q] = Math.min(i2, j2);
         // check we need to process values

package/lib/cjs/function/algebra/sparse/csTdfs.js

@@ -21,15 +21,15 @@ exports.csTdfs = csTdfs;
  */
 function csTdfs(j, k, w, head, next, post, stack) {
   // variables
-  var top = 0;
+  let top = 0;
   // place j on the stack
   w[stack] = j;
   // while (stack is not empty)
   while (top >= 0) {
     // p = top of stack
-    var p = w[stack + top];
+    const p = w[stack + top];
     // i = youngest child of p
-    var i = w[head + p];
+    const i = w[head + p];
     if (i === -1) {
       // p has no unordered children left
       top--;

package/lib/cjs/function/algebra/sylvester.js

@@ -5,24 +5,26 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createSylvester = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'sylvester';
-var dependencies = ['typed', 'schur', 'matrixFromColumns', 'matrix', 'multiply', 'range', 'concat', 'transpose', 'index', 'subset', 'add', 'subtract', 'identity', 'lusolve', 'abs'];
-var createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    schur = _ref.schur,
-    matrixFromColumns = _ref.matrixFromColumns,
-    matrix = _ref.matrix,
-    multiply = _ref.multiply,
-    range = _ref.range,
-    concat = _ref.concat,
-    transpose = _ref.transpose,
-    index = _ref.index,
-    subset = _ref.subset,
-    add = _ref.add,
-    subtract = _ref.subtract,
-    identity = _ref.identity,
-    lusolve = _ref.lusolve,
-    abs = _ref.abs;
+const name = 'sylvester';
+const dependencies = ['typed', 'schur', 'matrixFromColumns', 'matrix', 'multiply', 'range', 'concat', 'transpose', 'index', 'subset', 'add', 'subtract', 'identity', 'lusolve', 'abs'];
+const createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    schur,
+    matrixFromColumns,
+    matrix,
+    multiply,
+    range,
+    concat,
+    transpose,
+    index,
+    subset,
+    add,
+    subtract,
+    identity,
+    lusolve,
+    abs
+  } = _ref;
   /**
    *
    * Solves the real-valued Sylvester equation AX+XB=C for X, where A, B and C are
@@ -54,73 +56,69 @@ var createSylvester = exports.createSylvester = /* #__PURE__ */(0, _factory.fact
    */
   return typed(name, {
     'Matrix, Matrix, Matrix': _sylvester,
-    'Array, Matrix, Matrix': function ArrayMatrixMatrix(A, B, C) {
+    'Array, Matrix, Matrix': function (A, B, C) {
       return _sylvester(matrix(A), B, C);
     },
-    'Array, Array, Matrix': function ArrayArrayMatrix(A, B, C) {
+    'Array, Array, Matrix': function (A, B, C) {
       return _sylvester(matrix(A), matrix(B), C);
     },
-    'Array, Matrix, Array': function ArrayMatrixArray(A, B, C) {
+    'Array, Matrix, Array': function (A, B, C) {
       return _sylvester(matrix(A), B, matrix(C));
     },
-    'Matrix, Array, Matrix': function MatrixArrayMatrix(A, B, C) {
+    'Matrix, Array, Matrix': function (A, B, C) {
       return _sylvester(A, matrix(B), C);
     },
-    'Matrix, Array, Array': function MatrixArrayArray(A, B, C) {
+    'Matrix, Array, Array': function (A, B, C) {
       return _sylvester(A, matrix(B), matrix(C));
     },
-    'Matrix, Matrix, Array': function MatrixMatrixArray(A, B, C) {
+    'Matrix, Matrix, Array': function (A, B, C) {
       return _sylvester(A, B, matrix(C));
     },
-    'Array, Array, Array': function ArrayArrayArray(A, B, C) {
+    'Array, Array, Array': function (A, B, C) {
       return _sylvester(matrix(A), matrix(B), matrix(C)).toArray();
     }
   });
   function _sylvester(A, B, C) {
-    var n = B.size()[0];
-    var m = A.size()[0];
-    var sA = schur(A);
-    var F = sA.T;
-    var U = sA.U;
-    var sB = schur(multiply(-1, B));
-    var G = sB.T;
-    var V = sB.U;
-    var D = multiply(multiply(transpose(U), C), V);
-    var all = range(0, m);
-    var y = [];
-    var hc = function hc(a, b) {
-      return concat(a, b, 1);
-    };
-    var vc = function vc(a, b) {
-      return concat(a, b, 0);
-    };
-    for (var k = 0; k < n; k++) {
+    const n = B.size()[0];
+    const m = A.size()[0];
+    const sA = schur(A);
+    const F = sA.T;
+    const U = sA.U;
+    const sB = schur(multiply(-1, B));
+    const G = sB.T;
+    const V = sB.U;
+    const D = multiply(multiply(transpose(U), C), V);
+    const all = range(0, m);
+    const y = [];
+    const hc = (a, b) => concat(a, b, 1);
+    const vc = (a, b) => concat(a, b, 0);
+    for (let k = 0; k < n; k++) {
       if (k < n - 1 && abs(subset(G, index(k + 1, k))) > 1e-5) {
-        var RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
-        for (var j = 0; j < k; j++) {
+        let RHS = vc(subset(D, index(all, k)), subset(D, index(all, k + 1)));
+        for (let j = 0; j < k; j++) {
           RHS = add(RHS, vc(multiply(y[j], subset(G, index(j, k))), multiply(y[j], subset(G, index(j, k + 1)))));
         }
-        var gkk = multiply(identity(m), multiply(-1, subset(G, index(k, k))));
-        var gmk = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k))));
-        var gkm = multiply(identity(m), multiply(-1, subset(G, index(k, k + 1))));
-        var gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
-        var LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
-        var yAux = lusolve(LHS, RHS);
+        const gkk = multiply(identity(m), multiply(-1, subset(G, index(k, k))));
+        const gmk = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k))));
+        const gkm = multiply(identity(m), multiply(-1, subset(G, index(k, k + 1))));
+        const gmm = multiply(identity(m), multiply(-1, subset(G, index(k + 1, k + 1))));
+        const LHS = vc(hc(add(F, gkk), gmk), hc(gkm, add(F, gmm)));
+        const yAux = lusolve(LHS, RHS);
         y[k] = yAux.subset(index(range(0, m), 0));
         y[k + 1] = yAux.subset(index(range(m, 2 * m), 0));
         k++;
       } else {
-        var _RHS = subset(D, index(all, k));
-        for (var _j = 0; _j < k; _j++) {
-          _RHS = add(_RHS, multiply(y[_j], subset(G, index(_j, k))));
+        let RHS = subset(D, index(all, k));
+        for (let j = 0; j < k; j++) {
+          RHS = add(RHS, multiply(y[j], subset(G, index(j, k))));
         }
-        var _gkk = subset(G, index(k, k));
-        var _LHS = subtract(F, multiply(_gkk, identity(m)));
-        y[k] = lusolve(_LHS, _RHS);
+        const gkk = subset(G, index(k, k));
+        const LHS = subtract(F, multiply(gkk, identity(m)));
+        y[k] = lusolve(LHS, RHS);
       }
     }
-    var Y = matrix(matrixFromColumns.apply(void 0, y));
-    var X = multiply(U, multiply(Y, transpose(V)));
+    const Y = matrix(matrixFromColumns(...y));
+    const X = multiply(U, multiply(Y, transpose(V)));
     return X;
   }
 });

package/lib/cjs/function/algebra/symbolicEqual.js

@@ -6,13 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.createSymbolicEqual = void 0;
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-var name = 'symbolicEqual';
-var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
-var createSymbolicEqual = exports.createSymbolicEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var parse = _ref.parse,
-    simplify = _ref.simplify,
-    typed = _ref.typed,
-    OperatorNode = _ref.OperatorNode;
+const name = 'symbolicEqual';
+const dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+const createSymbolicEqual = exports.createSymbolicEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    parse,
+    simplify,
+    typed,
+    OperatorNode
+  } = _ref;
   /**
    * Attempts to determine if two expressions are symbolically equal, i.e.
    * one is the result of valid algebraic manipulations on the other.
@@ -52,9 +54,9 @@ var createSymbolicEqual = exports.createSymbolicEqual = /* #__PURE__ */(0, _fact
    *     is found.
    */
   function _symbolicEqual(e1, e2) {
-    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    var diff = new OperatorNode('-', 'subtract', [e1, e2]);
-    var simplified = simplify(diff, {}, options);
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const diff = new OperatorNode('-', 'subtract', [e1, e2]);
+    const simplified = simplify(diff, {}, options);
     return (0, _is.isConstantNode)(simplified) && !simplified.value;
   }
   return typed(name, {

package/lib/cjs/function/arithmetic/abs.js

@@ -7,10 +7,12 @@ exports.createAbs = void 0;
 var _factory = require("../../utils/factory.js");
 var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
-var name = 'abs';
-var dependencies = ['typed'];
-var createAbs = exports.createAbs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'abs';
+const dependencies = ['typed'];
+const createAbs = exports.createAbs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Calculate the absolute value of a number. For matrices, the function is
    * evaluated element wise.
@@ -30,21 +32,16 @@ var createAbs = exports.createAbs = /* #__PURE__ */(0, _factory.factory)(name, d
    *
    *    sign
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit} x
    *            A number or matrix for which to get the absolute value
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | bigint | Fraction | Complex | Array | Matrix | Unit}
    *            Absolute value of `x`
    */
   return typed(name, {
     number: _index.absNumber,
-    'Complex | BigNumber | Fraction | Unit': function ComplexBigNumberFractionUnit(x) {
-      return x.abs();
-    },
+    'Complex | BigNumber | Fraction | Unit': x => x.abs(),
+    bigint: x => x < 0n ? -x : x,
     // deep map collection, skip zeros since abs(0) = 0
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self, true);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self, true))
   });
 });

package/lib/cjs/function/arithmetic/add.js

@@ -9,31 +9,33 @@ var _matAlgo01xDSid = require("../../type/matrix/utils/matAlgo01xDSid.js");
 var _matAlgo04xSidSid = require("../../type/matrix/utils/matAlgo04xSidSid.js");
 var _matAlgo10xSids = require("../../type/matrix/utils/matAlgo10xSids.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
-var name = 'add';
-var dependencies = ['typed', 'matrix', 'addScalar', 'equalScalar', 'DenseMatrix', 'SparseMatrix', 'concat'];
-var createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    addScalar = _ref.addScalar,
-    equalScalar = _ref.equalScalar,
-    DenseMatrix = _ref.DenseMatrix,
-    SparseMatrix = _ref.SparseMatrix,
-    concat = _ref.concat;
-  var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
-    typed: typed
+const name = 'add';
+const dependencies = ['typed', 'matrix', 'addScalar', 'equalScalar', 'DenseMatrix', 'SparseMatrix', 'concat'];
+const createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    addScalar,
+    equalScalar,
+    DenseMatrix,
+    SparseMatrix,
+    concat
+  } = _ref;
+  const matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
+    typed
   });
-  var matAlgo04xSidSid = (0, _matAlgo04xSidSid.createMatAlgo04xSidSid)({
-    typed: typed,
-    equalScalar: equalScalar
+  const matAlgo04xSidSid = (0, _matAlgo04xSidSid.createMatAlgo04xSidSid)({
+    typed,
+    equalScalar
   });
-  var matAlgo10xSids = (0, _matAlgo10xSids.createMatAlgo10xSids)({
-    typed: typed,
-    DenseMatrix: DenseMatrix
+  const matAlgo10xSids = (0, _matAlgo10xSids.createMatAlgo10xSids)({
+    typed,
+    DenseMatrix
   });
-  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
-    typed: typed,
-    matrix: matrix,
-    concat: concat
+  const matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed,
+    matrix,
+    concat
   });
   /**
   * Add two or more values, `x + y`.
@@ -65,20 +67,18 @@ var createAdd = exports.createAdd = /* #__PURE__ */(0, _factory.factory)(name, d
   *
   *    subtract, sum
   *
-  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First value to add
-  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to add
-  * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
+  * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x First value to add
+  * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} y Second value to add
+  * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
   */
   return typed(name, {
     'any, any': addScalar,
-    'any, any, ...any': typed.referToSelf(function (self) {
-      return function (x, y, rest) {
-        var result = self(x, y);
-        for (var i = 0; i < rest.length; i++) {
-          result = self(result, rest[i]);
-        }
-        return result;
-      };
+    'any, any, ...any': typed.referToSelf(self => (x, y, rest) => {
+      let result = self(x, y);
+      for (let i = 0; i < rest.length; i++) {
+        result = self(result, rest[i]);
+      }
+      return result;
     })
   }, matrixAlgorithmSuite({
     elop: addScalar,