@tachybase/plugin-evaluator-mathjs 1.3.20

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

@@ -0,0 +1,131 @@
+import { isBigNumber } from '../../utils/is.js';
+import { isInteger } from '../../utils/number.js';
+import { resize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+var name = 'ones';
+var dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
+export var createOnes = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    matrix,
+    BigNumber
+  } = _ref;
+
+  /**
+   * Create a matrix filled with ones. The created matrix can have one or
+   * multiple dimensions.
+   *
+   * Syntax:
+   *
+   *    math.ones(m)
+   *    math.ones(m, format)
+   *    math.ones(m, n)
+   *    math.ones(m, n, format)
+   *    math.ones([m, n])
+   *    math.ones([m, n], format)
+   *    math.ones([m, n, p, ...])
+   *    math.ones([m, n, p, ...], format)
+   *
+   * Examples:
+   *
+   *    math.ones(3)                   // returns [1, 1, 1]
+   *    math.ones(3, 2)                // returns [[1, 1], [1, 1], [1, 1]]
+   *    math.ones(3, 2, 'dense')       // returns Dense Matrix [[1, 1], [1, 1], [1, 1]]
+   *
+   *    const A = [[1, 2, 3], [4, 5, 6]]
+   *    math.ones(math.size(A))       // returns [[1, 1, 1], [1, 1, 1]]
+   *
+   * See also:
+   *
+   *    zeros, identity, size, range
+   *
+   * @param {...number | Array} size    The size of each dimension of the matrix
+   * @param {string} [format]           The Matrix storage format
+   *
+   * @return {Array | Matrix | number}  A matrix filled with ones
+   */
+  return typed('ones', {
+    '': function _() {
+      return config.matrix === 'Array' ? _ones([]) : _ones([], 'default');
+    },
+    // math.ones(m, n, p, ..., format)
+    // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
+    '...number | BigNumber | string': function numberBigNumberString(size) {
+      var last = size[size.length - 1];
+
+      if (typeof last === 'string') {
+        var format = size.pop();
+        return _ones(size, format);
+      } else if (config.matrix === 'Array') {
+        return _ones(size);
+      } else {
+        return _ones(size, 'default');
+      }
+    },
+    Array: _ones,
+    Matrix: function Matrix(size) {
+      var format = size.storage();
+      return _ones(size.valueOf(), format);
+    },
+    'Array | Matrix, string': function ArrayMatrixString(size, format) {
+      return _ones(size.valueOf(), format);
+    }
+  });
+  /**
+   * Create an Array or Matrix with ones
+   * @param {Array} size
+   * @param {string} [format='default']
+   * @return {Array | Matrix}
+   * @private
+   */
+
+  function _ones(size, format) {
+    var hasBigNumbers = _normalize(size);
+
+    var defaultValue = hasBigNumbers ? new BigNumber(1) : 1;
+
+    _validate(size);
+
+    if (format) {
+      // return a matrix
+      var m = matrix(format);
+
+      if (size.length > 0) {
+        return m.resize(size, defaultValue);
+      }
+
+      return m;
+    } else {
+      // return an Array
+      var arr = [];
+
+      if (size.length > 0) {
+        return resize(arr, size, defaultValue);
+      }
+
+      return arr;
+    }
+  } // replace BigNumbers with numbers, returns true if size contained BigNumbers
+
+
+  function _normalize(size) {
+    var hasBigNumbers = false;
+    size.forEach(function (value, index, arr) {
+      if (isBigNumber(value)) {
+        hasBigNumbers = true;
+        arr[index] = value.toNumber();
+      }
+    });
+    return hasBigNumbers;
+  } // validate arguments
+
+
+  function _validate(size) {
+    size.forEach(function (value) {
+      if (typeof value !== 'number' || !isInteger(value) || value < 0) {
+        throw new Error('Parameters in function ones must be positive integers');
+      }
+    });
+  }
+});

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

@@ -0,0 +1,146 @@
+import { isMatrix } from '../../utils/is.js';
+import { isInteger } from '../../utils/number.js';
+import { factory } from '../../utils/factory.js';
+var name = 'partitionSelect';
+var dependencies = ['typed', 'isNumeric', 'isNaN', 'compare'];
+export var createPartitionSelect = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    isNumeric,
+    isNaN,
+    compare
+  } = _ref;
+  var asc = compare;
+
+  var desc = (a, b) => -compare(a, b);
+  /**
+   * Partition-based selection of an array or 1D matrix.
+   * Will find the kth smallest value, and mutates the input array.
+   * Uses Quickselect.
+   *
+   * Syntax:
+   *
+   *    math.partitionSelect(x, k)
+   *    math.partitionSelect(x, k, compare)
+   *
+   * Examples:
+   *
+   *    math.partitionSelect([5, 10, 1], 2)           // returns 10
+   *    math.partitionSelect(['C', 'B', 'A', 'D'], 1) // returns 'B'
+   *
+   *    function sortByLength (a, b) {
+   *      return a.length - b.length
+   *    }
+   *    math.partitionSelect(['Langdon', 'Tom', 'Sara'], 2, sortByLength) // returns 'Langdon'
+   *
+   * See also:
+   *
+   *    sort
+   *
+   * @param {Matrix | Array} x    A one dimensional matrix or array to sort
+   * @param {Number} k            The kth smallest value to be retrieved zero-based index
+   * @param {Function | 'asc' | 'desc'} [compare='asc']
+   *        An optional comparator function. The function is called as
+   *        `compare(a, b)`, and must return 1 when a > b, -1 when a < b,
+   *        and 0 when a == b.
+   * @return {*} Returns the kth lowest value.
+   */
+
+
+  return typed(name, {
+    'Array | Matrix, number': function ArrayMatrixNumber(x, k) {
+      return _partitionSelect(x, k, asc);
+    },
+    'Array | Matrix, number, string': function ArrayMatrixNumberString(x, k, compare) {
+      if (compare === 'asc') {
+        return _partitionSelect(x, k, asc);
+      } else if (compare === 'desc') {
+        return _partitionSelect(x, k, desc);
+      } else {
+        throw new Error('Compare string must be "asc" or "desc"');
+      }
+    },
+    'Array | Matrix, number, function': _partitionSelect
+  });
+
+  function _partitionSelect(x, k, compare) {
+    if (!isInteger(k) || k < 0) {
+      throw new Error('k must be a non-negative integer');
+    }
+
+    if (isMatrix(x)) {
+      var size = x.size();
+
+      if (size.length > 1) {
+        throw new Error('Only one dimensional matrices supported');
+      }
+
+      return quickSelect(x.valueOf(), k, compare);
+    }
+
+    if (Array.isArray(x)) {
+      return quickSelect(x, k, compare);
+    }
+  }
+  /**
+   * Quickselect algorithm.
+   * Code adapted from:
+   * https://blog.teamleadnet.com/2012/07/quick-select-algorithm-find-kth-element.html
+   *
+   * @param {Array} arr
+   * @param {Number} k
+   * @param {Function} compare
+   * @private
+   */
+
+
+  function quickSelect(arr, k, compare) {
+    if (k >= arr.length) {
+      throw new Error('k out of bounds');
+    } // check for NaN values since these can cause an infinite while loop
+
+
+    for (var i = 0; i < arr.length; i++) {
+      if (isNumeric(arr[i]) && isNaN(arr[i])) {
+        return arr[i]; // return NaN
+      }
+    }
+
+    var from = 0;
+    var to = arr.length - 1; // if from == to we reached the kth element
+
+    while (from < to) {
+      var r = from;
+      var w = to;
+      var pivot = arr[Math.floor(Math.random() * (to - from + 1)) + from]; // stop if the reader and writer meets
+
+      while (r < w) {
+        // arr[r] >= pivot
+        if (compare(arr[r], pivot) >= 0) {
+          // put the large values at the end
+          var tmp = arr[w];
+          arr[w] = arr[r];
+          arr[r] = tmp;
+          --w;
+        } else {
+          // the value is smaller than the pivot, skip
+          ++r;
+        }
+      } // if we stepped up (r++) we need to step one down (arr[r] > pivot)
+
+
+      if (compare(arr[r], pivot) > 0) {
+        --r;
+      } // the r pointer is on the end of the first k elements
+
+
+      if (k <= r) {
+        to = r;
+      } else {
+        from = r + 1;
+      }
+    }
+
+    return arr[k];
+  }
+});

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

@@ -0,0 +1,205 @@
+import { isMatrix } from '../../utils/is.js';
+import { arraySize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { format } from '../../utils/string.js';
+import { clone } from '../../utils/object.js';
+var name = 'pinv';
+var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+export var createPinv = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    inv,
+    deepEqual,
+    equal,
+    dotDivide,
+    dot,
+    ctranspose,
+    divideScalar,
+    multiply,
+    add,
+    Complex
+  } = _ref;
+
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix.
+   *
+   * Syntax:
+   *
+   *     math.pinv(x)
+   *
+   * Examples:
+   *
+   *     math.pinv([[1, 2], [3, 4]])          // returns [[-2, 1], [1.5, -0.5]]
+   *     math.pinv([[1, 0], [0, 1], [0, 1]])  // returns [[1, 0, 0], [0, 0.5, 0.5]]
+   *     math.pinv(4)                         // returns 0.25
+   *
+   * See also:
+   *
+   *     inv
+   *
+   * @param {number | Complex | Array | Matrix} x     Matrix to be inversed
+   * @return {number | Complex | Array | Matrix} The inverse of `x`.
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(x) {
+      var size = isMatrix(x) ? x.size() : arraySize(x);
+
+      switch (size.length) {
+        case 1:
+          // vector
+          if (_isZeros(x)) return ctranspose(x); // null vector
+
+          if (size[0] === 1) {
+            return inv(x); // invertible matrix
+          } else {
+            return dotDivide(ctranspose(x), dot(x, x));
+          }
+
+        case 2:
+          // two dimensional array
+          {
+            if (_isZeros(x)) return ctranspose(x); // zero matrixx
+
+            var rows = size[0];
+            var cols = size[1];
+
+            if (rows === cols) {
+              try {
+                return inv(x); // invertible matrix
+              } catch (err) {
+                if (err instanceof Error && err.message.match(/Cannot calculate inverse, determinant is zero/)) {// Expected
+                } else {
+                  throw err;
+                }
+              }
+            }
+
+            if (isMatrix(x)) {
+              return matrix(_pinv(x.valueOf(), rows, cols), x.storage());
+            } else {
+              // return an Array
+              return _pinv(x, rows, cols);
+            }
+          }
+
+        default:
+          // multi dimensional array
+          throw new RangeError('Matrix must be two dimensional ' + '(size: ' + format(size) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      if (equal(x, 0)) return clone(x); // zero
+
+      return divideScalar(1, x);
+    }
+  });
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]} pinv    Pseudoinverse matrix
+   * @private
+   */
+
+  function _pinv(mat, rows, cols) {
+    var {
+      C,
+      F
+    } = _rankFact(mat, rows, cols); // TODO: Use SVD instead (may improve precision)
+
+
+    var Cpinv = multiply(inv(multiply(ctranspose(C), C)), ctranspose(C));
+    var Fpinv = multiply(ctranspose(F), inv(multiply(F, ctranspose(F))));
+    return multiply(Fpinv, Cpinv);
+  }
+  /**
+   * Calculate the reduced row echelon form of a matrix
+   *
+   * Modified from https://rosettacode.org/wiki/Reduced_row_echelon_form
+   *
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]}        Reduced row echelon form
+   * @private
+   */
+
+
+  function _rref(mat, rows, cols) {
+    var M = clone(mat);
+    var lead = 0;
+
+    for (var r = 0; r < rows; r++) {
+      if (cols <= lead) {
+        return M;
+      }
+
+      var i = r;
+
+      while (_isZero(M[i][lead])) {
+        i++;
+
+        if (rows === i) {
+          i = r;
+          lead++;
+
+          if (cols === lead) {
+            return M;
+          }
+        }
+      }
+
+      [M[i], M[r]] = [M[r], M[i]];
+      var val = M[r][lead];
+
+      for (var j = 0; j < cols; j++) {
+        M[r][j] = dotDivide(M[r][j], val);
+      }
+
+      for (var _i = 0; _i < rows; _i++) {
+        if (_i === r) continue;
+        val = M[_i][lead];
+
+        for (var _j = 0; _j < cols; _j++) {
+          M[_i][_j] = add(M[_i][_j], multiply(-1, multiply(val, M[r][_j])));
+        }
+      }
+
+      lead++;
+    }
+
+    return M;
+  }
+  /**
+   * Calculate the rank factorization of a matrix
+   *
+   * @param {Array[]} mat                  A matrix (M)
+   * @param {number} rows                  Number of rows
+   * @param {number} cols                  Number of columns
+   * @return {{C: Array, F: Array}}        rank factorization where M = C F
+   * @private
+   */
+
+
+  function _rankFact(mat, rows, cols) {
+    var rref = _rref(mat, rows, cols);
+
+    var C = mat.map((_, i) => _.filter((_, j) => j < rows && !_isZero(dot(rref[j], rref[j]))));
+    var F = rref.filter((_, i) => !_isZero(dot(rref[i], rref[i])));
+    return {
+      C,
+      F
+    };
+  }
+
+  function _isZero(x) {
+    return equal(add(x, Complex(1, 1)), add(0, Complex(1, 1)));
+  }
+
+  function _isZeros(arr) {
+    return deepEqual(add(arr, Complex(1, 1)), add(multiply(arr, 0), Complex(1, 1)));
+  }
+});