@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csLeaf.js

@@ -0,0 +1,56 @@
+/**
+ * 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)
+ *
+ * @param {Number}  i               The ith row subtree
+ * @param {Number}  j               The node to test
+ * @param {Array}   w               The workspace array
+ * @param {Number}  first           The index offset within the workspace for the first array
+ * @param {Number}  maxfirst        The index offset within the workspace for the maxfirst array
+ * @param {Number}  prevleaf        The index offset within the workspace for the prevleaf array
+ * @param {Number}  ancestor        The index offset within the workspace for the ancestor array
+ *
+ * @return {Object}
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+export function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
+  var s, sparent; // our result
+
+  var jleaf = 0;
+  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
+
+  var jprev = w[prevleaf + i];
+  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)
+
+    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,
+    q
+  };
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csLu.js

@@ -0,0 +1,198 @@
+import { factory } from '../../../utils/factory.js';
+import { createCsSpsolve } from './csSpsolve.js';
+var name = 'csLu';
+var dependencies = ['abs', 'divideScalar', 'multiply', 'subtract', 'larger', 'largerEq', 'SparseMatrix'];
+export var createCsLu = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    abs,
+    divideScalar,
+    multiply,
+    subtract,
+    larger,
+    largerEq,
+    SparseMatrix
+  } = _ref;
+  var csSpsolve = createCsSpsolve({
+    divideScalar,
+    multiply,
+    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
+   * and column k of A. Given the fill-reducing column ordering q (see parameter s) computes L, U and pinv so
+   * L * U = A(p, q), where p is the inverse of pinv.
+   *
+   * @param {Matrix}  m               The A Matrix to factorize
+   * @param {Object}  s               The symbolic analysis from csSqr(). Provides the fill-reducing
+   *                                  column ordering q
+   * @param {Number}  tol             Partial pivoting threshold (1 for partial pivoting)
+   *
+   * @return {Number}                 The numeric LU factorization of A or null
+   *
+   * 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
+
+    var q;
+    var lnz = 100;
+    var unz = 100; // update symbolic analysis parameters
+
+    if (s) {
+      q = s.q;
+      lnz = s.lnz || lnz;
+      unz = s.unz || unz;
+    } // 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
+
+    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
+
+    var pinv = []; // (n)
+    // vars
+
+    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
+
+      lptr[i + 1] = 0;
+    } // reset number of nonzero elements in L and U
+
+
+    lnz = 0;
+    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
+
+      var ipiv = -1;
+      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
+
+        if (pinv[i] < 0) {
+          // absolute value of x[i]
+          var xabs = abs(x[i]); // check absoulte value is greater than pivot value
+
+          if (larger(xabs, a)) {
+            // largest pivot candidate so far
+            a = xabs;
+            ipiv = i;
+          }
+        } else {
+          // x(i) is the entry U(pinv[i],k)
+          uindex[unz] = pinv[i];
+          uvalues[unz++] = x[i];
+        }
+      } // validate we found a valid pivot
+
+
+      if (ipiv === -1 || a <= 0) {
+        return null;
+      } // 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)
+
+      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
+
+      lindex[lnz] = ipiv;
+      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)
+
+        if (pinv[i] < 0) {
+          // save unpermuted row in L
+          lindex[lnz] = i; // scale pivot column
+
+          lvalues[lnz++] = divideScalar(x[i], pivot);
+        } // x[0..n-1] = 0 for next k
+
+
+        x[i] = 0;
+      }
+    } // update ptr
+
+
+    lptr[n] = lnz;
+    uptr[n] = unz; // fix row indices of L for final pinv
+
+    for (p = 0; p < lnz; p++) {
+      lindex[p] = pinv[lindex[p]];
+    } // 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
+
+    return {
+      L,
+      U,
+      pinv
+    };
+  };
+});

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csMark.js

@@ -0,0 +1,14 @@
+import { csFlip } from './csFlip.js';
+/**
+ * Marks the node at w[j]
+ *
+ * @param {Array}   w               The array
+ * @param {Number}  j               The array index
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+
+export function csMark(w, j) {
+  // mark w[j]
+  w[j] = csFlip(w[j]);
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csMarked.js

@@ -0,0 +1,12 @@
+/**
+ * Checks if the node at w[j] is marked
+ *
+ * @param {Array}   w               The array
+ * @param {Number}  j               The array index
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+export function csMarked(w, j) {
+  // check node is marked
+  return w[j] < 0;
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csPermute.js

@@ -0,0 +1,63 @@
+/**
+ * Permutes a sparse matrix C = P * A * Q
+ *
+ * @param {SparseMatrix}  a         The Matrix A
+ * @param {Array}   pinv            The row permutation vector
+ * @param {Array}   q               The column permutation vector
+ * @param {boolean} values          Create a pattern matrix (false), values and pattern otherwise
+ *
+ * @return {Matrix}                 C = P * A * Q, null on error
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+export 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; // rows & columns
+
+  var m = asize[0];
+  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
+
+  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
+
+    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
+
+      if (cvalues) {
+        cvalues[nz] = avalues[t];
+      } // increment number of nonzero elements
+
+
+      nz++;
+    }
+  } // finalize the last column of C
+
+
+  cptr[n] = nz; // return C matrix
+
+  return a.createSparseMatrix({
+    values: cvalues,
+    index: cindex,
+    ptr: cptr,
+    size: [m, n],
+    datatype: adt
+  });
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csPost.js

@@ -0,0 +1,59 @@
+import { csTdfs } from './csTdfs.js';
+/**
+ * Post order a tree of forest
+ *
+ * @param {Array}   parent          The tree or forest
+ * @param {Number}  n               Number of columns
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+
+export function csPost(parent, n) {
+  // check inputs
+  if (!parent) {
+    return null;
+  } // vars
+
+
+  var k = 0;
+  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
+
+  for (j = 0; j < n; j++) {
+    // empty linked lists
+    w[head + j] = -1;
+  } // 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
+
+
+    w[next + j] = w[head + parent[j]];
+    w[head + parent[j]] = j;
+  } // loop nodes
+
+
+  for (j = 0; j < n; j++) {
+    // skip j if it is not a root
+    if (parent[j] !== -1) {
+      continue;
+    } // depth-first search
+
+
+    k = csTdfs(j, k, w, head, next, post, stack);
+  }
+
+  return post;
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csReach.js

@@ -0,0 +1,52 @@
+import { csMarked } from './csMarked.js';
+import { csMark } from './csMark.js';
+import { csDfs } from './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
+ * nonzero pattern xi of the solution x to the sparse linear system Lx=b is given by X=Reach(B).
+ *
+ * @param {Matrix}  g               The G matrix
+ * @param {Matrix}  b               The B matrix
+ * @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
+ *
+ * @return {Number}                 The index for the nonzero pattern
+ *
+ * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+ */
+
+export function csReach(g, b, k, xi, pinv) {
+  // g arrays
+  var gptr = g._ptr;
+  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
+
+  for (p0 = bptr[k], p1 = bptr[k + 1], p = p0; p < p1; p++) {
+    // node i
+    var i = bindex[p]; // check node i is marked
+
+    if (!csMarked(gptr, i)) {
+      // start a dfs at unmarked node i
+      top = csDfs(i, g, top, xi, pinv);
+    }
+  } // loop columns from top -> n - 1
+
+
+  for (p = top; p < n; p++) {
+    // restore G
+    csMark(gptr, xi[p]);
+  }
+
+  return top;
+}

package/dist/node_modules/mathjs/lib/esm/function/algebra/sparse/csSpsolve.js

@@ -0,0 +1,88 @@
+import { csReach } from './csReach.js';
+import { factory } from '../../../utils/factory.js';
+var name = 'csSpsolve';
+var dependencies = ['divideScalar', 'multiply', 'subtract'];
+export var createCsSpsolve = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    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
+   * diagonal entry as the first entry in each column. When lo is true, the function assumes G = U
+   * is upper triangular with the diagonal entry as the last entry in each column.
+   *
+   * @param {Matrix}  g               The G matrix
+   * @param {Matrix}  b               The B matrix
+   * @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}   x               The soluton to the linear system G * x = b
+   * @param {Array}   pinv            The inverse row permutation vector, must be null for L * x = b
+   * @param {boolean} lo              The lower (true) upper triangular (false) flag
+   *
+   * @return {Number}                 The index for the nonzero pattern
+   *
+   * Reference: http://faculty.cse.tamu.edu/davis/publications.html
+   */
+  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; // 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 = csReach(g, b, k, xi, pinv); // clear x
+
+    for (p = top; p < n; p++) {
+      x[xi[p]] = 0;
+    } // scatter b
+
+
+    for (p0 = bptr[k], p1 = bptr[k + 1], p = p0; p < p1; p++) {
+      x[bindex[p]] = bvalues[p];
+    } // 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
+
+      if (J < 0) {
+        continue;
+      } // 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)
+
+      p = lo ? p0 + 1 : p0;
+      q = lo ? p1 : p1 - 1; // loop
+
+      for (; p < q; p++) {
+        // row
+        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;
+  };
+});