mathjs 8.1.0 → 12.2.1

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

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csPost = csPost;
-
 var _csTdfs = require("./csTdfs.js");
-
 /**
  * Post order a tree of forest
  *
@@ -19,48 +17,40 @@ function csPost(parent, n) {
   // check inputs
   if (!parent) {
     return null;
-  } // vars
-
-
+  }
+  // vars
   var k = 0;
-  var j; // allocate result
-
+  var j;
+  // allocate result
   var 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; // initialize workspace
-
+  var stack = 2 * n;
+  // initialize workspace
   for (j = 0; j < n; j++) {
     // empty linked lists
     w[head + j] = -1;
-  } // traverse nodes in reverse order
-
-
+  }
+  // traverse nodes in reverse order
   for (j = n - 1; j >= 0; j--) {
     // check j is a root
     if (parent[j] === -1) {
       continue;
-    } // add j to list of its parent
-
-
+    }
+    // add j to list of its parent
     w[next + j] = w[head + parent[j]];
     w[head + parent[j]] = j;
-  } // loop nodes
-
-
+  }
+  // loop nodes
   for (j = 0; j < n; j++) {
     // skip j if it is not a root
     if (parent[j] !== -1) {
       continue;
-    } // depth-first search
-
-
+    }
+    // depth-first search
     k = (0, _csTdfs.csTdfs)(j, k, w, head, next, post, stack);
   }
-
   return post;
 }

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

@@ -4,13 +4,9 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csReach = csReach;
-
 var _csMarked = require("./csMarked.js");
-
 var _csMark = require("./csMark.js");
-
 var _csDfs = require("./csDfs.js");
-
 /**
  * The csReach function computes X = Reach(B), where B is the nonzero pattern of the n-by-1
  * sparse column of vector b. The function returns the set of nodes reachable from any node in B. The
@@ -30,32 +26,30 @@ var _csDfs = require("./csDfs.js");
 function csReach(g, b, k, xi, pinv) {
   // g arrays
   var gptr = g._ptr;
-  var gsize = g._size; // b arrays
-
+  var gsize = g._size;
+  // b arrays
   var bindex = b._index;
-  var bptr = b._ptr; // columns
-
-  var n = gsize[1]; // vars
-
-  var p, p0, p1; // initialize top
-
-  var top = n; // loop column indeces in B
-
+  var bptr = b._ptr;
+  // columns
+  var n = gsize[1];
+  // vars
+  var p, p0, p1;
+  // initialize top
+  var 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]; // check node i is marked
-
+    var i = bindex[p];
+    // check node i is marked
     if (!(0, _csMarked.csMarked)(gptr, i)) {
       // start a dfs at unmarked node i
       top = (0, _csDfs.csDfs)(i, g, top, xi, pinv);
     }
-  } // loop columns from top -> n - 1
-
-
+  }
+  // loop columns from top -> n - 1
   for (p = top; p < n; p++) {
     // restore G
     (0, _csMark.csMark)(gptr, xi[p]);
   }
-
   return top;
 }

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

@@ -4,18 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createCsSpsolve = void 0;
-
 var _csReach = require("./csReach.js");
-
 var _factory = require("../../../utils/factory.js");
-
 var name = 'csSpsolve';
 var dependencies = ['divideScalar', 'multiply', 'subtract'];
-var createCsSpsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createCsSpsolve = exports.createCsSpsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var divideScalar = _ref.divideScalar,
-      multiply = _ref.multiply,
-      subtract = _ref.subtract;
-
+    multiply = _ref.multiply,
+    subtract = _ref.subtract;
   /**
    * 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
@@ -40,57 +36,52 @@ var createCsSpsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     var gvalues = g._values;
     var gindex = g._index;
     var gptr = g._ptr;
-    var gsize = g._size; // columns
-
-    var n = gsize[1]; // b arrays
-
+    var gsize = g._size;
+    // columns
+    var n = gsize[1];
+    // b arrays
     var bvalues = b._values;
     var bindex = b._index;
-    var bptr = b._ptr; // vars
-
-    var p, p0, p1, q; // xi[top..n-1] = csReach(B(:,k))
-
-    var top = (0, _csReach.csReach)(g, b, k, xi, pinv); // clear x
-
+    var bptr = b._ptr;
+    // vars
+    var p, p0, p1, q;
+    // xi[top..n-1] = csReach(B(:,k))
+    var top = (0, _csReach.csReach)(g, b, k, xi, pinv);
+    // clear x
     for (p = top; p < n; p++) {
       x[xi[p]] = 0;
-    } // scatter b
-
-
+    }
+    // scatter b
     for (p0 = bptr[k], p1 = bptr[k + 1], p = p0; p < p1; p++) {
       x[bindex[p]] = bvalues[p];
-    } // loop columns
-
-
+    }
+    // loop columns
     for (var px = top; px < n; px++) {
       // x array index for px
-      var j = xi[px]; // apply permutation vector (U x = b), j maps to column J of G
-
-      var J = pinv ? pinv[j] : j; // check column J is empty
-
+      var j = xi[px];
+      // apply permutation vector (U x = b), j maps to column J of G
+      var J = pinv ? pinv[j] : j;
+      // check column J is empty
       if (J < 0) {
         continue;
-      } // column value indeces in G, p0 <= p < p1
-
-
+      }
+      // column value indeces in G, p0 <= p < p1
       p0 = gptr[J];
-      p1 = gptr[J + 1]; // x(j) /= G(j,j)
-
-      x[j] = divideScalar(x[j], gvalues[lo ? p0 : p1 - 1]); // first entry L(j,j)
-
+      p1 = gptr[J + 1];
+      // x(j) /= G(j,j)
+      x[j] = divideScalar(x[j], gvalues[lo ? p0 : p1 - 1]);
+      // first entry L(j,j)
       p = lo ? p0 + 1 : p0;
-      q = lo ? p1 : p1 - 1; // loop
-
+      q = lo ? p1 : p1 - 1;
+      // loop
       for (; p < q; p++) {
         // row
-        var i = gindex[p]; // x(i) -= G(i,j) * x(j)
-
+        var i = gindex[p];
+        // x(i) -= G(i,j) * x(j)
         x[i] = subtract(x[i], multiply(gvalues[p], x[j]));
       }
-    } // return top of stack
-
-
+    }
+    // return top of stack
     return top;
   };
-});
-exports.createCsSpsolve = createCsSpsolve;
+});

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

@@ -4,25 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createCsSqr = void 0;
-
 var _csPermute = require("./csPermute.js");
-
 var _csPost = require("./csPost.js");
-
 var _csEtree = require("./csEtree.js");
-
 var _csAmd = require("./csAmd.js");
-
 var _csCounts = require("./csCounts.js");
-
 var _factory = require("../../../utils/factory.js");
-
 var name = 'csSqr';
 var dependencies = ['add', 'multiply', 'transpose'];
-var createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createCsSqr = exports.createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var add = _ref.add,
-      multiply = _ref.multiply,
-      transpose = _ref.transpose;
+    multiply = _ref.multiply,
+    transpose = _ref.transpose;
   var csAmd = (0, _csAmd.createCsAmd)({
     add: add,
     multiply: multiply,
@@ -31,6 +24,7 @@ var createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   var csCounts = (0, _csCounts.createCsCounts)({
     transpose: transpose
   });
+
   /**
    * Symbolic ordering and analysis for QR and LU decompositions.
    *
@@ -43,35 +37,33 @@ var createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    *
    * Reference: http://faculty.cse.tamu.edu/davis/publications.html
    */
-
   return function csSqr(order, a, qr) {
     // a arrays
     var aptr = a._ptr;
-    var asize = a._size; // columns
-
-    var n = asize[1]; // vars
-
-    var k; // symbolic analysis result
-
-    var s = {}; // fill-reducing ordering
-
-    s.q = csAmd(order, a); // validate results
-
+    var asize = a._size;
+    // columns
+    var n = asize[1];
+    // vars
+    var k;
+    // symbolic analysis result
+    var s = {};
+    // fill-reducing ordering
+    s.q = csAmd(order, a);
+    // validate results
     if (order && !s.q) {
       return null;
-    } // QR symbolic analysis
-
-
+    }
+    // QR symbolic analysis
     if (qr) {
       // apply permutations if needed
-      var 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); // col counts chol(C'*C)
-
-      s.cp = csCounts(c, s.parent, post, 1); // check we have everything needed to calculate number of nonzero elements
-
+      var 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);
+      // col counts chol(C'*C)
+      s.cp = csCounts(c, s.parent, post, 1);
+      // check we have everything needed to calculate number of nonzero elements
       if (c && s.parent && s.cp && _vcount(c, s)) {
         // calculate number of nonzero elements
         for (s.unz = 0, k = 0; k < n; k++) {
@@ -82,126 +74,109 @@ var createCsSqr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       // for LU factorization only, guess nnz(L) and nnz(U)
       s.unz = 4 * aptr[n] + n;
       s.lnz = s.unz;
-    } // return result S
-
-
+    }
+    // return result S
     return s;
   };
+
   /**
    * Compute nnz(V) = s.lnz, s.pinv, s.leftmost, s.m2 from A and s.parent
    */
-
   function _vcount(a, s) {
     // a arrays
     var aptr = a._ptr;
     var aindex = a._index;
-    var asize = a._size; // rows & columns
-
+    var asize = a._size;
+    // rows & columns
     var m = asize[0];
-    var n = asize[1]; // initialize s arrays
-
+    var 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; // workspace, next: first m entries, head: next n entries, tail: next n entries, nque: next n entries
-
+    var 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; // vars
-
-    var i, k, p, p0, p1; // initialize w
-
+    var nque = m + 2 * n;
+    // vars
+    var i, k, p, p0, p1;
+    // initialize w
     for (k = 0; k < n; k++) {
       // queue k is empty
       w[head + k] = -1;
       w[tail + k] = -1;
       w[nque + k] = 0;
-    } // initialize row arrays
-
-
+    }
+    // initialize row arrays
     for (i = 0; i < m; i++) {
       leftmost[i] = -1;
-    } // loop columns backwards
-
-
+    }
+    // loop columns backwards
     for (k = n - 1; k >= 0; k--) {
       // values & index for column k
       for (p0 = aptr[k], p1 = aptr[k + 1], p = p0; p < p1; p++) {
         // leftmost[i] = min(find(A(i,:)))
         leftmost[aindex[p]] = k;
       }
-    } // scan rows in reverse order
-
-
+    }
+    // scan rows in reverse order
     for (i = m - 1; i >= 0; i--) {
       // row i is not yet ordered
       pinv[i] = -1;
-      k = leftmost[i]; // check row i is empty
-
+      k = leftmost[i];
+      // check row i is empty
       if (k === -1) {
         continue;
-      } // first row in queue k
-
-
+      }
+      // first row in queue k
       if (w[nque + k]++ === 0) {
         w[tail + k] = i;
-      } // put i at head of queue k
-
-
+      }
+      // put i at head of queue k
       w[next + i] = w[head + k];
       w[head + k] = i;
     }
-
     s.lnz = 0;
-    s.m2 = m; // find row permutation and nnz(V)
-
+    s.m2 = m;
+    // find row permutation and nnz(V)
     for (k = 0; k < n; k++) {
       // remove row i from queue k
-      i = w[head + k]; // count V(k,k) as nonzero
-
-      s.lnz++; // add a fictitious row
-
+      i = w[head + k];
+      // count V(k,k) as nonzero
+      s.lnz++;
+      // add a fictitious row
       if (i < 0) {
         i = s.m2++;
-      } // associate row i with V(:,k)
-
-
-      pinv[i] = k; // skip if V(k+1:m,k) is empty
-
+      }
+      // associate row i with V(:,k)
+      pinv[i] = k;
+      // skip if V(k+1:m,k) is empty
       if (--nque[k] <= 0) {
         continue;
-      } // nque[k] is nnz (V(k+1:m,k))
-
-
-      s.lnz += w[nque + k]; // move all rows to parent of k
-
+      }
+      // 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];
-
       if (pa !== -1) {
         if (w[nque + pa] === 0) {
           w[tail + pa] = w[tail + k];
         }
-
         w[next + w[tail + k]] = w[head + pa];
         w[head + pa] = w[next + i];
         w[nque + pa] += w[nque + k];
       }
     }
-
     for (i = 0; i < m; i++) {
       if (pinv[i] < 0) {
         pinv[i] = k++;
       }
     }
-
     return true;
   }
-});
-exports.createCsSqr = createCsSqr;
+});

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

@@ -4,17 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createCsSymperm = void 0;
-
 var _csCumsum = require("./csCumsum.js");
-
 var _factory = require("../../../utils/factory.js");
-
 var name = 'csSymperm';
 var dependencies = ['conj', 'SparseMatrix'];
-var createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createCsSymperm = exports.createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var conj = _ref.conj,
-      SparseMatrix = _ref.SparseMatrix;
-
+    SparseMatrix = _ref.SparseMatrix;
   /**
    * Computes the symmetric permutation of matrix A accessing only
    * the upper triangular part of A.
@@ -34,69 +30,62 @@ var createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     var avalues = a._values;
     var aindex = a._index;
     var aptr = a._ptr;
-    var asize = a._size; // columns
-
-    var n = asize[1]; // C matrix arrays
-
+    var asize = a._size;
+    // columns
+    var n = asize[1];
+    // C matrix arrays
     var cvalues = values && avalues ? [] : null;
     var cindex = []; // (nz)
-
     var cptr = []; // (n + 1)
     // variables
-
-    var i, i2, j, j2, p, p0, p1; // create workspace vector
-
+    var i, i2, j, j2, p, p0, p1;
+    // create workspace vector
     var w = []; // (n)
     // count entries in each column of C
-
     for (j = 0; j < n; j++) {
       // column j of A is column j2 of C
-      j2 = pinv ? pinv[j] : j; // loop values in column j
-
+      j2 = pinv ? pinv[j] : j;
+      // loop values in column j
       for (p0 = aptr[j], p1 = aptr[j + 1], p = p0; p < p1; p++) {
         // row
-        i = aindex[p]; // skip lower triangular part of A
-
+        i = aindex[p];
+        // skip lower triangular part of A
         if (i > j) {
           continue;
-        } // row i of A is row i2 of C
-
-
-        i2 = pinv ? pinv[i] : i; // column count of C
-
+        }
+        // row i of A is row i2 of C
+        i2 = pinv ? pinv[i] : i;
+        // column count of C
         w[Math.max(i2, j2)]++;
       }
-    } // compute column pointers of C
-
-
-    (0, _csCumsum.csCumsum)(cptr, w, n); // loop columns
-
+    }
+    // compute column pointers of C
+    (0, _csCumsum.csCumsum)(cptr, w, n);
+    // loop columns
     for (j = 0; j < n; j++) {
       // column j of A is column j2 of C
-      j2 = pinv ? pinv[j] : j; // loop values in column j
-
+      j2 = pinv ? pinv[j] : j;
+      // loop values in column j
       for (p0 = aptr[j], p1 = aptr[j + 1], p = p0; p < p1; p++) {
         // row
-        i = aindex[p]; // skip lower triangular part of A
-
+        i = aindex[p];
+        // skip lower triangular part of A
         if (i > j) {
           continue;
-        } // 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)]++; // update C index for entry q
-
-        cindex[q] = Math.min(i2, j2); // check we need to process values
-
+        }
+        // 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)]++;
+        // update C index for entry q
+        cindex[q] = Math.min(i2, j2);
+        // check we need to process values
         if (cvalues) {
           cvalues[q] = i2 <= j2 ? avalues[p] : conj(avalues[p]);
         }
       }
-    } // return C matrix
-
-
+    }
+    // return C matrix
     return new SparseMatrix({
       values: cvalues,
       index: cindex,
@@ -104,5 +93,4 @@ var createCsSymperm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       size: [n, n]
     });
   };
-});
-exports.createCsSymperm = createCsSymperm;
+});

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csTdfs = csTdfs;
-
 /**
  * Depth-first search and postorder of a tree rooted at node j
  *
@@ -20,30 +19,28 @@ exports.csTdfs = csTdfs;
  */
 function csTdfs(j, k, w, head, next, post, stack) {
   // variables
-  var top = 0; // place j on the stack
-
-  w[stack] = j; // while (stack is not empty)
-
+  var 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]; // i = youngest child of p
-
+    var p = w[stack + top];
+    // i = youngest child of p
     var i = w[head + p];
-
     if (i === -1) {
       // p has no unordered children left
-      top--; // node p is the kth postordered node
-
+      top--;
+      // node p is the kth postordered node
       post[k++] = p;
     } else {
       // remove i from children of p
-      w[head + p] = w[next + i]; // increment top
-
-      ++top; // start dfs on child node i
-
+      w[head + p] = w[next + i];
+      // increment top
+      ++top;
+      // start dfs on child node i
       w[stack + top] = i;
     }
   }
-
   return k;
 }