mathjs-min 11.7.2

package/lib/cjs/type/matrix/utils/matAlgo04xSidSid.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo04xSidSid = void 0;
+var _factory = require("../../../utils/factory.js");
+var _DimensionError = require("../../../error/DimensionError.js");
+var name = 'matAlgo04xSidSid';
+var dependencies = ['typed', 'equalScalar'];
+var createMatAlgo04xSidSid = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    equalScalar = _ref.equalScalar;
+  /**
+   * Iterates over SparseMatrix A and SparseMatrix B nonzero items and invokes the callback function f(Aij, Bij).
+   * Callback function invoked MAX(NNZA, NNZB) times
+   *
+   *
+   *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
+   * C(i,j) = ┤  A(i,j)       ; A(i,j) !== 0 && B(i,j) === 0
+   *          └  B(i,j)       ; A(i,j) === 0
+   *
+   *
+   * @param {Matrix}   a                 The SparseMatrix instance (A)
+   * @param {Matrix}   b                 The SparseMatrix instance (B)
+   * @param {Function} callback          The f(Aij,Bij) operation to invoke
+   *
+   * @return {Matrix}                    SparseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
+   */
+  return function matAlgo04xSidSid(a, b, callback) {
+    // sparse matrix arrays
+    var avalues = a._values;
+    var aindex = a._index;
+    var aptr = a._ptr;
+    var asize = a._size;
+    var adt = a._datatype;
+    // sparse matrix arrays
+    var bvalues = b._values;
+    var bindex = b._index;
+    var bptr = b._ptr;
+    var bsize = b._size;
+    var bdt = b._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new _DimensionError.DimensionError(asize.length, bsize.length);
+    }
+
+    // check rows & columns
+    if (asize[0] !== bsize[0] || asize[1] !== bsize[1]) {
+      throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
+    }
+
+    // rows & columns
+    var rows = asize[0];
+    var columns = asize[1];
+
+    // datatype
+    var dt;
+    // equal signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string' && adt === bdt) {
+      // datatype
+      dt = adt;
+      // find signature that matches (dt, dt)
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
+      zero = typed.convert(0, dt);
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // result arrays
+    var cvalues = avalues && bvalues ? [] : undefined;
+    var cindex = [];
+    var cptr = [];
+
+    // workspace
+    var xa = avalues && bvalues ? [] : undefined;
+    var xb = avalues && bvalues ? [] : undefined;
+    // marks indicating we have a value in x for a given column
+    var wa = [];
+    var wb = [];
+
+    // vars
+    var i, j, k, k0, k1;
+
+    // loop columns
+    for (j = 0; j < columns; j++) {
+      // update cptr
+      cptr[j] = cindex.length;
+      // columns mark
+      var mark = j + 1;
+      // loop A(:,j)
+      for (k0 = aptr[j], k1 = aptr[j + 1], k = k0; k < k1; k++) {
+        // row
+        i = aindex[k];
+        // update c
+        cindex.push(i);
+        // update workspace
+        wa[i] = mark;
+        // check we need to process values
+        if (xa) {
+          xa[i] = avalues[k];
+        }
+      }
+      // loop B(:,j)
+      for (k0 = bptr[j], k1 = bptr[j + 1], k = k0; k < k1; k++) {
+        // row
+        i = bindex[k];
+        // check row exists in A
+        if (wa[i] === mark) {
+          // update record in xa @ i
+          if (xa) {
+            // invoke callback
+            var v = cf(xa[i], bvalues[k]);
+            // check for zero
+            if (!eq(v, zero)) {
+              // update workspace
+              xa[i] = v;
+            } else {
+              // remove mark (index will be removed later)
+              wa[i] = null;
+            }
+          }
+        } else {
+          // update c
+          cindex.push(i);
+          // update workspace
+          wb[i] = mark;
+          // check we need to process values
+          if (xb) {
+            xb[i] = bvalues[k];
+          }
+        }
+      }
+      // check we need to process values (non pattern matrix)
+      if (xa && xb) {
+        // initialize first index in j
+        k = cptr[j];
+        // loop index in j
+        while (k < cindex.length) {
+          // row
+          i = cindex[k];
+          // check workspace has value @ i
+          if (wa[i] === mark) {
+            // push value (Aij != 0 || (Aij != 0 && Bij != 0))
+            cvalues[k] = xa[i];
+            // increment pointer
+            k++;
+          } else if (wb[i] === mark) {
+            // push value (bij != 0)
+            cvalues[k] = xb[i];
+            // increment pointer
+            k++;
+          } else {
+            // remove index @ k
+            cindex.splice(k, 1);
+          }
+        }
+      }
+    }
+    // update cptr
+    cptr[columns] = cindex.length;
+
+    // return sparse matrix
+    return a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});
+exports.createMatAlgo04xSidSid = createMatAlgo04xSidSid;

package/lib/cjs/type/matrix/utils/matAlgo05xSfSf.js

@@ -0,0 +1,176 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo05xSfSf = void 0;
+var _factory = require("../../../utils/factory.js");
+var _DimensionError = require("../../../error/DimensionError.js");
+var name = 'matAlgo05xSfSf';
+var dependencies = ['typed', 'equalScalar'];
+var createMatAlgo05xSfSf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    equalScalar = _ref.equalScalar;
+  /**
+   * Iterates over SparseMatrix A and SparseMatrix B nonzero items and invokes the callback function f(Aij, Bij).
+   * Callback function invoked MAX(NNZA, NNZB) times
+   *
+   *
+   *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 || B(i,j) !== 0
+   * C(i,j) = ┤
+   *          └  0            ; otherwise
+   *
+   *
+   * @param {Matrix}   a                 The SparseMatrix instance (A)
+   * @param {Matrix}   b                 The SparseMatrix instance (B)
+   * @param {Function} callback          The f(Aij,Bij) operation to invoke
+   *
+   * @return {Matrix}                    SparseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
+   */
+  return function matAlgo05xSfSf(a, b, callback) {
+    // sparse matrix arrays
+    var avalues = a._values;
+    var aindex = a._index;
+    var aptr = a._ptr;
+    var asize = a._size;
+    var adt = a._datatype;
+    // sparse matrix arrays
+    var bvalues = b._values;
+    var bindex = b._index;
+    var bptr = b._ptr;
+    var bsize = b._size;
+    var bdt = b._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new _DimensionError.DimensionError(asize.length, bsize.length);
+    }
+
+    // check rows & columns
+    if (asize[0] !== bsize[0] || asize[1] !== bsize[1]) {
+      throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
+    }
+
+    // rows & columns
+    var rows = asize[0];
+    var columns = asize[1];
+
+    // datatype
+    var dt;
+    // equal signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string' && adt === bdt) {
+      // datatype
+      dt = adt;
+      // find signature that matches (dt, dt)
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
+      zero = typed.convert(0, dt);
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // result arrays
+    var cvalues = avalues && bvalues ? [] : undefined;
+    var cindex = [];
+    var cptr = [];
+
+    // workspaces
+    var xa = cvalues ? [] : undefined;
+    var xb = cvalues ? [] : undefined;
+    // marks indicating we have a value in x for a given column
+    var wa = [];
+    var wb = [];
+
+    // vars
+    var i, j, k, k1;
+
+    // loop columns
+    for (j = 0; j < columns; j++) {
+      // update cptr
+      cptr[j] = cindex.length;
+      // columns mark
+      var mark = j + 1;
+      // loop values A(:,j)
+      for (k = aptr[j], k1 = aptr[j + 1]; k < k1; k++) {
+        // row
+        i = aindex[k];
+        // push index
+        cindex.push(i);
+        // update workspace
+        wa[i] = mark;
+        // check we need to process values
+        if (xa) {
+          xa[i] = avalues[k];
+        }
+      }
+      // loop values B(:,j)
+      for (k = bptr[j], k1 = bptr[j + 1]; k < k1; k++) {
+        // row
+        i = bindex[k];
+        // check row existed in A
+        if (wa[i] !== mark) {
+          // push index
+          cindex.push(i);
+        }
+        // update workspace
+        wb[i] = mark;
+        // check we need to process values
+        if (xb) {
+          xb[i] = bvalues[k];
+        }
+      }
+      // check we need to process values (non pattern matrix)
+      if (cvalues) {
+        // initialize first index in j
+        k = cptr[j];
+        // loop index in j
+        while (k < cindex.length) {
+          // row
+          i = cindex[k];
+          // marks
+          var wai = wa[i];
+          var wbi = wb[i];
+          // check Aij or Bij are nonzero
+          if (wai === mark || wbi === mark) {
+            // matrix values @ i,j
+            var va = wai === mark ? xa[i] : zero;
+            var vb = wbi === mark ? xb[i] : zero;
+            // Cij
+            var vc = cf(va, vb);
+            // check for zero
+            if (!eq(vc, zero)) {
+              // push value
+              cvalues.push(vc);
+              // increment pointer
+              k++;
+            } else {
+              // remove value @ i, do not increment pointer
+              cindex.splice(k, 1);
+            }
+          }
+        }
+      }
+    }
+    // update cptr
+    cptr[columns] = cindex.length;
+
+    // return sparse matrix
+    return a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});
+exports.createMatAlgo05xSfSf = createMatAlgo05xSfSf;

package/lib/cjs/type/matrix/utils/matAlgo06xS0S0.js

@@ -0,0 +1,158 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo06xS0S0 = void 0;
+var _factory = require("../../../utils/factory.js");
+var _DimensionError = require("../../../error/DimensionError.js");
+var _collection = require("../../../utils/collection.js");
+var name = 'matAlgo06xS0S0';
+var dependencies = ['typed', 'equalScalar'];
+var createMatAlgo06xS0S0 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    equalScalar = _ref.equalScalar;
+  /**
+   * Iterates over SparseMatrix A and SparseMatrix B nonzero items and invokes the callback function f(Aij, Bij).
+   * Callback function invoked (Anz U Bnz) times, where Anz and Bnz are the nonzero elements in both matrices.
+   *
+   *
+   *          ┌  f(Aij, Bij)  ; A(i,j) !== 0 && B(i,j) !== 0
+   * C(i,j) = ┤
+   *          └  0            ; otherwise
+   *
+   *
+   * @param {Matrix}   a                 The SparseMatrix instance (A)
+   * @param {Matrix}   b                 The SparseMatrix instance (B)
+   * @param {Function} callback          The f(Aij,Bij) operation to invoke
+   *
+   * @return {Matrix}                    SparseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
+   */
+  return function matAlgo06xS0S0(a, b, callback) {
+    // sparse matrix arrays
+    var avalues = a._values;
+    var asize = a._size;
+    var adt = a._datatype;
+    // sparse matrix arrays
+    var bvalues = b._values;
+    var bsize = b._size;
+    var bdt = b._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new _DimensionError.DimensionError(asize.length, bsize.length);
+    }
+
+    // check rows & columns
+    if (asize[0] !== bsize[0] || asize[1] !== bsize[1]) {
+      throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
+    }
+
+    // rows & columns
+    var rows = asize[0];
+    var columns = asize[1];
+
+    // datatype
+    var dt;
+    // equal signature to use
+    var eq = equalScalar;
+    // zero value
+    var zero = 0;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string' && adt === bdt) {
+      // datatype
+      dt = adt;
+      // find signature that matches (dt, dt)
+      eq = typed.find(equalScalar, [dt, dt]);
+      // convert 0 to the same datatype
+      zero = typed.convert(0, dt);
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // result arrays
+    var cvalues = avalues && bvalues ? [] : undefined;
+    var cindex = [];
+    var cptr = [];
+
+    // workspaces
+    var x = cvalues ? [] : undefined;
+    // marks indicating we have a value in x for a given column
+    var w = [];
+    // marks indicating value in a given row has been updated
+    var u = [];
+
+    // loop columns
+    for (var j = 0; j < columns; j++) {
+      // update cptr
+      cptr[j] = cindex.length;
+      // columns mark
+      var mark = j + 1;
+      // scatter the values of A(:,j) into workspace
+      (0, _collection.scatter)(a, j, w, x, u, mark, cindex, cf);
+      // scatter the values of B(:,j) into workspace
+      (0, _collection.scatter)(b, j, w, x, u, mark, cindex, cf);
+      // check we need to process values (non pattern matrix)
+      if (x) {
+        // initialize first index in j
+        var k = cptr[j];
+        // loop index in j
+        while (k < cindex.length) {
+          // row
+          var i = cindex[k];
+          // check function was invoked on current row (Aij !=0 && Bij != 0)
+          if (u[i] === mark) {
+            // value @ i
+            var v = x[i];
+            // check for zero value
+            if (!eq(v, zero)) {
+              // push value
+              cvalues.push(v);
+              // increment pointer
+              k++;
+            } else {
+              // remove value @ i, do not increment pointer
+              cindex.splice(k, 1);
+            }
+          } else {
+            // remove value @ i, do not increment pointer
+            cindex.splice(k, 1);
+          }
+        }
+      } else {
+        // initialize first index in j
+        var p = cptr[j];
+        // loop index in j
+        while (p < cindex.length) {
+          // row
+          var r = cindex[p];
+          // check function was invoked on current row (Aij !=0 && Bij != 0)
+          if (u[r] !== mark) {
+            // remove value @ i, do not increment pointer
+            cindex.splice(p, 1);
+          } else {
+            // increment pointer
+            p++;
+          }
+        }
+      }
+    }
+    // update cptr
+    cptr[columns] = cindex.length;
+
+    // return sparse matrix
+    return a.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});
+exports.createMatAlgo06xS0S0 = createMatAlgo06xS0S0;

package/lib/cjs/type/matrix/utils/matAlgo07xSSf.js

@@ -0,0 +1,124 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatAlgo07xSSf = void 0;
+var _factory = require("../../../utils/factory.js");
+var _DimensionError = require("../../../error/DimensionError.js");
+var name = 'matAlgo07xSSf';
+var dependencies = ['typed', 'DenseMatrix'];
+var createMatAlgo07xSSf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    DenseMatrix = _ref.DenseMatrix;
+  /**
+   * Iterates over SparseMatrix A and SparseMatrix B items (zero and nonzero) and invokes the callback function f(Aij, Bij).
+   * Callback function invoked MxN times.
+   *
+   * C(i,j) = f(Aij, Bij)
+   *
+   * @param {Matrix}   a                 The SparseMatrix instance (A)
+   * @param {Matrix}   b                 The SparseMatrix instance (B)
+   * @param {Function} callback          The f(Aij,Bij) operation to invoke
+   *
+   * @return {Matrix}                    DenseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97620294
+   */
+  return function matAlgo07xSSf(a, b, callback) {
+    // sparse matrix arrays
+    var asize = a._size;
+    var adt = a._datatype;
+    // sparse matrix arrays
+    var bsize = b._size;
+    var bdt = b._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new _DimensionError.DimensionError(asize.length, bsize.length);
+    }
+
+    // check rows & columns
+    if (asize[0] !== bsize[0] || asize[1] !== bsize[1]) {
+      throw new RangeError('Dimension mismatch. Matrix A (' + asize + ') must match Matrix B (' + bsize + ')');
+    }
+
+    // rows & columns
+    var rows = asize[0];
+    var columns = asize[1];
+
+    // datatype
+    var dt;
+    // zero value
+    var zero = 0;
+    // callback signature to use
+    var cf = callback;
+
+    // process data types
+    if (typeof adt === 'string' && adt === bdt) {
+      // datatype
+      dt = adt;
+      // convert 0 to the same datatype
+      zero = typed.convert(0, dt);
+      // callback
+      cf = typed.find(callback, [dt, dt]);
+    }
+
+    // vars
+    var i, j;
+
+    // result arrays
+    var cdata = [];
+    // initialize c
+    for (i = 0; i < rows; i++) {
+      cdata[i] = [];
+    }
+
+    // workspaces
+    var xa = [];
+    var xb = [];
+    // marks indicating we have a value in x for a given column
+    var wa = [];
+    var wb = [];
+
+    // loop columns
+    for (j = 0; j < columns; j++) {
+      // columns mark
+      var mark = j + 1;
+      // scatter the values of A(:,j) into workspace
+      _scatter(a, j, wa, xa, mark);
+      // scatter the values of B(:,j) into workspace
+      _scatter(b, j, wb, xb, mark);
+      // loop rows
+      for (i = 0; i < rows; i++) {
+        // matrix values @ i,j
+        var va = wa[i] === mark ? xa[i] : zero;
+        var vb = wb[i] === mark ? xb[i] : zero;
+        // invoke callback
+        cdata[i][j] = cf(va, vb);
+      }
+    }
+
+    // return dense matrix
+    return new DenseMatrix({
+      data: cdata,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+  function _scatter(m, j, w, x, mark) {
+    // a arrays
+    var values = m._values;
+    var index = m._index;
+    var ptr = m._ptr;
+    // loop values in column j
+    for (var k = ptr[j], k1 = ptr[j + 1]; k < k1; k++) {
+      // row
+      var i = index[k];
+      // update workspace
+      w[i] = mark;
+      x[i] = values[k];
+    }
+  }
+});
+exports.createMatAlgo07xSSf = createMatAlgo07xSSf;