@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/function/matrix/apply.js

@@ -0,0 +1,125 @@
+import { factory } from '../../utils/factory.js';
+import { arraySize } from '../../utils/array.js';
+import { isMatrix } from '../../utils/is.js';
+import { IndexError } from '../../error/IndexError.js';
+var name = 'apply';
+var dependencies = ['typed', 'isInteger'];
+export var createApply = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isInteger
+  } = _ref;
+
+  /**
+   * Apply a function that maps an array to a scalar
+   * along a given axis of a matrix or array.
+   * Returns a new matrix or array with one less dimension than the input.
+   *
+   * Syntax:
+   *
+   *     math.apply(A, dim, callback)
+   *
+   * Where:
+   *
+   * - `dim: number` is a zero-based dimension over which to concatenate the matrices.
+   *
+   * Examples:
+   *
+   *    const A = [[1, 2], [3, 4]]
+   *    const sum = math.sum
+   *
+   *    math.apply(A, 0, sum)             // returns [4, 6]
+   *    math.apply(A, 1, sum)             // returns [3, 7]
+   *
+   * See also:
+   *
+   *    map, filter, forEach
+   *
+   * @param {Array | Matrix} array   The input Matrix
+   * @param {number} dim             The dimension along which the callback is applied
+   * @param {Function} callback      The callback function that is applied. This Function
+   *                                 should take an array or 1-d matrix as an input and
+   *                                 return a number.
+   * @return {Array | Matrix} res    The residual matrix with the function applied over some dimension.
+   */
+  return typed(name, {
+    'Array | Matrix, number | BigNumber, function': function ArrayMatrixNumberBigNumberFunction(mat, dim, callback) {
+      if (!isInteger(dim)) {
+        throw new TypeError('Integer number expected for dimension');
+      }
+
+      var size = Array.isArray(mat) ? arraySize(mat) : mat.size();
+
+      if (dim < 0 || dim >= size.length) {
+        throw new IndexError(dim, size.length);
+      }
+
+      if (isMatrix(mat)) {
+        return mat.create(_apply(mat.valueOf(), dim, callback));
+      } else {
+        return _apply(mat, dim, callback);
+      }
+    }
+  });
+});
+/**
+ * Recursively reduce a matrix
+ * @param {Array} mat
+ * @param {number} dim
+ * @param {Function} callback
+ * @returns {Array} ret
+ * @private
+ */
+
+function _apply(mat, dim, callback) {
+  var i, ret, tran;
+
+  if (dim <= 0) {
+    if (!Array.isArray(mat[0])) {
+      return callback(mat);
+    } else {
+      tran = _switch(mat);
+      ret = [];
+
+      for (i = 0; i < tran.length; i++) {
+        ret[i] = _apply(tran[i], dim - 1, callback);
+      }
+
+      return ret;
+    }
+  } else {
+    ret = [];
+
+    for (i = 0; i < mat.length; i++) {
+      ret[i] = _apply(mat[i], dim - 1, callback);
+    }
+
+    return ret;
+  }
+}
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+
+
+function _switch(mat) {
+  var I = mat.length;
+  var J = mat[0].length;
+  var i, j;
+  var ret = [];
+
+  for (j = 0; j < J; j++) {
+    var tmp = [];
+
+    for (i = 0; i < I; i++) {
+      tmp.push(mat[i][j]);
+    }
+
+    ret.push(tmp);
+  }
+
+  return ret;
+}

package/dist/node_modules/mathjs/lib/esm/function/matrix/column.js

@@ -0,0 +1,59 @@
+import { factory } from '../../utils/factory.js';
+import { clone } from '../../utils/object.js';
+import { validateIndex } from '../../utils/array.js';
+var name = 'column';
+var dependencies = ['typed', 'Index', 'matrix', 'range'];
+export var createColumn = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
+
+  /**
+   * Return a column from a Matrix.
+   *
+   * Syntax:
+   *
+   *     math.column(value, index)
+   *
+   * Example:
+   *
+   *     // get a column
+   *     const d = [[1, 2], [3, 4]]
+   *     math.column(d, 1) // returns [[2], [4]]
+   *
+   * See also:
+   *
+   *     row
+   *
+   * @param {Array | Matrix } value   An array or matrix
+   * @param {number} column           The index of the column
+   * @return {Array | Matrix}         The retrieved column
+   */
+  return typed(name, {
+    'Matrix, number': _column,
+    'Array, number': function ArrayNumber(value, column) {
+      return _column(matrix(clone(value)), column).valueOf();
+    }
+  });
+  /**
+   * Retrieve a column of a matrix
+   * @param {Matrix } value  A matrix
+   * @param {number} column  The index of the column
+   * @return {Matrix}        The retrieved column
+   */
+
+  function _column(value, column) {
+    // check dimensions
+    if (value.size().length !== 2) {
+      throw new Error('Only two dimensional matrix is supported');
+    }
+
+    validateIndex(column, value.size()[1]);
+    var rowRange = range(0, value.size()[0]);
+    var index = new Index(rowRange, column);
+    return value.subset(index);
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/matrix/concat.js

@@ -0,0 +1,140 @@
+import { isBigNumber, isMatrix, isNumber } from '../../utils/is.js';
+import { clone } from '../../utils/object.js';
+import { arraySize } from '../../utils/array.js';
+import { IndexError } from '../../error/IndexError.js';
+import { DimensionError } from '../../error/DimensionError.js';
+import { factory } from '../../utils/factory.js';
+var name = 'concat';
+var dependencies = ['typed', 'matrix', 'isInteger'];
+export var createConcat = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    isInteger
+  } = _ref;
+
+  /**
+   * Concatenate two or more matrices.
+   *
+   * Syntax:
+   *
+   *     math.concat(A, B, C, ...)
+   *     math.concat(A, B, C, ..., dim)
+   *
+   * Where:
+   *
+   * - `dim: number` is a zero-based dimension over which to concatenate the matrices.
+   *   By default the last dimension of the matrices.
+   *
+   * Examples:
+   *
+   *    const A = [[1, 2], [5, 6]]
+   *    const B = [[3, 4], [7, 8]]
+   *
+   *    math.concat(A, B)                  // returns [[1, 2, 3, 4], [5, 6, 7, 8]]
+   *    math.concat(A, B, 0)               // returns [[1, 2], [5, 6], [3, 4], [7, 8]]
+   *    math.concat('hello', ' ', 'world') // returns 'hello world'
+   *
+   * See also:
+   *
+   *    size, squeeze, subset, transpose
+   *
+   * @param {... Array | Matrix} args     Two or more matrices
+   * @return {Array | Matrix} Concatenated matrix
+   */
+  return typed(name, {
+    // TODO: change signature to '...Array | Matrix, dim?' when supported
+    '...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumber(args) {
+      var i;
+      var len = args.length;
+      var dim = -1; // zero-based dimension
+
+      var prevDim;
+      var asMatrix = false;
+      var matrices = []; // contains multi dimensional arrays
+
+      for (i = 0; i < len; i++) {
+        var arg = args[i]; // test whether we need to return a Matrix (if not we return an Array)
+
+        if (isMatrix(arg)) {
+          asMatrix = true;
+        }
+
+        if (isNumber(arg) || isBigNumber(arg)) {
+          if (i !== len - 1) {
+            throw new Error('Dimension must be specified as last argument');
+          } // last argument contains the dimension on which to concatenate
+
+
+          prevDim = dim;
+          dim = arg.valueOf(); // change BigNumber to number
+
+          if (!isInteger(dim)) {
+            throw new TypeError('Integer number expected for dimension');
+          }
+
+          if (dim < 0 || i > 0 && dim > prevDim) {
+            // TODO: would be more clear when throwing a DimensionError here
+            throw new IndexError(dim, prevDim + 1);
+          }
+        } else {
+          // this is a matrix or array
+          var m = clone(arg).valueOf();
+          var size = arraySize(m);
+          matrices[i] = m;
+          prevDim = dim;
+          dim = size.length - 1; // verify whether each of the matrices has the same number of dimensions
+
+          if (i > 0 && dim !== prevDim) {
+            throw new DimensionError(prevDim + 1, dim + 1);
+          }
+        }
+      }
+
+      if (matrices.length === 0) {
+        throw new SyntaxError('At least one matrix expected');
+      }
+
+      var res = matrices.shift();
+
+      while (matrices.length) {
+        res = _concat(res, matrices.shift(), dim, 0);
+      }
+
+      return asMatrix ? matrix(res) : res;
+    },
+    '...string': function string(args) {
+      return args.join('');
+    }
+  });
+});
+/**
+ * Recursively concatenate two matrices.
+ * The contents of the matrices is not cloned.
+ * @param {Array} a             Multi dimensional array
+ * @param {Array} b             Multi dimensional array
+ * @param {number} concatDim    The dimension on which to concatenate (zero-based)
+ * @param {number} dim          The current dim (zero-based)
+ * @return {Array} c            The concatenated matrix
+ * @private
+ */
+
+function _concat(a, b, concatDim, dim) {
+  if (dim < concatDim) {
+    // recurse into next dimension
+    if (a.length !== b.length) {
+      throw new DimensionError(a.length, b.length);
+    }
+
+    var c = [];
+
+    for (var i = 0; i < a.length; i++) {
+      c[i] = _concat(a[i], b[i], concatDim, dim + 1);
+    }
+
+    return c;
+  } else {
+    // concatenate this dimension
+    return a.concat(b);
+  }
+}

package/dist/node_modules/mathjs/lib/esm/function/matrix/count.js

@@ -0,0 +1,40 @@
+import { factory } from '../../utils/factory.js';
+var name = 'count';
+var dependencies = ['typed', 'size', 'prod'];
+export var createCount = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    size,
+    prod
+  } = _ref;
+
+  /**
+   * Count the number of elements of a matrix, array or string.
+   *
+   * Syntax:
+   *
+   *     math.count(x)
+   *
+   * Examples:
+   *
+   *     math.count('hello world')        // returns 11
+   *     const A = [[1, 2, 3], [4, 5, 6]]
+   *     math.count(A)                    // returns 6
+   *     math.count(math.range(1,6))      // returns 5
+   *
+   * See also:
+   *
+   *     size
+   *
+   * @param {string | Array | Matrix} x  A matrix or string
+   * @return {number} An integer with the elements in `x`.
+   */
+  return typed(name, {
+    string: function string(x) {
+      return x.length;
+    },
+    'Matrix | Array': function MatrixArray(x) {
+      return prod(size(x));
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/matrix/cross.js

@@ -0,0 +1,85 @@
+import { arraySize, squeeze } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'cross';
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply'];
+export var createCross = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    subtract,
+    multiply
+  } = _ref;
+
+  /**
+   * Calculate the cross product for two vectors in three dimensional space.
+   * The cross product of `A = [a1, a2, a3]` and `B = [b1, b2, b3]` is defined
+   * as:
+   *
+   *    cross(A, B) = [
+   *      a2 * b3 - a3 * b2,
+   *      a3 * b1 - a1 * b3,
+   *      a1 * b2 - a2 * b1
+   *    ]
+   *
+   * If one of the input vectors has a dimension greater than 1, the output
+   * vector will be a 1x3 (2-dimensional) matrix.
+   *
+   * Syntax:
+   *
+   *    math.cross(x, y)
+   *
+   * Examples:
+   *
+   *    math.cross([1, 1, 0],   [0, 1, 1])       // Returns [1, -1, 1]
+   *    math.cross([3, -3, 1],  [4, 9, 2])       // Returns [-15, -2, 39]
+   *    math.cross([2, 3, 4],   [5, 6, 7])       // Returns [-3, 6, -3]
+   *    math.cross([[1, 2, 3]], [[4], [5], [6]]) // Returns [[-3, 6, -3]]
+   *
+   * See also:
+   *
+   *    dot, multiply
+   *
+   * @param  {Array | Matrix} x   First vector
+   * @param  {Array | Matrix} y   Second vector
+   * @return {Array | Matrix}     Returns the cross product of `x` and `y`
+   */
+  return typed(name, {
+    'Matrix, Matrix': function MatrixMatrix(x, y) {
+      return matrix(_cross(x.toArray(), y.toArray()));
+    },
+    'Matrix, Array': function MatrixArray(x, y) {
+      return matrix(_cross(x.toArray(), y));
+    },
+    'Array, Matrix': function ArrayMatrix(x, y) {
+      return matrix(_cross(x, y.toArray()));
+    },
+    'Array, Array': _cross
+  });
+  /**
+   * Calculate the cross product for two arrays
+   * @param {Array} x  First vector
+   * @param {Array} y  Second vector
+   * @returns {Array} Returns the cross product of x and y
+   * @private
+   */
+
+  function _cross(x, y) {
+    var highestDimension = Math.max(arraySize(x).length, arraySize(y).length);
+    x = squeeze(x);
+    y = squeeze(y);
+    var xSize = arraySize(x);
+    var ySize = arraySize(y);
+
+    if (xSize.length !== 1 || ySize.length !== 1 || xSize[0] !== 3 || ySize[0] !== 3) {
+      throw new RangeError('Vectors with length 3 expected ' + '(Size A = [' + xSize.join(', ') + '], B = [' + ySize.join(', ') + '])');
+    }
+
+    var product = [subtract(multiply(x[1], y[2]), multiply(x[2], y[1])), subtract(multiply(x[2], y[0]), multiply(x[0], y[2])), subtract(multiply(x[0], y[1]), multiply(x[1], y[0]))];
+
+    if (highestDimension > 1) {
+      return [product];
+    } else {
+      return product;
+    }
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/matrix/ctranspose.js

@@ -0,0 +1,38 @@
+import { factory } from '../../utils/factory.js';
+var name = 'ctranspose';
+var dependencies = ['typed', 'transpose', 'conj'];
+export var createCtranspose = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    transpose,
+    conj
+  } = _ref;
+
+  /**
+   * Transpose and complex conjugate a matrix. All values of the matrix are
+   * reflected over its main diagonal and then the complex conjugate is
+   * taken. This is equivalent to complex conjugation for scalars and
+   * vectors.
+   *
+   * Syntax:
+   *
+   *     math.ctranspose(x)
+   *
+   * Examples:
+   *
+   *     const A = [[1, 2, 3], [4, 5, math.complex(6,7)]]
+   *     math.ctranspose(A)               // returns [[1, 4], [2, 5], [3, {re:6,im:7}]]
+   *
+   * See also:
+   *
+   *     transpose, diag, inv, subset, squeeze
+   *
+   * @param {Array | Matrix} x  Matrix to be ctransposed
+   * @return {Array | Matrix}   The ctransposed matrix
+   */
+  return typed(name, {
+    any: function any(x) {
+      return conj(transpose(x));
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/matrix/det.js

@@ -0,0 +1,151 @@
+import { isMatrix } from '../../utils/is.js';
+import { clone } from '../../utils/object.js';
+import { format } from '../../utils/string.js';
+import { factory } from '../../utils/factory.js';
+var name = 'det';
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
+export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    subtract,
+    multiply,
+    divideScalar,
+    isZero,
+    unaryMinus
+  } = _ref;
+
+  /**
+   * Calculate the determinant of a matrix.
+   *
+   * Syntax:
+   *
+   *    math.det(x)
+   *
+   * Examples:
+   *
+   *    math.det([[1, 2], [3, 4]]) // returns -2
+   *
+   *    const A = [
+   *      [-2, 2, 3],
+   *      [-1, 1, 3],
+   *      [2, 0, -1]
+   *    ]
+   *    math.det(A) // returns 6
+   *
+   * See also:
+   *
+   *    inv
+   *
+   * @param {Array | Matrix} x  A matrix
+   * @return {number} The determinant of `x`
+   */
+  return typed(name, {
+    any: function any(x) {
+      return clone(x);
+    },
+    'Array | Matrix': function det(x) {
+      var size;
+
+      if (isMatrix(x)) {
+        size = x.size();
+      } else if (Array.isArray(x)) {
+        x = matrix(x);
+        size = x.size();
+      } else {
+        // a scalar
+        size = [];
+      }
+
+      switch (size.length) {
+        case 0:
+          // scalar
+          return clone(x);
+
+        case 1:
+          // vector
+          if (size[0] === 1) {
+            return clone(x.valueOf()[0]);
+          } else {
+            throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
+          }
+
+        case 2:
+          {
+            // two dimensional array
+            var rows = size[0];
+            var cols = size[1];
+
+            if (rows === cols) {
+              return _det(x.clone().valueOf(), rows, cols);
+            } else {
+              throw new RangeError('Matrix must be square ' + '(size: ' + format(size) + ')');
+            }
+          }
+
+        default:
+          // multi dimensional array
+          throw new RangeError('Matrix must be two dimensional ' + '(size: ' + format(size) + ')');
+      }
+    }
+  });
+  /**
+   * Calculate the determinant of a matrix
+   * @param {Array[]} matrix  A square, two dimensional matrix
+   * @param {number} rows     Number of rows of the matrix (zero-based)
+   * @param {number} cols     Number of columns of the matrix (zero-based)
+   * @returns {number} det
+   * @private
+   */
+
+  function _det(matrix, rows, cols) {
+    if (rows === 1) {
+      // this is a 1 x 1 matrix
+      return clone(matrix[0][0]);
+    } else if (rows === 2) {
+      // this is a 2 x 2 matrix
+      // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
+      return subtract(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
+    } else {
+      // Bareiss algorithm
+      // this algorithm have same complexity as LUP decomposition (O(n^3))
+      // but it preserve precision of floating point more relative to the LUP decomposition
+      var negated = false;
+      var rowIndices = new Array(rows).fill(0).map((_, i) => i); // matrix index of row i
+
+      for (var k = 0; k < rows; k++) {
+        var k_ = rowIndices[k];
+
+        if (isZero(matrix[k_][k])) {
+          var _k = void 0;
+
+          for (_k = k + 1; _k < rows; _k++) {
+            if (!isZero(matrix[rowIndices[_k]][k])) {
+              k_ = rowIndices[_k];
+              rowIndices[_k] = rowIndices[k];
+              rowIndices[k] = k_;
+              negated = !negated;
+              break;
+            }
+          }
+
+          if (_k === rows) return matrix[k_][k]; // some zero of the type
+        }
+
+        var piv = matrix[k_][k];
+        var piv_ = k === 0 ? 1 : matrix[rowIndices[k - 1]][k - 1];
+
+        for (var i = k + 1; i < rows; i++) {
+          var i_ = rowIndices[i];
+
+          for (var j = k + 1; j < rows; j++) {
+            matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
+          }
+        }
+      }
+
+      var det = matrix[rowIndices[rows - 1]][rows - 1];
+      return negated ? unaryMinus(det) : det;
+    }
+  }
+});