@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/esm/function/probability/combinations.js

@@ -0,0 +1,74 @@
+import { factory } from '../../utils/factory.js';
+import { combinationsNumber } from '../../plain/number/combinations.js';
+var name = 'combinations';
+var dependencies = ['typed'];
+export var createCombinations = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * Compute the number of ways of picking `k` unordered outcomes from `n`
+   * possibilities.
+   *
+   * Combinations only takes integer arguments.
+   * The following condition must be enforced: k <= n.
+   *
+   * Syntax:
+   *
+   *     math.combinations(n, k)
+   *
+   * Examples:
+   *
+   *    math.combinations(7, 5) // returns 21
+   *
+   * See also:
+   *
+   *    combinationsWithRep, permutations, factorial
+   *
+   * @param {number | BigNumber} n    Total number of objects in the set
+   * @param {number | BigNumber} k    Number of objects in the subset
+   * @return {number | BigNumber}     Number of possible combinations.
+   */
+  return typed(name, {
+    'number, number': combinationsNumber,
+    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+      var BigNumber = n.constructor;
+      var result, i;
+      var nMinusk = n.minus(k);
+      var one = new BigNumber(1);
+
+      if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
+        throw new TypeError('Positive integer value expected in function combinations');
+      }
+
+      if (k.gt(n)) {
+        throw new TypeError('k must be less than n in function combinations');
+      }
+
+      result = one;
+
+      if (k.lt(nMinusk)) {
+        for (i = one; i.lte(nMinusk); i = i.plus(one)) {
+          result = result.times(k.plus(i)).dividedBy(i);
+        }
+      } else {
+        for (i = one; i.lte(k); i = i.plus(one)) {
+          result = result.times(nMinusk.plus(i)).dividedBy(i);
+        }
+      }
+
+      return result;
+    } // TODO: implement support for collection in combinations
+
+  });
+});
+/**
+ * Test whether BigNumber n is a positive integer
+ * @param {BigNumber} n
+ * @returns {boolean} isPositiveInteger
+ */
+
+function isPositiveInteger(n) {
+  return n.isInteger() && n.gte(0);
+}

package/dist/node_modules/mathjs/lib/esm/function/probability/combinationsWithRep.js

@@ -0,0 +1,95 @@
+import { factory } from '../../utils/factory.js';
+import { isInteger } from '../../utils/number.js';
+import { product } from '../../utils/product.js';
+var name = 'combinationsWithRep';
+var dependencies = ['typed'];
+export var createCombinationsWithRep = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+
+  /**
+   * Compute the number of ways of picking `k` unordered outcomes from `n`
+   * possibilities, allowing individual outcomes to be repeated more than once.
+   *
+   * CombinationsWithRep only takes integer arguments.
+   * The following condition must be enforced: k <= n + k -1.
+   *
+   * Syntax:
+   *
+   *     math.combinationsWithRep(n, k)
+   *
+   * Examples:
+   *
+   *    math.combinationsWithRep(7, 5) // returns 462
+   *
+   * See also:
+   *
+   *    combinations, permutations, factorial
+   *
+   * @param {number | BigNumber} n    Total number of objects in the set
+   * @param {number | BigNumber} k    Number of objects in the subset
+   * @return {number | BigNumber}     Number of possible combinations with replacement.
+   */
+  return typed(name, {
+    'number, number': function numberNumber(n, k) {
+      if (!isInteger(n) || n < 0) {
+        throw new TypeError('Positive integer value expected in function combinationsWithRep');
+      }
+
+      if (!isInteger(k) || k < 0) {
+        throw new TypeError('Positive integer value expected in function combinationsWithRep');
+      }
+
+      if (n < 1) {
+        throw new TypeError('k must be less than or equal to n + k - 1');
+      }
+
+      if (k < n - 1) {
+        var _prodrange = product(n, n + k - 1);
+
+        return _prodrange / product(1, k);
+      }
+
+      var prodrange = product(k + 1, n + k - 1);
+      return prodrange / product(1, n - 1);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+      var BigNumber = n.constructor;
+      var result, i;
+      var one = new BigNumber(1);
+      var nMinusOne = n.minus(one);
+
+      if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
+        throw new TypeError('Positive integer value expected in function combinationsWithRep');
+      }
+
+      if (n.lt(one)) {
+        throw new TypeError('k must be less than or equal to n + k - 1 in function combinationsWithRep');
+      }
+
+      result = one;
+
+      if (k.lt(nMinusOne)) {
+        for (i = one; i.lte(nMinusOne); i = i.plus(one)) {
+          result = result.times(k.plus(i)).dividedBy(i);
+        }
+      } else {
+        for (i = one; i.lte(k); i = i.plus(one)) {
+          result = result.times(nMinusOne.plus(i)).dividedBy(i);
+        }
+      }
+
+      return result;
+    }
+  });
+});
+/**
+ * Test whether BigNumber n is a positive integer
+ * @param {BigNumber} n
+ * @returns {boolean} isPositiveInteger
+ */
+
+function isPositiveInteger(n) {
+  return n.isInteger() && n.gte(0);
+}

package/dist/node_modules/mathjs/lib/esm/function/probability/factorial.js

@@ -0,0 +1,52 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+var name = 'factorial';
+var dependencies = ['typed', 'gamma'];
+export var createFactorial = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    gamma
+  } = _ref;
+
+  /**
+   * Compute the factorial of a value
+   *
+   * Factorial only supports an integer value as argument.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.factorial(n)
+   *
+   * Examples:
+   *
+   *    math.factorial(5)    // returns 120
+   *    math.factorial(3)    // returns 6
+   *
+   * See also:
+   *
+   *    combinations, combinationsWithRep, gamma, permutations
+   *
+   * @param {number | BigNumber | Array | Matrix} n   An integer number
+   * @return {number | BigNumber | Array | Matrix}    The factorial of `n`
+   */
+  return typed(name, {
+    number: function number(n) {
+      if (n < 0) {
+        throw new Error('Value must be non-negative');
+      }
+
+      return gamma(n + 1);
+    },
+    BigNumber: function BigNumber(n) {
+      if (n.isNegative()) {
+        throw new Error('Value must be non-negative');
+      }
+
+      return gamma(n.plus(1));
+    },
+    'Array | Matrix': function ArrayMatrix(n) {
+      return deepMap(n, this);
+    }
+  });
+});

package/dist/node_modules/mathjs/lib/esm/function/probability/gamma.js

@@ -0,0 +1,129 @@
+import { deepMap } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+import { gammaG, gammaNumber, gammaP } from '../../plain/number/index.js';
+var name = 'gamma';
+var dependencies = ['typed', 'config', 'multiplyScalar', 'pow', 'BigNumber', 'Complex'];
+export var createGamma = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    multiplyScalar,
+    pow,
+    BigNumber: _BigNumber,
+    Complex: _Complex
+  } = _ref;
+
+  /**
+   * Compute the gamma function of a value using Lanczos approximation for
+   * small values, and an extended Stirling approximation for large values.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.gamma(n)
+   *
+   * Examples:
+   *
+   *    math.gamma(5)       // returns 24
+   *    math.gamma(-0.5)    // returns -3.5449077018110335
+   *    math.gamma(math.i)  // returns -0.15494982830180973 - 0.49801566811835596i
+   *
+   * See also:
+   *
+   *    combinations, factorial, permutations
+   *
+   * @param {number | Array | Matrix} n   A real or complex number
+   * @return {number | Array | Matrix}    The gamma of `n`
+   */
+  return typed(name, {
+    number: gammaNumber,
+    Complex: function Complex(n) {
+      if (n.im === 0) {
+        return this(n.re);
+      } // Lanczos approximation doesn't work well with real part lower than 0.5
+      // So reflection formula is required
+
+
+      if (n.re < 0.5) {
+        // Euler's reflection formula
+        // gamma(1-z) * gamma(z) = PI / sin(PI * z)
+        // real part of Z should not be integer [sin(PI) == 0 -> 1/0 - undefined]
+        // thanks to imperfect sin implementation sin(PI * n) != 0
+        // we can safely use it anyway
+        var _t = new _Complex(1 - n.re, -n.im);
+
+        var r = new _Complex(Math.PI * n.re, Math.PI * n.im);
+        return new _Complex(Math.PI).div(r.sin()).div(this(_t));
+      } // Lanczos approximation
+      // z -= 1
+
+
+      n = new _Complex(n.re - 1, n.im); // x = gammaPval[0]
+
+      var x = new _Complex(gammaP[0], 0); // for (i, gammaPval) in enumerate(gammaP):
+
+      for (var i = 1; i < gammaP.length; ++i) {
+        // x += gammaPval / (z + i)
+        var gammaPval = new _Complex(gammaP[i], 0);
+        x = x.add(gammaPval.div(n.add(i)));
+      } // t = z + gammaG + 0.5
+
+
+      var t = new _Complex(n.re + gammaG + 0.5, n.im); // y = sqrt(2 * pi) * t ** (z + 0.5) * exp(-t) * x
+
+      var twoPiSqrt = Math.sqrt(2 * Math.PI);
+      var tpow = t.pow(n.add(0.5));
+      var expt = t.neg().exp(); // y = [x] * [sqrt(2 * pi)] * [t ** (z + 0.5)] * [exp(-t)]
+
+      return x.mul(twoPiSqrt).mul(tpow).mul(expt);
+    },
+    BigNumber: function BigNumber(n) {
+      if (n.isInteger()) {
+        return n.isNegative() || n.isZero() ? new _BigNumber(Infinity) : bigFactorial(n.minus(1));
+      }
+
+      if (!n.isFinite()) {
+        return new _BigNumber(n.isNegative() ? NaN : Infinity);
+      }
+
+      throw new Error('Integer BigNumber expected');
+    },
+    'Array | Matrix': function ArrayMatrix(n) {
+      return deepMap(n, this);
+    }
+  });
+  /**
+   * Calculate factorial for a BigNumber
+   * @param {BigNumber} n
+   * @returns {BigNumber} Returns the factorial of n
+   */
+
+  function bigFactorial(n) {
+    if (n < 8) {
+      return new _BigNumber([1, 1, 2, 6, 24, 120, 720, 5040][n]);
+    }
+
+    var precision = config.precision + (Math.log(n.toNumber()) | 0);
+
+    var Big = _BigNumber.clone({
+      precision
+    });
+
+    if (n % 2 === 1) {
+      return n.times(bigFactorial(new _BigNumber(n - 1)));
+    }
+
+    var p = n;
+    var prod = new Big(n);
+    var sum = n.toNumber();
+
+    while (p > 2) {
+      p -= 2;
+      sum += p;
+      prod = prod.times(sum);
+    }
+
+    return new _BigNumber(prod.toPrecision(_BigNumber.precision));
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/probability/kldivergence.js

@@ -0,0 +1,86 @@
+import { factory } from '../../utils/factory.js';
+var name = 'kldivergence';
+var dependencies = ['typed', 'matrix', 'divide', 'sum', 'multiply', 'dotDivide', 'log', 'isNumeric'];
+export var createKldivergence = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    divide,
+    sum,
+    multiply,
+    dotDivide,
+    log,
+    isNumeric
+  } = _ref;
+
+  /**
+     * Calculate the Kullback-Leibler (KL) divergence  between two distributions
+     *
+     * Syntax:
+     *
+     *     math.kldivergence(x, y)
+     *
+     * Examples:
+     *
+     *     math.kldivergence([0.7,0.5,0.4], [0.2,0.9,0.5])   //returns 0.24376698773121153
+     *
+     *
+     * @param  {Array | Matrix} q    First vector
+     * @param  {Array | Matrix} p    Second vector
+     * @return {number}              Returns distance between q and p
+     */
+  return typed(name, {
+    'Array, Array': function ArrayArray(q, p) {
+      return _kldiv(matrix(q), matrix(p));
+    },
+    'Matrix, Array': function MatrixArray(q, p) {
+      return _kldiv(q, matrix(p));
+    },
+    'Array, Matrix': function ArrayMatrix(q, p) {
+      return _kldiv(matrix(q), p);
+    },
+    'Matrix, Matrix': function MatrixMatrix(q, p) {
+      return _kldiv(q, p);
+    }
+  });
+
+  function _kldiv(q, p) {
+    var plength = p.size().length;
+    var qlength = q.size().length;
+
+    if (plength > 1) {
+      throw new Error('first object must be one dimensional');
+    }
+
+    if (qlength > 1) {
+      throw new Error('second object must be one dimensional');
+    }
+
+    if (plength !== qlength) {
+      throw new Error('Length of two vectors must be equal');
+    } // Before calculation, apply normalization
+
+
+    var sumq = sum(q);
+
+    if (sumq === 0) {
+      throw new Error('Sum of elements in first object must be non zero');
+    }
+
+    var sump = sum(p);
+
+    if (sump === 0) {
+      throw new Error('Sum of elements in second object must be non zero');
+    }
+
+    var qnorm = divide(q, sum(q));
+    var pnorm = divide(p, sum(p));
+    var result = sum(multiply(qnorm, log(dotDivide(qnorm, pnorm))));
+
+    if (isNumeric(result)) {
+      return result;
+    } else {
+      return Number.NaN;
+    }
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/probability/lgamma.js

@@ -0,0 +1,137 @@
+/* eslint-disable no-loss-of-precision */
+// References
+// ----------
+// [1] Hare, "Computing the Principal Branch of log-Gamma", Journal of Algorithms, 1997.
+// [2] https://math.stackexchange.com/questions/1338753/how-do-i-calculate-values-for-gamma-function-with-complex-arguments
+import { lgammaNumber, lnSqrt2PI } from '../../plain/number/index.js';
+import { factory } from '../../utils/factory.js';
+import { copysign } from '../../utils/number.js';
+var name = 'lgamma';
+var dependencies = ['Complex', 'typed'];
+export var createLgamma = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    Complex: _Complex,
+    typed
+  } = _ref;
+  // Stirling series is non-convergent, we need to use the recurrence `lgamma(z) = lgamma(z+1) - log z` to get
+  // sufficient accuracy.
+  //
+  // These two values are copied from Scipy implementation:
+  // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L37
+  var SMALL_RE = 7;
+  var SMALL_IM = 7;
+  /**
+   * The coefficients are B[2*n]/(2*n*(2*n - 1)) where B[2*n] is the (2*n)th Bernoulli number. See (1.1) in [1].
+   *
+   * If you cannot access the paper, can also get these values from the formula in [2].
+   *
+   *    1 /     12 = 0.00833333333333333333333333333333
+   *    1 /    360 = 0.00277777777777777777777777777778
+   * ...
+   * 3617 / 133400 = 0.02955065359477124183006535947712
+   */
+
+  var coeffs = [-2.955065359477124183e-2, 6.4102564102564102564e-3, -1.9175269175269175269e-3, 8.4175084175084175084e-4, -5.952380952380952381e-4, 7.9365079365079365079e-4, -2.7777777777777777778e-3, 8.3333333333333333333e-2];
+  /**
+   * Logarithm of the gamma function for real, positive numbers and complex numbers,
+   * using Lanczos approximation for numbers and Stirling series for complex numbers.
+   *
+   * Syntax:
+   *
+   *    math.lgamma(n)
+   *
+   * Examples:
+   *
+   *    math.lgamma(5)       // returns 3.178053830347945
+   *    math.lgamma(0)       // returns Infinity
+   *    math.lgamma(-0.5)    // returns NaN
+   *    math.lgamma(math.i)  // returns -0.6509231993018536 - 1.8724366472624294i
+   *
+   * See also:
+   *
+   *    gamma
+   *
+   * @param {number | Complex} n   A real or complex number
+   * @return {number | Complex}    The log gamma of `n`
+   */
+
+  return typed(name, {
+    number: lgammaNumber,
+    Complex: function Complex(n) {
+      var TWOPI = 6.2831853071795864769252842; // 2*pi
+
+      var LOGPI = 1.1447298858494001741434262; // log(pi)
+
+      var REFLECTION = 0.1;
+
+      if (n.isNaN()) {
+        return new _Complex(NaN, NaN);
+      } else if (n.im === 0) {
+        return new _Complex(lgammaNumber(n.re), 0);
+      } else if (n.re >= SMALL_RE || Math.abs(n.im) >= SMALL_IM) {
+        return lgammaStirling(n);
+      } else if (n.re <= REFLECTION) {
+        // Reflection formula. see Proposition 3.1 in [1]
+        var tmp = copysign(TWOPI, n.im) * Math.floor(0.5 * n.re + 0.25); // TODO: `complex.js sin` doesn't have extremely high precision, so this value `a` may lose a little precision,
+        // causing the computation results to be less accurate than the lgamma of real numbers
+
+        var a = n.mul(Math.PI).sin().log();
+        var b = this(new _Complex(1 - n.re, -n.im));
+        return new _Complex(LOGPI, tmp).sub(a).sub(b);
+      } else if (n.im >= 0) {
+        return lgammaRecurrence(n);
+      } else {
+        return lgammaRecurrence(n.conjugate()).conjugate();
+      }
+    },
+    BigNumber: function BigNumber() {
+      throw new Error("mathjs doesn't yet provide an implementation of the algorithm lgamma for BigNumber");
+    }
+  });
+
+  function lgammaStirling(z) {
+    // formula ref in [2]
+    // computation ref:
+    // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L101
+    // left part
+    // x (log(x) - 1) + 1/2 (log(2PI) - log(x))
+    // => (x - 0.5) * log(x) - x + log(2PI) / 2
+    var leftPart = z.sub(0.5).mul(z.log()).sub(z).add(lnSqrt2PI); // right part
+
+    var rz = new _Complex(1, 0).div(z);
+    var rzz = rz.div(z);
+    var a = coeffs[0];
+    var b = coeffs[1];
+    var r = 2 * rzz.re;
+    var s = rzz.re * rzz.re + rzz.im * rzz.im;
+
+    for (var i = 2; i < 8; i++) {
+      var tmp = b;
+      b = -s * a + coeffs[i];
+      a = r * a + tmp;
+    }
+
+    var rightPart = rz.mul(rzz.mul(a).add(b)); // plus left and right
+
+    return leftPart.add(rightPart);
+  }
+
+  function lgammaRecurrence(z) {
+    // computation ref:
+    // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L78
+    var signflips = 0;
+    var sb = 0;
+    var shiftprod = z;
+    z = z.add(1);
+
+    while (z.re <= SMALL_RE) {
+      shiftprod = shiftprod.mul(z);
+      var nsb = shiftprod.im < 0 ? 1 : 0;
+      if (nsb !== 0 && sb === 0) signflips++;
+      sb = nsb;
+      z = z.add(1);
+    }
+
+    return lgammaStirling(z).sub(shiftprod.log()).sub(new _Complex(0, signflips * 2 * Math.PI * 1));
+  }
+});

package/dist/node_modules/mathjs/lib/esm/function/probability/multinomial.js

@@ -0,0 +1,52 @@
+import { deepForEach } from '../../utils/collection.js';
+import { factory } from '../../utils/factory.js';
+var name = 'multinomial';
+var dependencies = ['typed', 'add', 'divide', 'multiply', 'factorial', 'isInteger', 'isPositive'];
+export var createMultinomial = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    add,
+    divide,
+    multiply,
+    factorial,
+    isInteger,
+    isPositive
+  } = _ref;
+
+  /**
+   * Multinomial Coefficients compute the number of ways of picking a1, a2, ..., ai unordered outcomes from `n` possibilities.
+   *
+   * multinomial takes one array of integers as an argument.
+   * The following condition must be enforced: every ai <= 0
+   *
+   * Syntax:
+   *
+   *     math.multinomial(a) // a is an array type
+   *
+   * Examples:
+   *
+   *    math.multinomial([1,2,1]) // returns 12
+   *
+   * See also:
+   *
+   *    combinations, factorial
+   *
+   * @param {number[] | BigNumber[]} a    Integer numbers of objects in the subset
+   * @return {Number | BigNumber}         Multinomial coefficient.
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(a) {
+      var sum = 0;
+      var denom = 1;
+      deepForEach(a, function (ai) {
+        if (!isInteger(ai) || !isPositive(ai)) {
+          throw new TypeError('Positive integer value expected in function multinomial');
+        }
+
+        sum = add(sum, ai);
+        denom = multiply(denom, factorial(ai));
+      });
+      return divide(factorial(sum), denom);
+    }
+  });
+});