@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/function/statistics/median.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMedian = void 0;
+
+var _collection = require("../../utils/collection.js");
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+
+var name = 'median';
+var dependencies = ['typed', 'add', 'divide', 'compare', 'partitionSelect'];
+var createMedian = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      add = _ref.add,
+      divide = _ref.divide,
+      compare = _ref.compare,
+      partitionSelect = _ref.partitionSelect;
+
+  /**
+   * Recursively calculate the median of an n-dimensional array
+   * @param {Array} array
+   * @return {Number} median
+   * @private
+   */
+  function _median(array) {
+    try {
+      array = (0, _array.flatten)(array.valueOf());
+      var num = array.length;
+
+      if (num === 0) {
+        throw new Error('Cannot calculate median of an empty array');
+      }
+
+      if (num % 2 === 0) {
+        // even: return the average of the two middle values
+        var mid = num / 2 - 1;
+        var right = partitionSelect(array, mid + 1); // array now partitioned at mid + 1, take max of left part
+
+        var left = array[mid];
+
+        for (var i = 0; i < mid; ++i) {
+          if (compare(array[i], left) > 0) {
+            left = array[i];
+          }
+        }
+
+        return middle2(left, right);
+      } else {
+        // odd: return the middle value
+        var m = partitionSelect(array, (num - 1) / 2);
+        return middle(m);
+      }
+    } catch (err) {
+      throw (0, _improveErrorMessage.improveErrorMessage)(err, 'median');
+    }
+  } // helper function to type check the middle value of the array
+
+
+  var middle = typed({
+    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(value) {
+      return value;
+    }
+  }); // helper function to type check the two middle value of the array
+
+  var middle2 = typed({
+    'number | BigNumber | Complex | Unit, number | BigNumber | Complex | Unit': function numberBigNumberComplexUnitNumberBigNumberComplexUnit(left, right) {
+      return divide(add(left, right), 2);
+    }
+  });
+  /**
+   * Compute the median of a matrix or a list with values. The values are
+   * sorted and the middle value is returned. In case of an even number of
+   * values, the average of the two middle values is returned.
+   * Supported types of values are: Number, BigNumber, Unit
+   *
+   * In case of a (multi dimensional) array or matrix, the median of all
+   * elements will be calculated.
+   *
+   * Syntax:
+   *
+   *     math.median(a, b, c, ...)
+   *     math.median(A)
+   *
+   * Examples:
+   *
+   *     math.median(5, 2, 7)        // returns 5
+   *     math.median([3, -1, 5, 7])  // returns 4
+   *
+   * See also:
+   *
+   *     mean, min, max, sum, prod, std, variance, quantileSeq
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} The median
+   */
+
+  return typed(name, {
+    // median([a, b, c, d, ...])
+    'Array | Matrix': _median,
+    // median([a, b, c, d, ...], dim)
+    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+      // TODO: implement median(A, dim)
+      throw new Error('median(A, dim) is not yet supported'); // return reduce(arguments[0], arguments[1], ...)
+    },
+    // median(a, b, c, d, ...)
+    '...': function _(args) {
+      if ((0, _collection.containsCollections)(args)) {
+        throw new TypeError('Scalar values expected in function median');
+      }
+
+      return _median(args);
+    }
+  });
+});
+exports.createMedian = createMedian;

package/dist/node_modules/mathjs/lib/cjs/function/statistics/min.js

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMin = void 0;
+
+var _collection = require("../../utils/collection.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+
+var name = 'min';
+var dependencies = ['typed', 'config', 'numeric', 'smaller'];
+var createMin = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      numeric = _ref.numeric,
+      smaller = _ref.smaller;
+
+  /**
+   * Compute the minimum value of a matrix or a  list of values.
+   * In case of a multi dimensional array, the minimum of the flattened array
+   * will be calculated. When `dim` is provided, the minimum over the selected
+   * dimension will be calculated. Parameter `dim` is zero-based.
+   *
+   * Syntax:
+   *
+   *     math.min(a, b, c, ...)
+   *     math.min(A)
+   *     math.min(A, dim)
+   *
+   * Examples:
+   *
+   *     math.min(2, 1, 4, 3)                  // returns 1
+   *     math.min([2, 1, 4, 3])                // returns 1
+   *
+   *     // minimum over a specified dimension (zero-based)
+   *     math.min([[2, 5], [4, 3], [1, 7]], 0) // returns [1, 3]
+   *     math.min([[2, 5], [4, 3], [1, 7]], 1) // returns [2, 3, 1]
+   *
+   *     math.max(2.7, 7.1, -4.5, 2.0, 4.1)    // returns 7.1
+   *     math.min(2.7, 7.1, -4.5, 2.0, 4.1)    // returns -4.5
+   *
+   * See also:
+   *
+   *    mean, median, max, prod, std, sum, variance
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} The minimum value
+   */
+  return typed(name, {
+    // min([a, b, c, d, ...])
+    'Array | Matrix': _min,
+    // min([a, b, c, d, ...], dim)
+    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+      return (0, _collection.reduce)(array, dim.valueOf(), _smallest);
+    },
+    // min(a, b, c, d, ...)
+    '...': function _(args) {
+      if ((0, _collection.containsCollections)(args)) {
+        throw new TypeError('Scalar values expected in function min');
+      }
+
+      return _min(args);
+    }
+  });
+  /**
+   * Return the smallest of two values
+   * @param {*} x
+   * @param {*} y
+   * @returns {*} Returns x when x is smallest, or y when y is smallest
+   * @private
+   */
+
+  function _smallest(x, y) {
+    try {
+      return smaller(x, y) ? x : y;
+    } catch (err) {
+      throw (0, _improveErrorMessage.improveErrorMessage)(err, 'min', y);
+    }
+  }
+  /**
+   * Recursively calculate the minimum value in an n-dimensional array
+   * @param {Array} array
+   * @return {number} min
+   * @private
+   */
+
+
+  function _min(array) {
+    var min;
+    (0, _collection.deepForEach)(array, function (value) {
+      try {
+        if (isNaN(value) && typeof value === 'number') {
+          min = NaN;
+        } else if (min === undefined || smaller(value, min)) {
+          min = value;
+        }
+      } catch (err) {
+        throw (0, _improveErrorMessage.improveErrorMessage)(err, 'min', value);
+      }
+    });
+
+    if (min === undefined) {
+      throw new Error('Cannot calculate min of an empty array');
+    } // make sure returning numeric value: parse a string into a numeric value
+
+
+    if (typeof min === 'string') {
+      min = numeric(min, config.number);
+    }
+
+    return min;
+  }
+});
+exports.createMin = createMin;

package/dist/node_modules/mathjs/lib/cjs/function/statistics/mode.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMode = void 0;
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'mode';
+var dependencies = ['typed', 'isNaN', 'isNumeric'];
+var createMode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      isNaN = _ref.isNaN,
+      isNumeric = _ref.isNumeric;
+
+  /**
+  * Computes the mode of a set of numbers or a list with values(numbers or characters).
+  * If there are more than one modes, it returns a list of those values.
+  *
+  * Syntax:
+  *
+  *     math.mode(a, b, c, ...)
+  *     math.mode(A)
+  *
+  * Examples:
+  *
+  *     math.mode(2, 1, 4, 3, 1)                            // returns [1]
+  *     math.mode([1, 2.7, 3.2, 4, 2.7])                    // returns [2.7]
+  *     math.mode(1, 4, 6, 1, 6)                             // returns [1, 6]
+  *     math.mode('a','a','b','c')                           // returns ["a"]
+  *     math.mode(1, 1.5, 'abc')                             // returns [1, 1.5, "abc"]
+  *
+  * See also:
+  *
+  *     median,
+  *     mean
+  *
+  * @param {... *} args  A single matrix
+  * @return {*} The mode of all values
+  */
+  return typed(name, {
+    'Array | Matrix': _mode,
+    '...': function _(args) {
+      return _mode(args);
+    }
+  });
+  /**
+   * Calculates the mode in an 1-dimensional array
+   * @param {Array} values
+   * @return {Array} mode
+   * @private
+   */
+
+  function _mode(values) {
+    values = (0, _array.flatten)(values.valueOf());
+    var num = values.length;
+
+    if (num === 0) {
+      throw new Error('Cannot calculate mode of an empty array');
+    }
+
+    var count = {};
+    var mode = [];
+    var max = 0;
+
+    for (var i = 0; i < values.length; i++) {
+      var value = values[i];
+
+      if (isNumeric(value) && isNaN(value)) {
+        throw new Error('Cannot calculate mode of an array containing NaN values');
+      }
+
+      if (!(value in count)) {
+        count[value] = 0;
+      }
+
+      count[value]++;
+
+      if (count[value] === max) {
+        mode.push(value);
+      } else if (count[value] > max) {
+        max = count[value];
+        mode = [value];
+      }
+    }
+
+    return mode;
+  }
+});
+exports.createMode = createMode;

package/dist/node_modules/mathjs/lib/cjs/function/statistics/prod.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createProd = void 0;
+
+var _collection = require("../../utils/collection.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _improveErrorMessage = require("./utils/improveErrorMessage.js");
+
+var name = 'prod';
+var dependencies = ['typed', 'config', 'multiplyScalar', 'numeric'];
+var createProd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      multiplyScalar = _ref.multiplyScalar,
+      numeric = _ref.numeric;
+
+  /**
+   * Compute the product of a matrix or a list with values.
+   * In case of a (multi dimensional) array or matrix, the sum of all
+   * elements will be calculated.
+   *
+   * Syntax:
+   *
+   *     math.prod(a, b, c, ...)
+   *     math.prod(A)
+   *
+   * Examples:
+   *
+   *     math.multiply(2, 3)           // returns 6
+   *     math.prod(2, 3)               // returns 6
+   *     math.prod(2, 3, 4)            // returns 24
+   *     math.prod([2, 3, 4])          // returns 24
+   *     math.prod([[2, 5], [4, 3]])   // returns 120
+   *
+   * See also:
+   *
+   *    mean, median, min, max, sum, std, variance
+   *
+   * @param {... *} args  A single matrix or or multiple scalar values
+   * @return {*} The product of all values
+   */
+  return typed(name, {
+    // prod([a, b, c, d, ...])
+    'Array | Matrix': _prod,
+    // prod([a, b, c, d, ...], dim)
+    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
+      // TODO: implement prod(A, dim)
+      throw new Error('prod(A, dim) is not yet supported'); // return reduce(arguments[0], arguments[1], math.prod)
+    },
+    // prod(a, b, c, d, ...)
+    '...': function _(args) {
+      return _prod(args);
+    }
+  });
+  /**
+   * Recursively calculate the product of an n-dimensional array
+   * @param {Array} array
+   * @return {number} prod
+   * @private
+   */
+
+  function _prod(array) {
+    var prod;
+    (0, _collection.deepForEach)(array, function (value) {
+      try {
+        prod = prod === undefined ? value : multiplyScalar(prod, value);
+      } catch (err) {
+        throw (0, _improveErrorMessage.improveErrorMessage)(err, 'prod', value);
+      }
+    }); // make sure returning numeric value: parse a string into a numeric value
+
+    if (typeof prod === 'string') {
+      prod = numeric(prod, config.number);
+    }
+
+    if (prod === undefined) {
+      throw new Error('Cannot calculate prod of an empty array');
+    }
+
+    return prod;
+  }
+});
+exports.createProd = createProd;

package/dist/node_modules/mathjs/lib/cjs/function/statistics/quantileSeq.js

@@ -0,0 +1,285 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createQuantileSeq = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _number = require("../../utils/number.js");
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'quantileSeq';
+var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare'];
+var createQuantileSeq = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      add = _ref.add,
+      multiply = _ref.multiply,
+      partitionSelect = _ref.partitionSelect,
+      compare = _ref.compare;
+
+  /**
+   * Compute the prob order quantile of a matrix or a list with values.
+   * The sequence is sorted and the middle value is returned.
+   * Supported types of sequence values are: Number, BigNumber, Unit
+   * Supported types of probability are: Number, BigNumber
+   *
+   * In case of a (multi dimensional) array or matrix, the prob order quantile
+   * of all elements will be calculated.
+   *
+   * Syntax:
+   *
+   *     math.quantileSeq(A, prob[, sorted])
+   *     math.quantileSeq(A, [prob1, prob2, ...][, sorted])
+   *     math.quantileSeq(A, N[, sorted])
+   *
+   * Examples:
+   *
+   *     math.quantileSeq([3, -1, 5, 7], 0.5)         // returns 4
+   *     math.quantileSeq([3, -1, 5, 7], [1/3, 2/3])  // returns [3, 5]
+   *     math.quantileSeq([3, -1, 5, 7], 2)           // returns [3, 5]
+   *     math.quantileSeq([-1, 3, 5, 7], 0.5, true)   // returns 4
+   *
+   * See also:
+   *
+   *     median, mean, min, max, sum, prod, std, variance
+   *
+   * @param {Array, Matrix} data                A single matrix or Array
+   * @param {Number, BigNumber, Array} probOrN  prob is the order of the quantile, while N is
+   *                                            the amount of evenly distributed steps of
+   *                                            probabilities; only one of these options can
+   *                                            be provided
+   * @param {Boolean} sorted=false              is data sorted in ascending order
+   * @return {Number, BigNumber, Unit, Array}   Quantile(s)
+   */
+  function quantileSeq(data, probOrN, sorted) {
+    var probArr, dataArr, one;
+
+    if (arguments.length < 2 || arguments.length > 3) {
+      throw new SyntaxError('Function quantileSeq requires two or three parameters');
+    }
+
+    if ((0, _is.isCollection)(data)) {
+      sorted = sorted || false;
+
+      if (typeof sorted === 'boolean') {
+        dataArr = data.valueOf();
+
+        if ((0, _is.isNumber)(probOrN)) {
+          if (probOrN < 0) {
+            throw new Error('N/prob must be non-negative');
+          }
+
+          if (probOrN <= 1) {
+            // quantileSeq([a, b, c, d, ...], prob[,sorted])
+            return _quantileSeq(dataArr, probOrN, sorted);
+          }
+
+          if (probOrN > 1) {
+            // quantileSeq([a, b, c, d, ...], N[,sorted])
+            if (!(0, _number.isInteger)(probOrN)) {
+              throw new Error('N must be a positive integer');
+            }
+
+            var nPlusOne = probOrN + 1;
+            probArr = new Array(probOrN);
+
+            for (var i = 0; i < probOrN;) {
+              probArr[i] = _quantileSeq(dataArr, ++i / nPlusOne, sorted);
+            }
+
+            return probArr;
+          }
+        }
+
+        if ((0, _is.isBigNumber)(probOrN)) {
+          var BigNumber = probOrN.constructor;
+
+          if (probOrN.isNegative()) {
+            throw new Error('N/prob must be non-negative');
+          }
+
+          one = new BigNumber(1);
+
+          if (probOrN.lte(one)) {
+            // quantileSeq([a, b, c, d, ...], prob[,sorted])
+            return new BigNumber(_quantileSeq(dataArr, probOrN, sorted));
+          }
+
+          if (probOrN.gt(one)) {
+            // quantileSeq([a, b, c, d, ...], N[,sorted])
+            if (!probOrN.isInteger()) {
+              throw new Error('N must be a positive integer');
+            } // largest possible Array length is 2^32-1
+            // 2^32 < 10^15, thus safe conversion guaranteed
+
+
+            var intN = probOrN.toNumber();
+
+            if (intN > 4294967295) {
+              throw new Error('N must be less than or equal to 2^32-1, as that is the maximum length of an Array');
+            }
+
+            var _nPlusOne = new BigNumber(intN + 1);
+
+            probArr = new Array(intN);
+
+            for (var _i = 0; _i < intN;) {
+              probArr[_i] = new BigNumber(_quantileSeq(dataArr, new BigNumber(++_i).div(_nPlusOne), sorted));
+            }
+
+            return probArr;
+          }
+        }
+
+        if (Array.isArray(probOrN)) {
+          // quantileSeq([a, b, c, d, ...], [prob1, prob2, ...][,sorted])
+          probArr = new Array(probOrN.length);
+
+          for (var _i2 = 0; _i2 < probArr.length; ++_i2) {
+            var currProb = probOrN[_i2];
+
+            if ((0, _is.isNumber)(currProb)) {
+              if (currProb < 0 || currProb > 1) {
+                throw new Error('Probability must be between 0 and 1, inclusive');
+              }
+            } else if ((0, _is.isBigNumber)(currProb)) {
+              one = new currProb.constructor(1);
+
+              if (currProb.isNegative() || currProb.gt(one)) {
+                throw new Error('Probability must be between 0 and 1, inclusive');
+              }
+            } else {
+              throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+            }
+
+            probArr[_i2] = _quantileSeq(dataArr, currProb, sorted);
+          }
+
+          return probArr;
+        }
+
+        throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+      }
+
+      throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+    }
+
+    throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+  }
+  /**
+   * Calculate the prob order quantile of an n-dimensional array.
+   *
+   * @param {Array} array
+   * @param {Number, BigNumber} prob
+   * @param {Boolean} sorted
+   * @return {Number, BigNumber, Unit} prob order quantile
+   * @private
+   */
+
+
+  function _quantileSeq(array, prob, sorted) {
+    var flat = (0, _array.flatten)(array);
+    var len = flat.length;
+
+    if (len === 0) {
+      throw new Error('Cannot calculate quantile of an empty sequence');
+    }
+
+    if ((0, _is.isNumber)(prob)) {
+      var _index = prob * (len - 1);
+
+      var _fracPart = _index % 1;
+
+      if (_fracPart === 0) {
+        var value = sorted ? flat[_index] : partitionSelect(flat, _index);
+        validate(value);
+        return value;
+      }
+
+      var _integerPart = Math.floor(_index);
+
+      var _left;
+
+      var _right;
+
+      if (sorted) {
+        _left = flat[_integerPart];
+        _right = flat[_integerPart + 1];
+      } else {
+        _right = partitionSelect(flat, _integerPart + 1); // max of partition is kth largest
+
+        _left = flat[_integerPart];
+
+        for (var i = 0; i < _integerPart; ++i) {
+          if (compare(flat[i], _left) > 0) {
+            _left = flat[i];
+          }
+        }
+      }
+
+      validate(_left);
+      validate(_right); // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
+
+      return add(multiply(_left, 1 - _fracPart), multiply(_right, _fracPart));
+    } // If prob is a BigNumber
+
+
+    var index = prob.times(len - 1);
+
+    if (index.isInteger()) {
+      index = index.toNumber();
+
+      var _value = sorted ? flat[index] : partitionSelect(flat, index);
+
+      validate(_value);
+      return _value;
+    }
+
+    var integerPart = index.floor();
+    var fracPart = index.minus(integerPart);
+    var integerPartNumber = integerPart.toNumber();
+    var left;
+    var right;
+
+    if (sorted) {
+      left = flat[integerPartNumber];
+      right = flat[integerPartNumber + 1];
+    } else {
+      right = partitionSelect(flat, integerPartNumber + 1); // max of partition is kth largest
+
+      left = flat[integerPartNumber];
+
+      for (var _i3 = 0; _i3 < integerPartNumber; ++_i3) {
+        if (compare(flat[_i3], left) > 0) {
+          left = flat[_i3];
+        }
+      }
+    }
+
+    validate(left);
+    validate(right); // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
+
+    var one = new fracPart.constructor(1);
+    return add(multiply(left, one.minus(fracPart)), multiply(right, fracPart));
+  }
+  /**
+   * Check if array value types are valid, throw error otherwise.
+   * @param {number | BigNumber | Unit} x
+   * @param {number | BigNumber | Unit} x
+   * @private
+   */
+
+
+  var validate = typed({
+    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
+      return x;
+    }
+  });
+  return quantileSeq;
+});
+exports.createQuantileSeq = createQuantileSeq;