@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/plain/number/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.tau = exports.pi = exports.phi = exports.e = void 0;
+var pi = Math.PI;
+exports.pi = pi;
+var tau = 2 * Math.PI;
+exports.tau = tau;
+var e = Math.E;
+exports.e = e;
+var phi = 1.6180339887498948; // eslint-disable-line no-loss-of-precision
+
+exports.phi = phi;

package/dist/node_modules/mathjs/lib/cjs/plain/number/index.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _arithmetic = require("./arithmetic.js");
+
+Object.keys(_arithmetic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _arithmetic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _arithmetic[key];
+    }
+  });
+});
+
+var _bitwise = require("./bitwise.js");
+
+Object.keys(_bitwise).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bitwise[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _bitwise[key];
+    }
+  });
+});
+
+var _combinations = require("./combinations.js");
+
+Object.keys(_combinations).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _combinations[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _combinations[key];
+    }
+  });
+});
+
+var _constants = require("./constants.js");
+
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _constants[key];
+    }
+  });
+});
+
+var _logical = require("./logical.js");
+
+Object.keys(_logical).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _logical[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _logical[key];
+    }
+  });
+});
+
+var _relational = require("./relational.js");
+
+Object.keys(_relational).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _relational[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _relational[key];
+    }
+  });
+});
+
+var _probability = require("./probability.js");
+
+Object.keys(_probability).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _probability[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _probability[key];
+    }
+  });
+});
+
+var _trigonometry = require("./trigonometry.js");
+
+Object.keys(_trigonometry).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _trigonometry[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _trigonometry[key];
+    }
+  });
+});
+
+var _utils = require("./utils.js");
+
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _utils[key];
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/cjs/plain/number/logical.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.andNumber = andNumber;
+exports.notNumber = notNumber;
+exports.orNumber = orNumber;
+exports.xorNumber = xorNumber;
+var n1 = 'number';
+var n2 = 'number, number';
+
+function notNumber(x) {
+  return !x;
+}
+
+notNumber.signature = n1;
+
+function orNumber(x, y) {
+  return !!(x || y);
+}
+
+orNumber.signature = n2;
+
+function xorNumber(x, y) {
+  return !!x !== !!y;
+}
+
+xorNumber.signature = n2;
+
+function andNumber(x, y) {
+  return !!(x && y);
+}
+
+andNumber.signature = n2;

package/dist/node_modules/mathjs/lib/cjs/plain/number/probability.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gammaG = void 0;
+exports.gammaNumber = gammaNumber;
+exports.lgammaN = exports.lgammaG = exports.gammaP = void 0;
+exports.lgammaNumber = lgammaNumber;
+exports.lnSqrt2PI = exports.lgammaSeries = void 0;
+
+var _number = require("../../utils/number.js");
+
+var _product = require("../../utils/product.js");
+
+/* eslint-disable no-loss-of-precision */
+function gammaNumber(n) {
+  var x;
+
+  if ((0, _number.isInteger)(n)) {
+    if (n <= 0) {
+      return isFinite(n) ? Infinity : NaN;
+    }
+
+    if (n > 171) {
+      return Infinity; // Will overflow
+    }
+
+    return (0, _product.product)(1, n - 1);
+  }
+
+  if (n < 0.5) {
+    return Math.PI / (Math.sin(Math.PI * n) * gammaNumber(1 - n));
+  }
+
+  if (n >= 171.35) {
+    return Infinity; // will overflow
+  }
+
+  if (n > 85.0) {
+    // Extended Stirling Approx
+    var twoN = n * n;
+    var threeN = twoN * n;
+    var fourN = threeN * n;
+    var fiveN = fourN * n;
+    return Math.sqrt(2 * Math.PI / n) * Math.pow(n / Math.E, n) * (1 + 1 / (12 * n) + 1 / (288 * twoN) - 139 / (51840 * threeN) - 571 / (2488320 * fourN) + 163879 / (209018880 * fiveN) + 5246819 / (75246796800 * fiveN * n));
+  }
+
+  --n;
+  x = gammaP[0];
+
+  for (var i = 1; i < gammaP.length; ++i) {
+    x += gammaP[i] / (n + i);
+  }
+
+  var t = n + gammaG + 0.5;
+  return Math.sqrt(2 * Math.PI) * Math.pow(t, n + 0.5) * Math.exp(-t) * x;
+}
+
+gammaNumber.signature = 'number'; // TODO: comment on the variables g and p
+
+var gammaG = 4.7421875;
+exports.gammaG = gammaG;
+var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5]; // lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
+// log(2 * pi) / 2
+
+exports.gammaP = gammaP;
+var lnSqrt2PI = 0.91893853320467274178;
+exports.lnSqrt2PI = lnSqrt2PI;
+var lgammaG = 5; // Lanczos parameter "g"
+
+exports.lgammaG = lgammaG;
+var lgammaN = 7; // Range of coefficients "n"
+
+exports.lgammaN = lgammaN;
+var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+exports.lgammaSeries = lgammaSeries;
+
+function lgammaNumber(n) {
+  if (n < 0) return NaN;
+  if (n === 0) return Infinity;
+  if (!isFinite(n)) return n;
+
+  if (n < 0.5) {
+    // Use Euler's reflection formula:
+    // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))
+    return Math.log(Math.PI / Math.sin(Math.PI * n)) - lgammaNumber(1 - n);
+  } // Compute the logarithm of the Gamma function using the Lanczos method
+
+
+  n = n - 1;
+  var base = n + lgammaG + 0.5; // Base of the Lanczos exponential
+
+  var sum = lgammaSeries[0]; // We start with the terms that have the smallest coefficients and largest denominator
+
+  for (var i = lgammaN - 1; i >= 1; i--) {
+    sum += lgammaSeries[i] / (n + i);
+  }
+
+  return lnSqrt2PI + (n + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+
+lgammaNumber.signature = 'number';

package/dist/node_modules/mathjs/lib/cjs/plain/number/relational.js

@@ -0,0 +1 @@
+"use strict";

package/dist/node_modules/mathjs/lib/cjs/plain/number/trigonometry.js

@@ -0,0 +1,194 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.acosNumber = acosNumber;
+exports.acoshNumber = acoshNumber;
+exports.acotNumber = acotNumber;
+exports.acothNumber = acothNumber;
+exports.acscNumber = acscNumber;
+exports.acschNumber = acschNumber;
+exports.asecNumber = asecNumber;
+exports.asechNumber = asechNumber;
+exports.asinNumber = asinNumber;
+exports.asinhNumber = asinhNumber;
+exports.atan2Number = atan2Number;
+exports.atanNumber = atanNumber;
+exports.atanhNumber = atanhNumber;
+exports.cosNumber = cosNumber;
+exports.coshNumber = coshNumber;
+exports.cotNumber = cotNumber;
+exports.cothNumber = cothNumber;
+exports.cscNumber = cscNumber;
+exports.cschNumber = cschNumber;
+exports.secNumber = secNumber;
+exports.sechNumber = sechNumber;
+exports.sinNumber = sinNumber;
+exports.sinhNumber = sinhNumber;
+exports.tanNumber = tanNumber;
+exports.tanhNumber = tanhNumber;
+
+var _number = require("../../utils/number.js");
+
+var n1 = 'number';
+var n2 = 'number, number';
+
+function acosNumber(x) {
+  return Math.acos(x);
+}
+
+acosNumber.signature = n1;
+
+function acoshNumber(x) {
+  return (0, _number.acosh)(x);
+}
+
+acoshNumber.signature = n1;
+
+function acotNumber(x) {
+  return Math.atan(1 / x);
+}
+
+acotNumber.signature = n1;
+
+function acothNumber(x) {
+  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+}
+
+acothNumber.signature = n1;
+
+function acscNumber(x) {
+  return Math.asin(1 / x);
+}
+
+acscNumber.signature = n1;
+
+function acschNumber(x) {
+  var xInv = 1 / x;
+  return Math.log(xInv + Math.sqrt(xInv * xInv + 1));
+}
+
+acschNumber.signature = n1;
+
+function asecNumber(x) {
+  return Math.acos(1 / x);
+}
+
+asecNumber.signature = n1;
+
+function asechNumber(x) {
+  var xInv = 1 / x;
+  var ret = Math.sqrt(xInv * xInv - 1);
+  return Math.log(ret + xInv);
+}
+
+asechNumber.signature = n1;
+
+function asinNumber(x) {
+  return Math.asin(x);
+}
+
+asinNumber.signature = n1;
+
+function asinhNumber(x) {
+  return (0, _number.asinh)(x);
+}
+
+asinhNumber.signature = n1;
+
+function atanNumber(x) {
+  return Math.atan(x);
+}
+
+atanNumber.signature = n1;
+
+function atan2Number(y, x) {
+  return Math.atan2(y, x);
+}
+
+atan2Number.signature = n2;
+
+function atanhNumber(x) {
+  return (0, _number.atanh)(x);
+}
+
+atanhNumber.signature = n1;
+
+function cosNumber(x) {
+  return Math.cos(x);
+}
+
+cosNumber.signature = n1;
+
+function coshNumber(x) {
+  return (0, _number.cosh)(x);
+}
+
+coshNumber.signature = n1;
+
+function cotNumber(x) {
+  return 1 / Math.tan(x);
+}
+
+cotNumber.signature = n1;
+
+function cothNumber(x) {
+  var e = Math.exp(2 * x);
+  return (e + 1) / (e - 1);
+}
+
+cothNumber.signature = n1;
+
+function cscNumber(x) {
+  return 1 / Math.sin(x);
+}
+
+cscNumber.signature = n1;
+
+function cschNumber(x) {
+  // consider values close to zero (+/-)
+  if (x === 0) {
+    return Number.POSITIVE_INFINITY;
+  } else {
+    return Math.abs(2 / (Math.exp(x) - Math.exp(-x))) * (0, _number.sign)(x);
+  }
+}
+
+cschNumber.signature = n1;
+
+function secNumber(x) {
+  return 1 / Math.cos(x);
+}
+
+secNumber.signature = n1;
+
+function sechNumber(x) {
+  return 2 / (Math.exp(x) + Math.exp(-x));
+}
+
+sechNumber.signature = n1;
+
+function sinNumber(x) {
+  return Math.sin(x);
+}
+
+sinNumber.signature = n1;
+
+function sinhNumber(x) {
+  return (0, _number.sinh)(x);
+}
+
+sinhNumber.signature = n1;
+
+function tanNumber(x) {
+  return Math.tan(x);
+}
+
+tanNumber.signature = n1;
+
+function tanhNumber(x) {
+  return (0, _number.tanh)(x);
+}
+
+tanhNumber.signature = n1;

package/dist/node_modules/mathjs/lib/cjs/plain/number/utils.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIntegerNumber = isIntegerNumber;
+exports.isNaNNumber = isNaNNumber;
+exports.isNegativeNumber = isNegativeNumber;
+exports.isPositiveNumber = isPositiveNumber;
+exports.isZeroNumber = isZeroNumber;
+
+var _number = require("../../utils/number.js");
+
+var n1 = 'number';
+
+function isIntegerNumber(x) {
+  return (0, _number.isInteger)(x);
+}
+
+isIntegerNumber.signature = n1;
+
+function isNegativeNumber(x) {
+  return x < 0;
+}
+
+isNegativeNumber.signature = n1;
+
+function isPositiveNumber(x) {
+  return x > 0;
+}
+
+isPositiveNumber.signature = n1;
+
+function isZeroNumber(x) {
+  return x === 0;
+}
+
+isZeroNumber.signature = n1;
+
+function isNaNNumber(x) {
+  return Number.isNaN(x);
+}
+
+isNaNNumber.signature = n1;

package/dist/node_modules/mathjs/lib/cjs/type/bignumber/BigNumber.js

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBigNumberClass = void 0;
+
+var _decimal = _interopRequireDefault(require("decimal.js"));
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'BigNumber';
+var dependencies = ['?on', 'config'];
+var createBigNumberClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var on = _ref.on,
+      config = _ref.config;
+
+  var BigNumber = _decimal.default.clone({
+    precision: config.precision,
+    modulo: _decimal.default.EUCLID
+  });
+
+  BigNumber.prototype = Object.create(BigNumber.prototype);
+  /**
+   * Attach type information
+   */
+
+  BigNumber.prototype.type = 'BigNumber';
+  BigNumber.prototype.isBigNumber = true;
+  /**
+   * Get a JSON representation of a BigNumber containing
+   * type information
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "BigNumber", "value": "0.2"}`
+   */
+
+  BigNumber.prototype.toJSON = function () {
+    return {
+      mathjs: 'BigNumber',
+      value: this.toString()
+    };
+  };
+  /**
+   * Instantiate a BigNumber from a JSON object
+   * @param {Object} json  a JSON object structured as:
+   *                       `{"mathjs": "BigNumber", "value": "0.2"}`
+   * @return {BigNumber}
+   */
+
+
+  BigNumber.fromJSON = function (json) {
+    return new BigNumber(json.value);
+  };
+
+  if (on) {
+    // listen for changed in the configuration, automatically apply changed precision
+    on('config', function (curr, prev) {
+      if (curr.precision !== prev.precision) {
+        BigNumber.config({
+          precision: curr.precision
+        });
+      }
+    });
+  }
+
+  return BigNumber;
+}, {
+  isClass: true
+});
+exports.createBigNumberClass = createBigNumberClass;

package/dist/node_modules/mathjs/lib/cjs/type/bignumber/function/bignumber.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBignumber = void 0;
+
+var _factory = require("../../../utils/factory.js");
+
+var _collection = require("../../../utils/collection.js");
+
+var name = 'bignumber';
+var dependencies = ['typed', 'BigNumber'];
+var createBignumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      BigNumber = _ref.BigNumber;
+
+  /**
+   * Create a BigNumber, which can store numbers with arbitrary precision.
+   * When a matrix is provided, all elements will be converted to BigNumber.
+   *
+   * Syntax:
+   *
+   *    math.bignumber(x)
+   *
+   * Examples:
+   *
+   *    0.1 + 0.2                                  // returns number 0.30000000000000004
+   *    math.bignumber(0.1) + math.bignumber(0.2)  // returns BigNumber 0.3
+   *
+   *
+   *    7.2e500                                    // returns number Infinity
+   *    math.bignumber('7.2e500')                  // returns BigNumber 7.2e500
+   *
+   * See also:
+   *
+   *    boolean, complex, index, matrix, string, unit
+   *
+   * @param {number | string | Fraction | BigNumber | Array | Matrix | boolean | null} [value]  Value for the big number,
+   *                                                    0 by default.
+   * @returns {BigNumber} The created bignumber
+   */
+  return typed('bignumber', {
+    '': function _() {
+      return new BigNumber(0);
+    },
+    number: function number(x) {
+      // convert to string to prevent errors in case of >15 digits
+      return new BigNumber(x + '');
+    },
+    string: function string(x) {
+      var wordSizeSuffixMatch = x.match(/(0[box][0-9a-fA-F]*)i([0-9]*)/);
+
+      if (wordSizeSuffixMatch) {
+        // x has a word size suffix
+        var size = wordSizeSuffixMatch[2];
+        var n = BigNumber(wordSizeSuffixMatch[1]);
+        var twoPowSize = new BigNumber(2).pow(Number(size));
+
+        if (n.gt(twoPowSize.sub(1))) {
+          throw new SyntaxError("String \"".concat(x, "\" is out of range"));
+        }
+
+        var twoPowSizeSubOne = new BigNumber(2).pow(Number(size) - 1);
+
+        if (n.gte(twoPowSizeSubOne)) {
+          return n.sub(twoPowSize);
+        } else {
+          return n;
+        }
+      }
+
+      return new BigNumber(x);
+    },
+    BigNumber: function BigNumber(x) {
+      // we assume a BigNumber is immutable
+      return x;
+    },
+    Fraction: function Fraction(x) {
+      return new BigNumber(x.n).div(x.d).times(x.s);
+    },
+    null: function _null(x) {
+      return new BigNumber(0);
+    },
+    'Array | Matrix': function ArrayMatrix(x) {
+      return (0, _collection.deepMap)(x, this);
+    }
+  });
+});
+exports.createBignumber = createBignumber;