mathjs 12.4.3 → 13.0.0

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

@@ -11,22 +11,24 @@ var _csSymperm = require("./csSymperm.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csChol';
-var dependencies = ['divideScalar', 'sqrt', 'subtract', 'multiply', 'im', 're', 'conj', 'equal', 'smallerEq', 'SparseMatrix'];
-var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var divideScalar = _ref.divideScalar,
-    sqrt = _ref.sqrt,
-    subtract = _ref.subtract,
-    multiply = _ref.multiply,
-    im = _ref.im,
-    re = _ref.re,
-    conj = _ref.conj,
-    equal = _ref.equal,
-    smallerEq = _ref.smallerEq,
-    SparseMatrix = _ref.SparseMatrix;
-  var csSymperm = (0, _csSymperm.createCsSymperm)({
-    conj: conj,
-    SparseMatrix: SparseMatrix
+const name = 'csChol';
+const dependencies = ['divideScalar', 'sqrt', 'subtract', 'multiply', 'im', 're', 'conj', 'equal', 'smallerEq', 'SparseMatrix'];
+const createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    divideScalar,
+    sqrt,
+    subtract,
+    multiply,
+    im,
+    re,
+    conj,
+    equal,
+    smallerEq,
+    SparseMatrix
+  } = _ref;
+  const csSymperm = (0, _csSymperm.createCsSymperm)({
+    conj,
+    SparseMatrix
   });
 
   /**
@@ -44,35 +46,35 @@ var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(n
       return null;
     }
     // m arrays
-    var size = m._size;
+    const size = m._size;
     // columns
-    var n = size[1];
+    const n = size[1];
     // symbolic analysis result
-    var parent = s.parent;
-    var cp = s.cp;
-    var pinv = s.pinv;
+    const parent = s.parent;
+    const cp = s.cp;
+    const pinv = s.pinv;
     // L arrays
-    var lvalues = [];
-    var lindex = [];
-    var lptr = [];
+    const lvalues = [];
+    const lindex = [];
+    const lptr = [];
     // L
-    var L = new SparseMatrix({
+    const L = new SparseMatrix({
       values: lvalues,
       index: lindex,
       ptr: lptr,
       size: [n, n]
     });
     // vars
-    var c = []; // (2 * n)
-    var x = []; // (n)
+    const c = []; // (2 * n)
+    const x = []; // (n)
     // compute C = P * A * P'
-    var cm = pinv ? csSymperm(m, pinv, 1) : m;
+    const cm = pinv ? csSymperm(m, pinv, 1) : m;
     // C matrix arrays
-    var cvalues = cm._values;
-    var cindex = cm._index;
-    var cptr = cm._ptr;
+    const cvalues = cm._values;
+    const cindex = cm._index;
+    const cptr = cm._ptr;
     // vars
-    var k, p;
+    let k, p;
     // initialize variables
     for (k = 0; k < n; k++) {
       lptr[k] = c[k] = cp[k];
@@ -80,7 +82,7 @@ var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(n
     // compute L(k,:) for L*L' = C
     for (k = 0; k < n; k++) {
       // nonzero pattern of L(k,:)
-      var top = (0, _csEreach.csEreach)(cm, k, parent, c);
+      let top = (0, _csEreach.csEreach)(cm, k, parent, c);
       // x (0:k) is now zero
       x[k] = 0;
       // x = full(triu(C(:,k)))
@@ -90,20 +92,20 @@ var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(n
         }
       }
       // d = C(k,k)
-      var d = x[k];
+      let d = x[k];
       // clear x for k+1st iteration
       x[k] = 0;
       // solve L(0:k-1,0:k-1) * x = C(:,k)
       for (; top < n; top++) {
         // s[top..n-1] is pattern of L(k,:)
-        var i = s[top];
+        const i = s[top];
         // L(k,i) = x (i) / L(i,i)
-        var lki = divideScalar(x[i], lvalues[lptr[i]]);
+        const lki = divideScalar(x[i], lvalues[lptr[i]]);
         // clear x for k+1st iteration
         x[i] = 0;
         for (p = lptr[i] + 1; p < c[i]; p++) {
           // row
-          var r = lindex[p];
+          const r = lindex[p];
           // update x[r]
           x[r] = subtract(x[r], multiply(lvalues[p], lki));
         }
@@ -127,13 +129,13 @@ var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(n
     // finalize L
     lptr[n] = cp[n];
     // P matrix
-    var P;
+    let P;
     // check we need to calculate P
     if (pinv) {
       // P arrays
-      var pvalues = [];
-      var pindex = [];
-      var pptr = [];
+      const pvalues = [];
+      const pindex = [];
+      const pptr = [];
       // create P matrix
       for (p = 0; p < n; p++) {
         // initialize ptr (one value per column)
@@ -155,8 +157,8 @@ var createCsChol = exports.createCsChol = /* #__PURE__ */(0, _factory.factory)(n
     }
     // return L & P
     return {
-      L: L,
-      P: P
+      L,
+      P
     };
   };
 });

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

@@ -10,10 +10,12 @@ var _csLeaf = require("./csLeaf.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csCounts';
-var dependencies = ['transpose'];
-var createCsCounts = exports.createCsCounts = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var transpose = _ref.transpose;
+const name = 'csCounts';
+const dependencies = ['transpose'];
+const createCsCounts = exports.createCsCounts = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    transpose
+  } = _ref;
   /**
    * Computes the column counts using the upper triangular part of A.
    * It transposes A internally, none of the input parameters are modified.
@@ -30,36 +32,36 @@ var createCsCounts = exports.createCsCounts = /* #__PURE__ */(0, _factory.factor
       return null;
     }
     // a matrix arrays
-    var asize = a._size;
+    const asize = a._size;
     // rows and columns
-    var m = asize[0];
-    var n = asize[1];
+    const m = asize[0];
+    const n = asize[1];
     // variables
-    var i, j, k, J, p, p0, p1;
+    let i, j, k, J, p, p0, p1;
 
     // workspace size
-    var s = 4 * n + (ata ? n + m + 1 : 0);
+    const s = 4 * n + (ata ? n + m + 1 : 0);
     // allocate workspace
-    var w = []; // (s)
-    var ancestor = 0; // first n entries
-    var maxfirst = n; // next n entries
-    var prevleaf = 2 * n; // next n entries
-    var first = 3 * n; // next n entries
-    var head = 4 * n; // next n + 1 entries (used when ata is true)
-    var next = 5 * n + 1; // last entries in workspace
+    const w = []; // (s)
+    const ancestor = 0; // first n entries
+    const maxfirst = n; // next n entries
+    const prevleaf = 2 * n; // next n entries
+    const first = 3 * n; // next n entries
+    const head = 4 * n; // next n + 1 entries (used when ata is true)
+    const next = 5 * n + 1; // last entries in workspace
     // clear workspace w[0..s-1]
     for (k = 0; k < s; k++) {
       w[k] = -1;
     }
 
     // allocate result
-    var colcount = []; // (n)
+    const colcount = []; // (n)
 
     // AT = A'
-    var at = transpose(a);
+    const at = transpose(a);
     // at arrays
-    var tindex = at._index;
-    var tptr = at._ptr;
+    const tindex = at._index;
+    const tptr = at._ptr;
 
     // find w[first + j]
     for (k = 0; k < n; k++) {
@@ -105,7 +107,7 @@ var createCsCounts = exports.createCsCounts = /* #__PURE__ */(0, _factory.factor
       for (J = ata ? w[head + k] : j; J !== -1; J = ata ? w[next + J] : -1) {
         for (p = tptr[J]; p < tptr[J + 1]; p++) {
           i = tindex[p];
-          var r = (0, _csLeaf.csLeaf)(i, j, w, first, maxfirst, prevleaf, ancestor);
+          const r = (0, _csLeaf.csLeaf)(i, j, w, first, maxfirst, prevleaf, ancestor);
           // check A(i,j) is in skeleton
           if (r.jleaf >= 1) {
             colcount[j]++;

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

@@ -17,8 +17,8 @@ exports.csCumsum = csCumsum;
  */
 function csCumsum(ptr, c, n) {
   // variables
-  var i;
-  var nz = 0;
+  let i;
+  let nz = 0;
   for (i = 0; i < n; i++) {
     // initialize ptr @ i
     ptr[i] = nz;

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

@@ -27,15 +27,15 @@ var _csUnflip = require("./csUnflip.js");
  */
 function csDfs(j, g, top, xi, pinv) {
   // g arrays
-  var index = g._index;
-  var ptr = g._ptr;
-  var size = g._size;
+  const index = g._index;
+  const ptr = g._ptr;
+  const size = g._size;
   // columns
-  var n = size[1];
+  const n = size[1];
   // vars
-  var i, p, p2;
+  let i, p, p2;
   // initialize head
-  var head = 0;
+  let head = 0;
   // initialize the recursion stack
   xi[0] = j;
   // loop
@@ -43,7 +43,7 @@ function csDfs(j, g, top, xi, pinv) {
     // get j from the top of the recursion stack
     j = xi[head];
     // apply permutation vector
-    var jnew = pinv ? pinv[j] : j;
+    const jnew = pinv ? pinv[j] : j;
     // check node j is marked
     if (!(0, _csMarked.csMarked)(ptr, j)) {
       // mark node j as visited
@@ -52,7 +52,7 @@ function csDfs(j, g, top, xi, pinv) {
       xi[n + head] = jnew < 0 ? 0 : (0, _csUnflip.csUnflip)(ptr[jnew]);
     }
     // node j done if no unvisited neighbors
-    var done = 1;
+    let done = 1;
     // examine all neighbors of j, stack (last n entries in xi)
     for (p = xi[n + head], p2 = jnew < 0 ? 0 : (0, _csUnflip.csUnflip)(ptr[jnew + 1]); p < p2; p++) {
       // consider neighbor node i

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

@@ -23,21 +23,21 @@ var _csMarked = require("./csMarked.js");
  */
 function csEreach(a, k, parent, w) {
   // a arrays
-  var aindex = a._index;
-  var aptr = a._ptr;
-  var asize = a._size;
+  const aindex = a._index;
+  const aptr = a._ptr;
+  const asize = a._size;
   // columns
-  var n = asize[1];
+  const n = asize[1];
   // initialize top
-  var top = n;
+  let top = n;
   // vars
-  var p, p0, p1, len;
+  let p, p0, p1, len;
   // mark node k as visited
   (0, _csMark.csMark)(w, k);
   // loop values & index for column k
   for (p0 = aptr[k], p1 = aptr[k + 1], p = p0; p < p1; p++) {
     // A(i,k) is nonzero
-    var i = aindex[p];
+    let i = aindex[p];
     // only use upper triangular part of A
     if (i > k) {
       continue;

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

@@ -21,22 +21,22 @@ function csEtree(a, ata) {
     return null;
   }
   // a arrays
-  var aindex = a._index;
-  var aptr = a._ptr;
-  var asize = a._size;
+  const aindex = a._index;
+  const aptr = a._ptr;
+  const asize = a._size;
   // rows & columns
-  var m = asize[0];
-  var n = asize[1];
+  const m = asize[0];
+  const n = asize[1];
 
   // allocate result
-  var parent = []; // (n)
+  const parent = []; // (n)
 
   // allocate workspace
-  var w = []; // (n + (ata ? m : 0))
-  var ancestor = 0; // first n entries in w
-  var prev = n; // last m entries (ata = true)
+  const w = []; // (n + (ata ? m : 0))
+  const ancestor = 0; // first n entries in w
+  const prev = n; // last m entries (ata = true)
 
-  var i, inext;
+  let i, inext;
 
   // check we are calculating A'A
   if (ata) {
@@ -46,15 +46,15 @@ function csEtree(a, ata) {
     }
   }
   // loop columns
-  for (var k = 0; k < n; k++) {
+  for (let k = 0; k < n; k++) {
     // node k has no parent yet
     parent[k] = -1;
     // nor does k have an ancestor
     w[ancestor + k] = -1;
     // values in column k
-    for (var p0 = aptr[k], p1 = aptr[k + 1], p = p0; p < p1; p++) {
+    for (let p0 = aptr[k], p1 = aptr[k + 1], p = p0; p < p1; p++) {
       // row
-      var r = aindex[p];
+      const r = aindex[p];
       // node
       i = ata ? w[prev + r] : r;
       // traverse from i to k

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

@@ -23,18 +23,18 @@ exports.csFkeep = csFkeep;
  */
 function csFkeep(a, callback, other) {
   // a 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];
   // nonzero items
-  var nz = 0;
+  let nz = 0;
   // loop columns
-  for (var j = 0; j < n; j++) {
+  for (let j = 0; j < n; j++) {
     // get current location of col j
-    var p = aptr[j];
+    let p = aptr[j];
     // record new location of col j
     aptr[j] = nz;
     for (; p < aptr[j + 1]; p++) {

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

@@ -18,9 +18,9 @@ exports.csIpvec = csIpvec;
  */
 function csIpvec(p, b) {
   // vars
-  var k;
-  var n = b.length;
-  var x = [];
+  let k;
+  const n = b.length;
+  const x = [];
   // check permutation vector was provided, p = null denotes identity
   if (p) {
     // loop vector

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

@@ -23,11 +23,11 @@ exports.csLeaf = csLeaf;
  * @return {Object}
  */
 function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
-  var s, sparent;
+  let s, sparent;
 
   // our result
-  var jleaf = 0;
-  var q;
+  let jleaf = 0;
+  let q;
 
   // check j is a leaf
   if (i <= j || w[first + j] <= w[maxfirst + i]) {
@@ -36,7 +36,7 @@ function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
   // update max first[j] seen so far
   w[maxfirst + i] = w[first + j];
   // jprev = previous leaf of ith subtree
-  var jprev = w[prevleaf + i];
+  const jprev = w[prevleaf + i];
   w[prevleaf + i] = j;
 
   // check j is first or subsequent leaf
@@ -56,7 +56,7 @@ function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
     }
   }
   return {
-    jleaf: jleaf,
-    q: q
+    jleaf,
+    q
   };
 }

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

@@ -10,20 +10,22 @@ var _csSpsolve = require("./csSpsolve.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csLu';
-var dependencies = ['abs', 'divideScalar', 'multiply', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
-var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var abs = _ref.abs,
-    divideScalar = _ref.divideScalar,
-    multiply = _ref.multiply,
-    subtract = _ref.subtract,
-    larger = _ref.larger,
-    largerEq = _ref.largerEq,
-    SparseMatrix = _ref.SparseMatrix;
-  var csSpsolve = (0, _csSpsolve.createCsSpsolve)({
-    divideScalar: divideScalar,
-    multiply: multiply,
-    subtract: subtract
+const name = 'csLu';
+const dependencies = ['abs', 'divideScalar', 'multiply', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
+const createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    abs,
+    divideScalar,
+    multiply,
+    subtract,
+    larger,
+    largerEq,
+    SparseMatrix
+  } = _ref;
+  const csSpsolve = (0, _csSpsolve.createCsSpsolve)({
+    divideScalar,
+    multiply,
+    subtract
   });
 
   /**
@@ -45,13 +47,13 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
       return null;
     }
     // m arrays
-    var size = m._size;
+    const size = m._size;
     // columns
-    var n = size[1];
+    const n = size[1];
     // symbolic analysis result
-    var q;
-    var lnz = 100;
-    var unz = 100;
+    let q;
+    let lnz = 100;
+    let unz = 100;
     // update symbolic analysis parameters
     if (s) {
       q = s.q;
@@ -59,34 +61,34 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
       unz = s.unz || unz;
     }
     // L arrays
-    var lvalues = []; // (lnz)
-    var lindex = []; // (lnz)
-    var lptr = []; // (n + 1)
+    const lvalues = []; // (lnz)
+    const lindex = []; // (lnz)
+    const lptr = []; // (n + 1)
     // L
-    var L = new SparseMatrix({
+    const L = new SparseMatrix({
       values: lvalues,
       index: lindex,
       ptr: lptr,
       size: [n, n]
     });
     // U arrays
-    var uvalues = []; // (unz)
-    var uindex = []; // (unz)
-    var uptr = []; // (n + 1)
+    const uvalues = []; // (unz)
+    const uindex = []; // (unz)
+    const uptr = []; // (n + 1)
     // U
-    var U = new SparseMatrix({
+    const U = new SparseMatrix({
       values: uvalues,
       index: uindex,
       ptr: uptr,
       size: [n, n]
     });
     // inverse of permutation vector
-    var pinv = []; // (n)
+    const pinv = []; // (n)
     // vars
-    var i, p;
+    let i, p;
     // allocate arrays
-    var x = []; // (n)
-    var xi = []; // (2 * n)
+    const x = []; // (n)
+    const xi = []; // (2 * n)
     // initialize variables
     for (i = 0; i < n; i++) {
       // clear workspace
@@ -100,17 +102,17 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
     lnz = 0;
     unz = 0;
     // compute L(:,k) and U(:,k)
-    for (var k = 0; k < n; k++) {
+    for (let k = 0; k < n; k++) {
       // update ptr
       lptr[k] = lnz;
       uptr[k] = unz;
       // apply column permutations if needed
-      var col = q ? q[k] : k;
+      const col = q ? q[k] : k;
       // solve triangular system, x = L\A(:,col)
-      var top = csSpsolve(L, m, col, xi, x, pinv, 1);
+      const top = csSpsolve(L, m, col, xi, x, pinv, 1);
       // find pivot
-      var ipiv = -1;
-      var a = -1;
+      let ipiv = -1;
+      let a = -1;
       // loop xi[] from top -> n
       for (p = top; p < n; p++) {
         // x[i] is nonzero
@@ -118,7 +120,7 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
         // check row i is not yet pivotal
         if (pinv[i] < 0) {
           // absolute value of x[i]
-          var xabs = abs(x[i]);
+          const xabs = abs(x[i]);
           // check absoulte value is greater than pivot value
           if (larger(xabs, a)) {
             // largest pivot candidate so far
@@ -140,7 +142,7 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
         ipiv = col;
       }
       // the chosen pivot
-      var pivot = x[ipiv];
+      const pivot = x[ipiv];
       // last entry in U(:,k) is U(k,k)
       uindex[unz] = k;
       uvalues[unz++] = pivot;
@@ -178,9 +180,9 @@ var createCsLu = exports.createCsLu = /* #__PURE__ */(0, _factory.factory)(name,
     uindex.splice(unz, uindex.length - unz);
     // return LU factor
     return {
-      L: L,
-      U: U,
-      pinv: pinv
+      L,
+      U,
+      pinv
     };
   };
 });

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

@@ -20,30 +20,30 @@ exports.csPermute = csPermute;
  */
 function csPermute(a, pinv, q, values) {
   // a arrays
-  var avalues = a._values;
-  var aindex = a._index;
-  var aptr = a._ptr;
-  var asize = a._size;
-  var adt = a._datatype;
+  const avalues = a._values;
+  const aindex = a._index;
+  const aptr = a._ptr;
+  const asize = a._size;
+  const adt = a._datatype;
   // rows & columns
-  var m = asize[0];
-  var n = asize[1];
+  const m = asize[0];
+  const n = asize[1];
   // c arrays
-  var cvalues = values && a._values ? [] : null;
-  var cindex = []; // (aptr[n])
-  var cptr = []; // (n + 1)
+  const cvalues = values && a._values ? [] : null;
+  const cindex = []; // (aptr[n])
+  const cptr = []; // (n + 1)
   // initialize vars
-  var nz = 0;
+  let nz = 0;
   // loop columns
-  for (var k = 0; k < n; k++) {
+  for (let k = 0; k < n; k++) {
     // column k of C is column q[k] of A
     cptr[k] = nz;
     // apply column permutation
-    var j = q ? q[k] : k;
+    const j = q ? q[k] : k;
     // loop values in column j of A
-    for (var t0 = aptr[j], t1 = aptr[j + 1], t = t0; t < t1; t++) {
+    for (let t0 = aptr[j], t1 = aptr[j + 1], t = t0; t < t1; t++) {
       // row i of A is row pinv[i] of C
-      var r = pinv ? pinv[aindex[t]] : aindex[t];
+      const r = pinv ? pinv[aindex[t]] : aindex[t];
       // index
       cindex[nz] = r;
       // check we need to populate values

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

@@ -21,15 +21,15 @@ function csPost(parent, n) {
     return null;
   }
   // vars
-  var k = 0;
-  var j;
+  let k = 0;
+  let j;
   // allocate result
-  var post = []; // (n)
+  const post = []; // (n)
   // workspace, head: first n entries, next: next n entries, stack: last n entries
-  var w = []; // (3 * n)
-  var head = 0;
-  var next = n;
-  var stack = 2 * n;
+  const w = []; // (3 * n)
+  const head = 0;
+  const next = n;
+  const stack = 2 * n;
   // initialize workspace
   for (j = 0; j < n; j++) {
     // empty linked lists