mathjs-min 11.7.2

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

@@ -0,0 +1,161 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCsChol = void 0;
+var _factory = require("../../../utils/factory.js");
+var _csEreach = require("./csEreach.js");
+var _csSymperm = require("./csSymperm.js");
+var name = 'csChol';
+var dependencies = ['divideScalar', 'sqrt', 'subtract', 'multiply', 'im', 're', 'conj', 'equal', 'smallerEq', 'SparseMatrix'];
+var 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
+  });
+
+  /**
+   * Computes the Cholesky factorization of matrix A. It computes L and P so
+   * L * L' = P * A * P'
+   *
+   * @param {Matrix}  m               The A Matrix to factorize, only upper triangular part used
+   * @param {Object}  s               The symbolic analysis from cs_schol()
+   *
+   * @return {Number}                 The numeric Cholesky factorization of A or null
+   *
+   * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+   */
+  return function csChol(m, s) {
+    // validate input
+    if (!m) {
+      return null;
+    }
+    // m arrays
+    var size = m._size;
+    // columns
+    var n = size[1];
+    // symbolic analysis result
+    var parent = s.parent;
+    var cp = s.cp;
+    var pinv = s.pinv;
+    // L arrays
+    var lvalues = [];
+    var lindex = [];
+    var lptr = [];
+    // L
+    var L = new SparseMatrix({
+      values: lvalues,
+      index: lindex,
+      ptr: lptr,
+      size: [n, n]
+    });
+    // vars
+    var c = []; // (2 * n)
+    var x = []; // (n)
+    // compute C = P * A * P'
+    var cm = pinv ? csSymperm(m, pinv, 1) : m;
+    // C matrix arrays
+    var cvalues = cm._values;
+    var cindex = cm._index;
+    var cptr = cm._ptr;
+    // vars
+    var k, p;
+    // initialize variables
+    for (k = 0; k < n; k++) {
+      lptr[k] = c[k] = cp[k];
+    }
+    // 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);
+      // x (0:k) is now zero
+      x[k] = 0;
+      // x = full(triu(C(:,k)))
+      for (p = cptr[k]; p < cptr[k + 1]; p++) {
+        if (cindex[p] <= k) {
+          x[cindex[p]] = cvalues[p];
+        }
+      }
+      // d = C(k,k)
+      var 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];
+        // L(k,i) = x (i) / L(i,i)
+        var 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];
+          // update x[r]
+          x[r] = subtract(x[r], multiply(lvalues[p], lki));
+        }
+        // d = d - L(k,i)*L(k,i)
+        d = subtract(d, multiply(lki, conj(lki)));
+        p = c[i]++;
+        // store L(k,i) in column i
+        lindex[p] = k;
+        lvalues[p] = conj(lki);
+      }
+      // compute L(k,k)
+      if (smallerEq(re(d), 0) || !equal(im(d), 0)) {
+        // not pos def
+        return null;
+      }
+      p = c[k]++;
+      //  store L(k,k) = sqrt(d) in column k
+      lindex[p] = k;
+      lvalues[p] = sqrt(d);
+    }
+    // finalize L
+    lptr[n] = cp[n];
+    // P matrix
+    var P;
+    // check we need to calculate P
+    if (pinv) {
+      // P arrays
+      var pvalues = [];
+      var pindex = [];
+      var pptr = [];
+      // create P matrix
+      for (p = 0; p < n; p++) {
+        // initialize ptr (one value per column)
+        pptr[p] = p;
+        // index (apply permutation vector)
+        pindex.push(pinv[p]);
+        // value 1
+        pvalues.push(1);
+      }
+      // update ptr
+      pptr[n] = n;
+      // P
+      P = new SparseMatrix({
+        values: pvalues,
+        index: pindex,
+        ptr: pptr,
+        size: [n, n]
+      });
+    }
+    // return L & P
+    return {
+      L: L,
+      P: P
+    };
+  };
+});
+exports.createCsChol = createCsChol;

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

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCsCounts = void 0;
+var _factory = require("../../../utils/factory.js");
+var _csLeaf = require("./csLeaf.js");
+var name = 'csCounts';
+var dependencies = ['transpose'];
+var createCsCounts = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var transpose = _ref.transpose;
+  /**
+   * Computes the column counts using the upper triangular part of A.
+   * It transposes A internally, none of the input parameters are modified.
+   *
+   * @param {Matrix} a           The sparse matrix A
+   *
+   * @param {Matrix} ata         Count the columns of A'A instead
+   *
+   * @return                     An array of size n of the column counts or null on error
+   *
+   * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+   */
+  return function (a, parent, post, ata) {
+    // check inputs
+    if (!a || !parent || !post) {
+      return null;
+    }
+    // a matrix arrays
+    var asize = a._size;
+    // rows and columns
+    var m = asize[0];
+    var n = asize[1];
+    // variables
+    var i, j, k, J, p, p0, p1;
+
+    // workspace size
+    var 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
+    // clear workspace w[0..s-1]
+    for (k = 0; k < s; k++) {
+      w[k] = -1;
+    }
+
+    // allocate result
+    var colcount = []; // (n)
+
+    // AT = A'
+    var at = transpose(a);
+    // at arrays
+    var tindex = at._index;
+    var tptr = at._ptr;
+
+    // find w[first + j]
+    for (k = 0; k < n; k++) {
+      j = post[k];
+      // colcount[j]=1 if j is a leaf
+      colcount[j] = w[first + j] === -1 ? 1 : 0;
+      for (; j !== -1 && w[first + j] === -1; j = parent[j]) {
+        w[first + j] = k;
+      }
+    }
+
+    // initialize ata if needed
+    if (ata) {
+      // invert post
+      for (k = 0; k < n; k++) {
+        w[post[k]] = k;
+      }
+      // loop rows (columns in AT)
+      for (i = 0; i < m; i++) {
+        // values in column i of AT
+        for (k = n, p0 = tptr[i], p1 = tptr[i + 1], p = p0; p < p1; p++) {
+          k = Math.min(k, w[tindex[p]]);
+        }
+        // place row i in linked list k
+        w[next + i] = w[head + k];
+        w[head + k] = i;
+      }
+    }
+
+    // each node in its own set
+    for (i = 0; i < n; i++) {
+      w[ancestor + i] = i;
+    }
+    for (k = 0; k < n; k++) {
+      // j is the kth node in postordered etree
+      j = post[k];
+      // check j is not a root
+      if (parent[j] !== -1) {
+        colcount[parent[j]]--;
+      }
+
+      // J=j for LL'=A case
+      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);
+          // check A(i,j) is in skeleton
+          if (r.jleaf >= 1) {
+            colcount[j]++;
+          }
+          // check account for overlap in q
+          if (r.jleaf === 2) {
+            colcount[r.q]--;
+          }
+        }
+      }
+      if (parent[j] !== -1) {
+        w[ancestor + j] = parent[j];
+      }
+    }
+    // sum up colcount's of each child
+    for (j = 0; j < n; j++) {
+      if (parent[j] !== -1) {
+        colcount[parent[j]] += colcount[j];
+      }
+    }
+    return colcount;
+  };
+});
+exports.createCsCounts = createCsCounts;

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csCumsum = csCumsum;
+/**
+ * It sets the p[i] equal to the sum of c[0] through c[i-1].
+ *
+ * @param {Array}   ptr             The Sparse Matrix ptr array
+ * @param {Array}   c               The Sparse Matrix ptr array
+ * @param {Number}  n               The number of columns
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csCumsum(ptr, c, n) {
+  // variables
+  var i;
+  var nz = 0;
+  for (i = 0; i < n; i++) {
+    // initialize ptr @ i
+    ptr[i] = nz;
+    // increment number of nonzeros
+    nz += c[i];
+    // also copy p[0..n-1] back into c[0..n-1]
+    c[i] = ptr[i];
+  }
+  // finalize ptr
+  ptr[n] = nz;
+  // return sum (c [0..n-1])
+  return nz;
+}

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

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csDfs = csDfs;
+var _csMarked = require("./csMarked.js");
+var _csMark = require("./csMark.js");
+var _csUnflip = require("./csUnflip.js");
+/**
+ * Depth-first search computes the nonzero pattern xi of the directed graph G (Matrix) starting
+ * at nodes in B (see csReach()).
+ *
+ * @param {Number}  j               The starting node for the DFS algorithm
+ * @param {Matrix}  g               The G matrix to search, ptr array modified, then restored
+ * @param {Number}  top             Start index in stack xi[top..n-1]
+ * @param {Number}  k               The kth column in B
+ * @param {Array}   xi              The nonzero pattern xi[top] .. xi[n - 1], an array of size = 2 * n
+ *                                  The first n entries is the nonzero pattern, the last n entries is the stack
+ * @param {Array}   pinv            The inverse row permutation vector, must be null for L * x = b
+ *
+ * @return {Number}                 New value of top
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csDfs(j, g, top, xi, pinv) {
+  // g arrays
+  var index = g._index;
+  var ptr = g._ptr;
+  var size = g._size;
+  // columns
+  var n = size[1];
+  // vars
+  var i, p, p2;
+  // initialize head
+  var head = 0;
+  // initialize the recursion stack
+  xi[0] = j;
+  // loop
+  while (head >= 0) {
+    // get j from the top of the recursion stack
+    j = xi[head];
+    // apply permutation vector
+    var jnew = pinv ? pinv[j] : j;
+    // check node j is marked
+    if (!(0, _csMarked.csMarked)(ptr, j)) {
+      // mark node j as visited
+      (0, _csMark.csMark)(ptr, j);
+      // update stack (last n entries in xi)
+      xi[n + head] = jnew < 0 ? 0 : (0, _csUnflip.csUnflip)(ptr[jnew]);
+    }
+    // node j done if no unvisited neighbors
+    var 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
+      i = index[p];
+      // check we have visited node i, skip it
+      if ((0, _csMarked.csMarked)(ptr, i)) {
+        continue;
+      }
+      // pause depth-first search of node j, update stack (last n entries in xi)
+      xi[n + head] = p;
+      // start dfs at node i
+      xi[++head] = i;
+      // node j is not done
+      done = 0;
+      // break, to start dfs(i)
+      break;
+    }
+    // check depth-first search at node j is done
+    if (done) {
+      // remove j from the recursion stack
+      head--;
+      // and place in the output stack
+      xi[--top] = j;
+    }
+  }
+  return top;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csEreach = csEreach;
+var _csMark = require("./csMark.js");
+var _csMarked = require("./csMarked.js");
+/**
+ * Find nonzero pattern of Cholesky L(k,1:k-1) using etree and triu(A(:,k))
+ *
+ * @param {Matrix}  a               The A matrix
+ * @param {Number}  k               The kth column in A
+ * @param {Array}   parent          The parent vector from the symbolic analysis result
+ * @param {Array}   w               The nonzero pattern xi[top] .. xi[n - 1], an array of size = 2 * n
+ *                                  The first n entries is the nonzero pattern, the last n entries is the stack
+ *
+ * @return {Number}                 The index for the nonzero pattern
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csEreach(a, k, parent, w) {
+  // a arrays
+  var aindex = a._index;
+  var aptr = a._ptr;
+  var asize = a._size;
+  // columns
+  var n = asize[1];
+  // initialize top
+  var top = n;
+  // vars
+  var 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];
+    // only use upper triangular part of A
+    if (i > k) {
+      continue;
+    }
+    // traverse up etree
+    for (len = 0; !(0, _csMarked.csMarked)(w, i); i = parent[i]) {
+      // L(k,i) is nonzero, last n entries in w
+      w[n + len++] = i;
+      // mark i as visited
+      (0, _csMark.csMark)(w, i);
+    }
+    while (len > 0) {
+      // decrement top & len
+      --top;
+      --len;
+      // push path onto stack, last n entries in w
+      w[n + top] = w[n + len];
+    }
+  }
+  // unmark all nodes
+  for (p = top; p < n; p++) {
+    // use stack value, last n entries in w
+    (0, _csMark.csMark)(w, w[n + p]);
+  }
+  // unmark node k
+  (0, _csMark.csMark)(w, k);
+  // s[top..n-1] contains pattern of L(k,:)
+  return top;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+
+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.
+ *
+ * @param {Matrix}  a               The A Matrix
+ * @param {boolean} ata             A value of true the function computes the etree of A'A
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csEtree(a, ata) {
+  // check inputs
+  if (!a) {
+    return null;
+  }
+  // a arrays
+  var aindex = a._index;
+  var aptr = a._ptr;
+  var asize = a._size;
+  // rows & columns
+  var m = asize[0];
+  var n = asize[1];
+
+  // allocate result
+  var 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)
+
+  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
+  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
+    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
+      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
+        if (inext === -1) {
+          parent[i] = k;
+        }
+      }
+      if (ata) {
+        w[prev + r] = k;
+      }
+    }
+  }
+  return parent;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csFkeep = csFkeep;
+/**
+ * Keeps entries in the matrix when the callback function returns true, removes the entry otherwise
+ *
+ * @param {Matrix}   a              The sparse matrix
+ * @param {function} callback       The callback function, function will be invoked with the following args:
+ *                                    - The entry row
+ *                                    - The entry column
+ *                                    - The entry value
+ *                                    - The state parameter
+ * @param {any}      other          The state
+ *
+ * @return                          The number of nonzero elements in the matrix
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csFkeep(a, callback, other) {
+  // a arrays
+  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
+  for (var j = 0; j < n; j++) {
+    // get current 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)
+        if (avalues) {
+          avalues[nz] = avalues[p];
+        }
+        // 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)
+  if (avalues) {
+    avalues.splice(nz, avalues.length - nz);
+  }
+  // return number of nonzero items
+  return nz;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csFlip = csFlip;
+/**
+ * This function "flips" its input about the integer -1.
+ *
+ * @param {Number}  i               The value to flip
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+function csFlip(i) {
+  // flip the value
+  return -i - 2;
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.csIpvec = csIpvec;
+/**
+ * Permutes a vector; x = P'b. In MATLAB notation, x(p)=b.
+ *
+ * @param {Array} p           The permutation vector of length n. null value denotes identity
+ * @param {Array} b           The input vector
+ *
+ * @return {Array}            The output vector x = P'b
+ */
+function csIpvec(p, b) {
+  // vars
+  var k;
+  var n = b.length;
+  var x = [];
+  // check permutation vector was provided, p = null denotes identity
+  if (p) {
+    // loop vector
+    for (k = 0; k < n; k++) {
+      // apply permutation
+      x[p[k]] = b[k];
+    }
+  } else {
+    // loop vector
+    for (k = 0; k < n; k++) {
+      // x[i] = b[i]
+      x[k] = b[k];
+    }
+  }
+  return x;
+}