mathjs-min 11.7.2

package/lib/esm/type/matrix/function/index.js

@@ -0,0 +1,62 @@
+import { factory } from '../../../utils/factory.js';
+import { isBigNumber, isMatrix } from '../../../utils/is.js';
+var name = 'index';
+var dependencies = ['typed', 'Index'];
+export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Index
+  } = _ref;
+  /**
+   * Create an index. An Index can store ranges having start, step, and end
+   * for multiple dimensions.
+   * Matrix.get, Matrix.set, and math.subset accept an Index as input.
+   *
+   * Syntax:
+   *
+   *     math.index(range1, range2, ...)
+   *
+   * Where each range can be any of:
+   *
+   * - A number
+   * - A string for getting/setting an object property
+   * - An instance of `Range`
+   * - A one-dimensional Array or a Matrix with numbers
+   *
+   * Indexes must be zero-based, integer numbers.
+   *
+   * Examples:
+   *
+   *    const b = [1, 2, 3, 4, 5]
+   *    math.subset(b, math.index([1, 2, 3]))     // returns [2, 3, 4]
+   *
+   *    const a = math.matrix([[1, 2], [3, 4]])
+   *    a.subset(math.index(0, 1))             // returns 2
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, matrix, number, string, unit
+   *
+   * @param {...*} ranges   Zero or more ranges or numbers.
+   * @return {Index}        Returns the created index
+   */
+  return typed(name, {
+    '...number | string | BigNumber | Range | Array | Matrix': function numberStringBigNumberRangeArrayMatrix(args) {
+      var ranges = args.map(function (arg) {
+        if (isBigNumber(arg)) {
+          return arg.toNumber(); // convert BigNumber to Number
+        } else if (Array.isArray(arg) || isMatrix(arg)) {
+          return arg.map(function (elem) {
+            // convert BigNumber to Number
+            return isBigNumber(elem) ? elem.toNumber() : elem;
+          });
+        } else {
+          return arg;
+        }
+      });
+      var res = new Index();
+      Index.apply(res, ranges);
+      return res;
+    }
+  });
+});

package/lib/esm/type/matrix/function/matrix.js

@@ -0,0 +1,82 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'matrix';
+var dependencies = ['typed', 'Matrix', 'DenseMatrix', 'SparseMatrix'];
+export var createMatrix = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Matrix,
+    DenseMatrix,
+    SparseMatrix
+  } = _ref;
+  /**
+   * Create a Matrix. The function creates a new `math.Matrix` object from
+   * an `Array`. A Matrix has utility functions to manipulate the data in the
+   * matrix, like getting the size and getting or setting values in the matrix.
+   * Supported storage formats are 'dense' and 'sparse'.
+   *
+   * Syntax:
+   *
+   *    math.matrix()                         // creates an empty matrix using default storage format (dense).
+   *    math.matrix(data)                     // creates a matrix with initial data using default storage format (dense).
+   *    math.matrix('dense')                  // creates an empty matrix using the given storage format.
+   *    math.matrix(data, 'dense')            // creates a matrix with initial data using the given storage format.
+   *    math.matrix(data, 'sparse')           // creates a sparse matrix with initial data.
+   *    math.matrix(data, 'sparse', 'number') // creates a sparse matrix with initial data, number data type.
+   *
+   * Examples:
+   *
+   *    let m = math.matrix([[1, 2], [3, 4]])
+   *    m.size()                        // Array [2, 2]
+   *    m.resize([3, 2], 5)
+   *    m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
+   *    m.get([1, 0])                    // number 3
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, number, string, unit, sparse
+   *
+   * @param {Array | Matrix} [data]    A multi dimensional array
+   * @param {string} [format]          The Matrix storage format, either `'dense'` or `'sparse'`
+   * @param {string} [datatype]        Type of the values
+   *
+   * @return {Matrix} The created matrix
+   */
+  return typed(name, {
+    '': function _() {
+      return _create([]);
+    },
+    string: function string(format) {
+      return _create([], format);
+    },
+    'string, string': function stringString(format, datatype) {
+      return _create([], format, datatype);
+    },
+    Array: function Array(data) {
+      return _create(data);
+    },
+    Matrix: function Matrix(data) {
+      return _create(data, data.storage());
+    },
+    'Array | Matrix, string': _create,
+    'Array | Matrix, string, string': _create
+  });
+
+  /**
+   * Create a new Matrix with given storage format
+   * @param {Array} data
+   * @param {string} [format]
+   * @param {string} [datatype]
+   * @returns {Matrix} Returns a new Matrix
+   * @private
+   */
+  function _create(data, format, datatype) {
+    // get storage format constructor
+    if (format === 'dense' || format === 'default' || format === undefined) {
+      return new DenseMatrix(data, datatype);
+    }
+    if (format === 'sparse') {
+      return new SparseMatrix(data, datatype);
+    }
+    throw new TypeError('Unknown matrix type ' + JSON.stringify(format) + '.');
+  }
+});

package/lib/esm/type/matrix/function/sparse.js

@@ -0,0 +1,56 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'sparse';
+var dependencies = ['typed', 'SparseMatrix'];
+export var createSparse = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    SparseMatrix
+  } = _ref;
+  /**
+   * Create a Sparse Matrix. The function creates a new `math.Matrix` object from
+   * an `Array`. A Matrix has utility functions to manipulate the data in the
+   * matrix, like getting the size and getting or setting values in the matrix.
+   * Note that a Sparse Matrix is always 2-dimensional, so for example if
+   * you create one from a plain array of _n_ numbers, you get an _n_ by 1
+   * Sparse "column vector".
+   *
+   * Syntax:
+   *
+   *    math.sparse()               // creates an empty sparse matrix.
+   *    math.sparse(data)           // creates a sparse matrix with initial data.
+   *    math.sparse(data, 'number') // creates a sparse matrix with initial data, number datatype.
+   *
+   * Examples:
+   *
+   *    let m = math.sparse([[1, 2], [3, 4]])
+   *    m.size()                        // Array [2, 2]
+   *    m.resize([3, 2], 5)
+   *    m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
+   *    m.get([1, 0])                    // number 3
+   *    let v = math.sparse([0, 0, 1])
+   *    v.size()                        // Array [3, 1]
+   *    v.get([2, 0])                   // number 1
+   *
+   * See also:
+   *
+   *    bignumber, boolean, complex, index, number, string, unit, matrix
+   *
+   * @param {Array | Matrix} [data]    A two dimensional array
+   *
+   * @return {Matrix} The created matrix
+   */
+  return typed(name, {
+    '': function _() {
+      return new SparseMatrix([]);
+    },
+    string: function string(datatype) {
+      return new SparseMatrix([], datatype);
+    },
+    'Array | Matrix': function ArrayMatrix(data) {
+      return new SparseMatrix(data);
+    },
+    'Array | Matrix, string': function ArrayMatrixString(data, datatype) {
+      return new SparseMatrix(data, datatype);
+    }
+  });
+});

package/lib/esm/type/matrix/utils/broadcast.js

@@ -0,0 +1,75 @@
+import { factory } from '../../../utils/factory.js';
+var name = 'broadcast';
+var dependancies = ['concat'];
+export var createBroadcast = /* #__PURE__ */factory(name, dependancies, _ref => {
+  var {
+    concat
+  } = _ref;
+  /**
+  * Broadcasts two matrices, and return both in an array
+  * It checks if it's possible with broadcasting rules
+  *
+  * @param {Matrix}   A      First Matrix
+  * @param {Matrix}   B      Second Matrix
+  *
+  * @return {Matrix[]}      [ broadcastedA, broadcastedB ]
+  */
+  return function (A, B) {
+    var N = Math.max(A._size.length, B._size.length); // max number of dims
+    if (A._size.length === B._size.length) {
+      if (A._size.every((dim, i) => dim === B._size[i])) {
+        // If matrices have the same size return them
+        return [A, B];
+      }
+    }
+    var sizeA = _padLeft(A._size, N, 0); // pad to the left to align dimensions to the right
+    var sizeB = _padLeft(B._size, N, 0); // pad to the left to align dimensions to the right
+
+    // calculate the max dimensions
+    var sizeMax = [];
+    for (var dim = 0; dim < N; dim++) {
+      sizeMax[dim] = Math.max(sizeA[dim], sizeB[dim]);
+    }
+
+    // check if the broadcasting rules applyes for both matrices
+    for (var _dim = 0; _dim < N; _dim++) {
+      _checkRules(sizeA, sizeMax, _dim);
+      _checkRules(sizeB, sizeMax, _dim);
+    }
+
+    // reshape A or B if needed to make them ready for concat
+    var AA = A.clone();
+    var BB = B.clone();
+    if (AA._size.length < N) {
+      AA.reshape(_padLeft(AA._size, N, 1));
+    } else if (BB._size.length < N) {
+      BB.reshape(_padLeft(BB._size, N, 1));
+    }
+
+    // stretches the matrices on each dimension to make them the same size
+    for (var _dim2 = 0; _dim2 < N; _dim2++) {
+      if (AA._size[_dim2] < sizeMax[_dim2]) {
+        AA = _stretch(AA, sizeMax[_dim2], _dim2);
+      }
+      if (BB._size[_dim2] < sizeMax[_dim2]) {
+        BB = _stretch(BB, sizeMax[_dim2], _dim2);
+      }
+    }
+
+    // return the array with the two broadcasted matrices
+    return [AA, BB];
+  };
+  function _padLeft(shape, N, filler) {
+    // pads an array of dimensions with numbers to the left, unitl the number of dimensions is N
+    return [...Array(N - shape.length).fill(filler), ...shape];
+  }
+  function _stretch(arrayToStretch, sizeToStretch, dimToStretch) {
+    // stretches a matrix up to a certain size in a certain dimension
+    return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
+  }
+  function _checkRules(shape, sizeMax, dim) {
+    if (shape[dim] < sizeMax[dim] & shape[dim] > 1) {
+      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(shape, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(shape[dim], " to size ").concat(sizeMax[dim]));
+    }
+  }
+});

package/lib/esm/type/matrix/utils/matAlgo01xDSid.js

@@ -0,0 +1,112 @@
+import { factory } from '../../../utils/factory.js';
+import { DimensionError } from '../../../error/DimensionError.js';
+var name = 'matAlgo01xDSid';
+var dependencies = ['typed'];
+export var createMatAlgo01xDSid = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Iterates over SparseMatrix nonzero items and invokes the callback function f(Dij, Sij).
+   * Callback function invoked NNZ times (number of nonzero items in SparseMatrix).
+   *
+   *
+   *          ┌  f(Dij, Sij)  ; S(i,j) !== 0
+   * C(i,j) = ┤
+   *          └  Dij          ; otherwise
+   *
+   *
+   * @param {Matrix}   denseMatrix       The DenseMatrix instance (D)
+   * @param {Matrix}   sparseMatrix      The SparseMatrix instance (S)
+   * @param {Function} callback          The f(Dij,Sij) operation to invoke, where Dij = DenseMatrix(i,j) and Sij = SparseMatrix(i,j)
+   * @param {boolean}  inverse           A true value indicates callback should be invoked f(Sij,Dij)
+   *
+   * @return {Matrix}                    DenseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
+   */
+  return function algorithm1(denseMatrix, sparseMatrix, callback, inverse) {
+    // dense matrix arrays
+    var adata = denseMatrix._data;
+    var asize = denseMatrix._size;
+    var adt = denseMatrix._datatype;
+    // sparse matrix arrays
+    var bvalues = sparseMatrix._values;
+    var bindex = sparseMatrix._index;
+    var bptr = sparseMatrix._ptr;
+    var bsize = sparseMatrix._size;
+    var bdt = sparseMatrix._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new 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 + ')');
+    }
+
+    // sparse matrix cannot be a Pattern matrix
+    if (!bvalues) {
+      throw new Error('Cannot perform operation on Dense Matrix and Pattern Sparse Matrix');
+    }
+
+    // rows & columns
+    var rows = asize[0];
+    var columns = asize[1];
+
+    // process data types
+    var dt = typeof adt === 'string' && adt === bdt ? adt : undefined;
+    // callback function
+    var cf = dt ? typed.find(callback, [dt, dt]) : callback;
+
+    // vars
+    var i, j;
+
+    // result (DenseMatrix)
+    var cdata = [];
+    // initialize c
+    for (i = 0; i < rows; i++) {
+      cdata[i] = [];
+    }
+
+    // workspace
+    var x = [];
+    // marks indicating we have a value in x for a given column
+    var w = [];
+
+    // loop columns in b
+    for (j = 0; j < columns; j++) {
+      // column mark
+      var mark = j + 1;
+      // values in column j
+      for (var k0 = bptr[j], k1 = bptr[j + 1], k = k0; k < k1; k++) {
+        // row
+        i = bindex[k];
+        // update workspace
+        x[i] = inverse ? cf(bvalues[k], adata[i][j]) : cf(adata[i][j], bvalues[k]);
+        // mark i as updated
+        w[i] = mark;
+      }
+      // loop rows
+      for (i = 0; i < rows; i++) {
+        // check row is in workspace
+        if (w[i] === mark) {
+          // c[i][j] was already calculated
+          cdata[i][j] = x[i];
+        } else {
+          // item does not exist in S
+          cdata[i][j] = adata[i][j];
+        }
+      }
+    }
+
+    // return dense matrix
+    return denseMatrix.createDenseMatrix({
+      data: cdata,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});

package/lib/esm/type/matrix/utils/matAlgo02xDS0.js

@@ -0,0 +1,116 @@
+import { factory } from '../../../utils/factory.js';
+import { DimensionError } from '../../../error/DimensionError.js';
+var name = 'matAlgo02xDS0';
+var dependencies = ['typed', 'equalScalar'];
+export var createMatAlgo02xDS0 = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    equalScalar
+  } = _ref;
+  /**
+   * Iterates over SparseMatrix nonzero items and invokes the callback function f(Dij, Sij).
+   * Callback function invoked NNZ times (number of nonzero items in SparseMatrix).
+   *
+   *
+   *          ┌  f(Dij, Sij)  ; S(i,j) !== 0
+   * C(i,j) = ┤
+   *          └  0            ; otherwise
+   *
+   *
+   * @param {Matrix}   denseMatrix       The DenseMatrix instance (D)
+   * @param {Matrix}   sparseMatrix      The SparseMatrix instance (S)
+   * @param {Function} callback          The f(Dij,Sij) operation to invoke, where Dij = DenseMatrix(i,j) and Sij = SparseMatrix(i,j)
+   * @param {boolean}  inverse           A true value indicates callback should be invoked f(Sij,Dij)
+   *
+   * @return {Matrix}                    SparseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
+   */
+  return function matAlgo02xDS0(denseMatrix, sparseMatrix, callback, inverse) {
+    // dense matrix arrays
+    var adata = denseMatrix._data;
+    var asize = denseMatrix._size;
+    var adt = denseMatrix._datatype;
+    // sparse matrix arrays
+    var bvalues = sparseMatrix._values;
+    var bindex = sparseMatrix._index;
+    var bptr = sparseMatrix._ptr;
+    var bsize = sparseMatrix._size;
+    var bdt = sparseMatrix._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new 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 + ')');
+    }
+
+    // sparse matrix cannot be a Pattern matrix
+    if (!bvalues) {
+      throw new Error('Cannot perform operation on Dense Matrix and Pattern Sparse Matrix');
+    }
+
+    // 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 (SparseMatrix)
+    var cvalues = [];
+    var cindex = [];
+    var cptr = [];
+
+    // loop columns in b
+    for (var j = 0; j < columns; j++) {
+      // update cptr
+      cptr[j] = cindex.length;
+      // values in column j
+      for (var k0 = bptr[j], k1 = bptr[j + 1], k = k0; k < k1; k++) {
+        // row
+        var i = bindex[k];
+        // update C(i,j)
+        var cij = inverse ? cf(bvalues[k], adata[i][j]) : cf(adata[i][j], bvalues[k]);
+        // check for nonzero
+        if (!eq(cij, zero)) {
+          // push i & v
+          cindex.push(i);
+          cvalues.push(cij);
+        }
+      }
+    }
+    // update cptr
+    cptr[columns] = cindex.length;
+
+    // return sparse matrix
+    return sparseMatrix.createSparseMatrix({
+      values: cvalues,
+      index: cindex,
+      ptr: cptr,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});

package/lib/esm/type/matrix/utils/matAlgo03xDSf.js

@@ -0,0 +1,122 @@
+import { factory } from '../../../utils/factory.js';
+import { DimensionError } from '../../../error/DimensionError.js';
+var name = 'matAlgo03xDSf';
+var dependencies = ['typed'];
+export var createMatAlgo03xDSf = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Iterates over SparseMatrix items and invokes the callback function f(Dij, Sij).
+   * Callback function invoked M*N times.
+   *
+   *
+   *          ┌  f(Dij, Sij)  ; S(i,j) !== 0
+   * C(i,j) = ┤
+   *          └  f(Dij, 0)    ; otherwise
+   *
+   *
+   * @param {Matrix}   denseMatrix       The DenseMatrix instance (D)
+   * @param {Matrix}   sparseMatrix      The SparseMatrix instance (C)
+   * @param {Function} callback          The f(Dij,Sij) operation to invoke, where Dij = DenseMatrix(i,j) and Sij = SparseMatrix(i,j)
+   * @param {boolean}  inverse           A true value indicates callback should be invoked f(Sij,Dij)
+   *
+   * @return {Matrix}                    DenseMatrix (C)
+   *
+   * see https://github.com/josdejong/mathjs/pull/346#issuecomment-97477571
+   */
+  return function matAlgo03xDSf(denseMatrix, sparseMatrix, callback, inverse) {
+    // dense matrix arrays
+    var adata = denseMatrix._data;
+    var asize = denseMatrix._size;
+    var adt = denseMatrix._datatype;
+    // sparse matrix arrays
+    var bvalues = sparseMatrix._values;
+    var bindex = sparseMatrix._index;
+    var bptr = sparseMatrix._ptr;
+    var bsize = sparseMatrix._size;
+    var bdt = sparseMatrix._datatype;
+
+    // validate dimensions
+    if (asize.length !== bsize.length) {
+      throw new 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 + ')');
+    }
+
+    // sparse matrix cannot be a Pattern matrix
+    if (!bvalues) {
+      throw new Error('Cannot perform operation on Dense Matrix and Pattern Sparse Matrix');
+    }
+
+    // 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]);
+    }
+
+    // result (DenseMatrix)
+    var cdata = [];
+
+    // initialize dense matrix
+    for (var z = 0; z < rows; z++) {
+      // initialize row
+      cdata[z] = [];
+    }
+
+    // workspace
+    var x = [];
+    // marks indicating we have a value in x for a given column
+    var w = [];
+
+    // loop columns in b
+    for (var j = 0; j < columns; j++) {
+      // column mark
+      var mark = j + 1;
+      // values in column j
+      for (var k0 = bptr[j], k1 = bptr[j + 1], k = k0; k < k1; k++) {
+        // row
+        var i = bindex[k];
+        // update workspace
+        x[i] = inverse ? cf(bvalues[k], adata[i][j]) : cf(adata[i][j], bvalues[k]);
+        w[i] = mark;
+      }
+      // process workspace
+      for (var y = 0; y < rows; y++) {
+        // check we have a calculated value for current row
+        if (w[y] === mark) {
+          // use calculated value
+          cdata[y][j] = x[y];
+        } else {
+          // calculate value
+          cdata[y][j] = inverse ? cf(zero, adata[y][j]) : cf(adata[y][j], zero);
+        }
+      }
+    }
+
+    // return dense matrix
+    return denseMatrix.createDenseMatrix({
+      data: cdata,
+      size: [rows, columns],
+      datatype: dt
+    });
+  };
+});