mathjs 11.2.0 → 11.3.0

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csEtree = csEtree;
-
 /**
  * Computes the elimination tree of Matrix A (using triu(A)) or the
  * elimination tree of A'A without forming A'A.
@@ -18,63 +17,59 @@ function csEtree(a, ata) {
   // check inputs
   if (!a) {
     return null;
-  } // a arrays
-
-
+  }
+  // a arrays
   var aindex = a._index;
   var aptr = a._ptr;
-  var asize = a._size; // rows & columns
-
+  var asize = a._size;
+  // rows & columns
   var m = asize[0];
-  var n = asize[1]; // allocate result
+  var n = asize[1];
 
+  // allocate result
   var parent = []; // (n)
-  // allocate workspace
 
+  // allocate workspace
   var w = []; // (n + (ata ? m : 0))
-
   var ancestor = 0; // first n entries in w
-
   var prev = n; // last m entries (ata = true)
 
-  var i, inext; // check we are calculating A'A
+  var i, inext;
 
+  // check we are calculating A'A
   if (ata) {
     // initialize workspace
     for (i = 0; i < m; i++) {
       w[prev + i] = -1;
     }
-  } // loop columns
-
-
+  }
+  // loop columns
   for (var 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
-
+    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++) {
       // row
-      var r = aindex[p]; // node
-
-      i = ata ? w[prev + r] : r; // traverse from i to k
-
+      var r = aindex[p];
+      // node
+      i = ata ? w[prev + r] : r;
+      // traverse from i to k
       for (; i !== -1 && i < k; i = inext) {
         // inext = ancestor of i
-        inext = w[ancestor + i]; // path compression
-
-        w[ancestor + i] = k; // check no anc., parent is k
-
+        inext = w[ancestor + i];
+        // path compression
+        w[ancestor + i] = k;
+        // check no anc., parent is k
         if (inext === -1) {
           parent[i] = k;
         }
       }
-
       if (ata) {
         w[prev + r] = k;
       }
     }
   }
-
   return parent;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csFkeep = csFkeep;
-
 /**
  * Keeps entries in the matrix when the callback function returns true, removes the entry otherwise
  *
@@ -25,43 +24,39 @@ function csFkeep(a, callback, other) {
   var avalues = a._values;
   var aindex = a._index;
   var aptr = a._ptr;
-  var asize = a._size; // columns
-
-  var n = asize[1]; // nonzero items
-
-  var nz = 0; // loop columns
-
+  var asize = a._size;
+  // columns
+  var n = asize[1];
+  // nonzero items
+  var nz = 0;
+  // loop columns
   for (var j = 0; j < n; j++) {
     // get current location of col j
-    var p = aptr[j]; // record new location of col j
-
+    var p = aptr[j];
+    // record new location of col j
     aptr[j] = nz;
-
     for (; p < aptr[j + 1]; p++) {
       // check we need to keep this item
       if (callback(aindex[p], j, avalues ? avalues[p] : 1, other)) {
         // keep A(i,j)
-        aindex[nz] = aindex[p]; // check we need to process values (pattern only)
-
+        aindex[nz] = aindex[p];
+        // check we need to process values (pattern only)
         if (avalues) {
           avalues[nz] = avalues[p];
-        } // increment nonzero items
-
-
+        }
+        // increment nonzero items
         nz++;
       }
     }
-  } // finalize A
-
-
-  aptr[n] = nz; // trim arrays
-
-  aindex.splice(nz, aindex.length - nz); // check we need to process values (pattern only)
-
+  }
+  // finalize A
+  aptr[n] = nz;
+  // trim arrays
+  aindex.splice(nz, aindex.length - nz);
+  // check we need to process values (pattern only)
   if (avalues) {
     avalues.splice(nz, avalues.length - nz);
-  } // return number of nonzero items
-
-
+  }
+  // return number of nonzero items
   return nz;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csFlip = csFlip;
-
 /**
  * This function "flips" its input about the integer -1.
  *

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csIpvec = csIpvec;
-
 /**
  * Permutes a vector; x = P'b. In MATLAB notation, x(p)=b.
  *
@@ -17,8 +16,8 @@ function csIpvec(p, b) {
   // vars
   var k;
   var n = b.length;
-  var x = []; // check permutation vector was provided, p = null denotes identity
-
+  var x = [];
+  // check permutation vector was provided, p = null denotes identity
   if (p) {
     // loop vector
     for (k = 0; k < n; k++) {
@@ -32,6 +31,5 @@ function csIpvec(p, b) {
       x[k] = b[k];
     }
   }
-
   return x;
 }

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csLeaf = csLeaf;
-
 /**
  * This function determines if j is a leaf of the ith row subtree.
  * Consider A(i,j), node j in ith row subtree and return lca(jprev,j)
@@ -22,40 +21,40 @@ exports.csLeaf = csLeaf;
  * Reference: http://faculty.cse.tamu.edu/davis/publications.html
  */
 function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
-  var s, sparent; // our result
+  var s, sparent;
 
+  // our result
   var jleaf = 0;
-  var q; // check j is a leaf
+  var q;
 
+  // check j is a leaf
   if (i <= j || w[first + j] <= w[maxfirst + i]) {
     return -1;
-  } // update max first[j] seen so far
-
-
-  w[maxfirst + i] = w[first + j]; // jprev = previous leaf of ith subtree
-
+  }
+  // update max first[j] seen so far
+  w[maxfirst + i] = w[first + j];
+  // jprev = previous leaf of ith subtree
   var jprev = w[prevleaf + i];
-  w[prevleaf + i] = j; // check j is first or subsequent leaf
+  w[prevleaf + i] = j;
 
+  // check j is first or subsequent leaf
   if (jprev === -1) {
     // 1st leaf, q = root of ith subtree
     jleaf = 1;
     q = i;
   } else {
     // update jleaf
-    jleaf = 2; // q = least common ancester (jprev,j)
-
+    jleaf = 2;
+    // q = least common ancester (jprev,j)
     for (q = jprev; q !== w[ancestor + q]; q = w[ancestor + q]) {
       ;
     }
-
     for (s = jprev; s !== q; s = sparent) {
       // path compression
       sparent = w[ancestor + s];
       w[ancestor + s] = q;
     }
   }
-
   return {
     jleaf: jleaf,
     q: q

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

@@ -4,26 +4,24 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createCsLu = void 0;
-
 var _factory = require("../../../utils/factory.js");
-
 var _csSpsolve = require("./csSpsolve.js");
-
 var name = 'csLu';
 var dependencies = ['abs', 'divideScalar', 'multiply', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
 var 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;
+    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
   });
+
   /**
    * Computes the numeric LU factorization of the sparse matrix A. Implements a Left-looking LU factorization
    * algorithm that computes L and U one column at a tume. At the kth step, it access columns 1 to k-1 of L
@@ -39,100 +37,87 @@ var createCsLu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    *
    * Reference: http://faculty.cse.tamu.edu/davis/publications.html
    */
-
   return function csLu(m, s, tol) {
     // validate input
     if (!m) {
       return null;
-    } // m arrays
-
-
-    var size = m._size; // columns
-
-    var n = size[1]; // symbolic analysis result
-
+    }
+    // m arrays
+    var size = m._size;
+    // columns
+    var n = size[1];
+    // symbolic analysis result
     var q;
     var lnz = 100;
-    var unz = 100; // update symbolic analysis parameters
-
+    var unz = 100;
+    // update symbolic analysis parameters
     if (s) {
       q = s.q;
       lnz = s.lnz || lnz;
       unz = s.unz || unz;
-    } // L arrays
-
-
+    }
+    // L arrays
     var lvalues = []; // (lnz)
-
     var lindex = []; // (lnz)
-
     var lptr = []; // (n + 1)
     // L
-
     var L = new SparseMatrix({
       values: lvalues,
       index: lindex,
       ptr: lptr,
       size: [n, n]
-    }); // U arrays
-
+    });
+    // U arrays
     var uvalues = []; // (unz)
-
     var uindex = []; // (unz)
-
     var uptr = []; // (n + 1)
     // U
-
     var U = new SparseMatrix({
       values: uvalues,
       index: uindex,
       ptr: uptr,
       size: [n, n]
-    }); // inverse of permutation vector
-
+    });
+    // inverse of permutation vector
     var pinv = []; // (n)
     // vars
-
-    var i, p; // allocate arrays
-
+    var i, p;
+    // allocate arrays
     var x = []; // (n)
-
     var xi = []; // (2 * n)
     // initialize variables
-
     for (i = 0; i < n; i++) {
       // clear workspace
-      x[i] = 0; // no rows pivotal yet
-
-      pinv[i] = -1; // no cols of L yet
-
+      x[i] = 0;
+      // no rows pivotal yet
+      pinv[i] = -1;
+      // no cols of L yet
       lptr[i + 1] = 0;
-    } // reset number of nonzero elements in L and U
-
-
+    }
+    // reset number of nonzero elements in L and U
     lnz = 0;
-    unz = 0; // compute L(:,k) and U(:,k)
-
+    unz = 0;
+    // compute L(:,k) and U(:,k)
     for (var k = 0; k < n; k++) {
       // update ptr
       lptr[k] = lnz;
-      uptr[k] = unz; // apply column permutations if needed
-
-      var col = q ? q[k] : k; // solve triangular system, x = L\A(:,col)
-
-      var top = csSpsolve(L, m, col, xi, x, pinv, 1); // find pivot
-
+      uptr[k] = unz;
+      // apply column permutations if needed
+      var col = q ? q[k] : k;
+      // solve triangular system, x = L\A(:,col)
+      var top = csSpsolve(L, m, col, xi, x, pinv, 1);
+      // find pivot
       var ipiv = -1;
-      var a = -1; // loop xi[] from top -> n
-
+      var a = -1;
+      // loop xi[] from top -> n
       for (p = top; p < n; p++) {
         // x[i] is nonzero
-        i = xi[p]; // check row i is not yet pivotal
-
+        i = xi[p];
+        // check row i is not yet pivotal
         if (pinv[i] < 0) {
           // absolute value of x[i]
-          var xabs = abs(x[i]); // check absoulte value is greater than pivot value
-
+          var xabs = abs(x[i]);
+          // check absoulte value is greater than pivot value
           if (larger(xabs, a)) {
             // largest pivot candidate so far
             a = xabs;
@@ -143,59 +128,53 @@ var createCsLu = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
           uindex[unz] = pinv[i];
           uvalues[unz++] = x[i];
         }
-      } // validate we found a valid pivot
-
-
+      }
+      // validate we found a valid pivot
       if (ipiv === -1 || a <= 0) {
         return null;
-      } // update actual pivot column, give preference to diagonal value
-
-
+      }
+      // update actual pivot column, give preference to diagonal value
       if (pinv[col] < 0 && largerEq(abs(x[col]), multiply(a, tol))) {
         ipiv = col;
-      } // the chosen pivot
-
-
-      var pivot = x[ipiv]; // last entry in U(:,k) is U(k,k)
-
+      }
+      // the chosen pivot
+      var pivot = x[ipiv];
+      // last entry in U(:,k) is U(k,k)
       uindex[unz] = k;
-      uvalues[unz++] = pivot; // ipiv is the kth pivot row
-
-      pinv[ipiv] = k; // first entry in L(:,k) is L(k,k) = 1
-
+      uvalues[unz++] = pivot;
+      // ipiv is the kth pivot row
+      pinv[ipiv] = k;
+      // first entry in L(:,k) is L(k,k) = 1
       lindex[lnz] = ipiv;
-      lvalues[lnz++] = 1; // L(k+1:n,k) = x / pivot
-
+      lvalues[lnz++] = 1;
+      // L(k+1:n,k) = x / pivot
       for (p = top; p < n; p++) {
         // row
-        i = xi[p]; // check x(i) is an entry in L(:,k)
-
+        i = xi[p];
+        // check x(i) is an entry in L(:,k)
         if (pinv[i] < 0) {
           // save unpermuted row in L
-          lindex[lnz] = i; // scale pivot column
-
+          lindex[lnz] = i;
+          // scale pivot column
           lvalues[lnz++] = divideScalar(x[i], pivot);
-        } // x[0..n-1] = 0 for next k
-
-
+        }
+        // x[0..n-1] = 0 for next k
         x[i] = 0;
       }
-    } // update ptr
-
-
+    }
+    // update ptr
     lptr[n] = lnz;
-    uptr[n] = unz; // fix row indices of L for final pinv
-
+    uptr[n] = unz;
+    // fix row indices of L for final pinv
     for (p = 0; p < lnz; p++) {
       lindex[p] = pinv[lindex[p]];
-    } // trim arrays
-
-
+    }
+    // trim arrays
     lvalues.splice(lnz, lvalues.length - lnz);
     lindex.splice(lnz, lindex.length - lnz);
     uvalues.splice(unz, uvalues.length - unz);
-    uindex.splice(unz, uindex.length - unz); // return LU factor
-
+    uindex.splice(unz, uindex.length - unz);
+    // return LU factor
     return {
       L: L,
       U: U,

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

@@ -4,9 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csMark = csMark;
-
 var _csFlip = require("./csFlip.js");
-
 /**
  * Marks the node at w[j]
  *

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csMarked = csMarked;
-
 /**
  * Checks if the node at w[j] is marked
  *

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

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.csPermute = csPermute;
-
 /**
  * Permutes a sparse matrix C = P * A * Q
  *
@@ -23,43 +22,39 @@ function csPermute(a, pinv, q, values) {
   var aindex = a._index;
   var aptr = a._ptr;
   var asize = a._size;
-  var adt = a._datatype; // rows & columns
-
+  var adt = a._datatype;
+  // rows & columns
   var m = asize[0];
-  var n = asize[1]; // c arrays
-
+  var n = asize[1];
+  // c arrays
   var cvalues = values && a._values ? [] : null;
   var cindex = []; // (aptr[n])
-
   var cptr = []; // (n + 1)
   // initialize vars
-
-  var nz = 0; // loop columns
-
+  var nz = 0;
+  // loop columns
   for (var 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; // loop values in column j of A
-
+    cptr[k] = nz;
+    // apply column permutation
+    var 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++) {
       // row i of A is row pinv[i] of C
-      var r = pinv ? pinv[aindex[t]] : aindex[t]; // index
-
-      cindex[nz] = r; // check we need to populate values
-
+      var r = pinv ? pinv[aindex[t]] : aindex[t];
+      // index
+      cindex[nz] = r;
+      // check we need to populate values
       if (cvalues) {
         cvalues[nz] = avalues[t];
-      } // increment number of nonzero elements
-
-
+      }
+      // increment number of nonzero elements
       nz++;
     }
-  } // finalize the last column of C
-
-
-  cptr[n] = nz; // return C matrix
-
+  }
+  // finalize the last column of C
+  cptr[n] = nz;
+  // return C matrix
   return a.createSparseMatrix({
     values: cvalues,
     index: cindex,

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;
 }