mathjs-min 11.7.2

package/lib/cjs/function/probability/gamma.js

@@ -0,0 +1,125 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGamma = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'gamma';
+var dependencies = ['typed', 'config', 'multiplyScalar', 'pow', 'BigNumber', 'Complex'];
+var createGamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    multiplyScalar = _ref.multiplyScalar,
+    pow = _ref.pow,
+    _BigNumber = _ref.BigNumber,
+    Complex = _ref.Complex;
+  /**
+   * Compute the gamma function of a value using Lanczos approximation for
+   * small values, and an extended Stirling approximation for large values.
+   *
+   * To avoid confusion with the matrix Gamma function, this function does
+   * not apply to matrices.
+   *
+   * 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 | BigNumber | Complex} n   A real or complex number
+   * @return {number | BigNumber | Complex}    The gamma of `n`
+   */
+
+  function gammaComplex(n) {
+    if (n.im === 0) {
+      return (0, _index.gammaNumber)(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(gammaComplex(_t));
+    }
+
+    // Lanczos approximation
+    // z -= 1
+    n = new Complex(n.re - 1, n.im);
+
+    // x = gammaPval[0]
+    var x = new Complex(_index.gammaP[0], 0);
+    // for (i, gammaPval) in enumerate(gammaP):
+    for (var i = 1; i < _index.gammaP.length; ++i) {
+      // x += gammaPval / (z + i)
+      var gammaPval = new Complex(_index.gammaP[i], 0);
+      x = x.add(gammaPval.div(n.add(i)));
+    }
+    // t = z + gammaG + 0.5
+    var t = new Complex(n.re + _index.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);
+  }
+  return typed(name, {
+    number: _index.gammaNumber,
+    Complex: gammaComplex,
+    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');
+    }
+  });
+
+  /**
+   * 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: 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));
+  }
+});
+exports.createGamma = createGamma;

package/lib/cjs/function/probability/kldivergence.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createKldivergence = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'kldivergence';
+var dependencies = ['typed', 'matrix', 'divide', 'sum', 'multiply', 'map', 'dotDivide', 'log', 'isNumeric'];
+var createKldivergence = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    divide = _ref.divide,
+    sum = _ref.sum,
+    multiply = _ref.multiply,
+    map = _ref.map,
+    dotDivide = _ref.dotDivide,
+    log = _ref.log,
+    isNumeric = _ref.isNumeric;
+  /**
+     * 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, map(dotDivide(qnorm, pnorm), function (x) {
+      return log(x);
+    })));
+    if (isNumeric(result)) {
+      return result;
+    } else {
+      return Number.NaN;
+    }
+  }
+});
+exports.createKldivergence = createKldivergence;

package/lib/cjs/function/probability/lgamma.js

@@ -0,0 +1,142 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLgamma = void 0;
+var _index = require("../../plain/number/index.js");
+var _factory = require("../../utils/factory.js");
+var _number = require("../../utils/number.js");
+/* 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
+
+var name = 'lgamma';
+var dependencies = ['Complex', 'typed'];
+var createLgamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var Complex = _ref.Complex,
+    typed = _ref.typed;
+  // 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: _index.lgammaNumber,
+    Complex: lgammaComplex,
+    BigNumber: function BigNumber() {
+      throw new Error("mathjs doesn't yet provide an implementation of the algorithm lgamma for BigNumber");
+    }
+  });
+  function lgammaComplex(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((0, _index.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 = (0, _number.copysign)(TWOPI, n.im) * Math.floor(0.5 * n.re + 0.25);
+      var a = n.mul(Math.PI).sin().log();
+      var b = lgammaComplex(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();
+    }
+  }
+  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(_index.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));
+  }
+});
+exports.createLgamma = createLgamma;

package/lib/cjs/function/probability/multinomial.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMultinomial = void 0;
+var _collection = require("../../utils/collection.js");
+var _factory = require("../../utils/factory.js");
+var name = 'multinomial';
+var dependencies = ['typed', 'add', 'divide', 'multiply', 'factorial', 'isInteger', 'isPositive'];
+var createMultinomial = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    add = _ref.add,
+    divide = _ref.divide,
+    multiply = _ref.multiply,
+    factorial = _ref.factorial,
+    isInteger = _ref.isInteger,
+    isPositive = _ref.isPositive;
+  /**
+   * 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;
+      (0, _collection.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);
+    }
+  });
+});
+exports.createMultinomial = createMultinomial;

package/lib/cjs/function/probability/permutations.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPermutations = void 0;
+var _number = require("../../utils/number.js");
+var _product = require("../../utils/product.js");
+var _factory = require("../../utils/factory.js");
+var name = 'permutations';
+var dependencies = ['typed', 'factorial'];
+var createPermutations = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    factorial = _ref.factorial;
+  /**
+   * Compute the number of ways of obtaining an ordered subset of `k` elements
+   * from a set of `n` elements.
+   *
+   * Permutations only takes integer arguments.
+   * The following condition must be enforced: k <= n.
+   *
+   * Syntax:
+   *
+   *     math.permutations(n)
+   *     math.permutations(n, k)
+   *
+   * Examples:
+   *
+   *    math.permutations(5)     // 120
+   *    math.permutations(5, 3)  // 60
+   *
+   * See also:
+   *
+   *    combinations, combinationsWithRep, factorial
+   *
+   * @param {number | BigNumber} n   The number of objects in total
+   * @param {number | BigNumber} [k] The number of objects in the subset
+   * @return {number | BigNumber}    The number of permutations
+   */
+  return typed(name, {
+    'number | BigNumber': factorial,
+    'number, number': function numberNumber(n, k) {
+      if (!(0, _number.isInteger)(n) || n < 0) {
+        throw new TypeError('Positive integer value expected in function permutations');
+      }
+      if (!(0, _number.isInteger)(k) || k < 0) {
+        throw new TypeError('Positive integer value expected in function permutations');
+      }
+      if (k > n) {
+        throw new TypeError('second argument k must be less than or equal to first argument n');
+      }
+      // Permute n objects, k at a time
+      return (0, _product.product)(n - k + 1, n);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
+      var result, i;
+      if (!isPositiveInteger(n) || !isPositiveInteger(k)) {
+        throw new TypeError('Positive integer value expected in function permutations');
+      }
+      if (k.gt(n)) {
+        throw new TypeError('second argument k must be less than or equal to first argument n');
+      }
+      var one = n.mul(0).add(1);
+      result = one;
+      for (i = n.minus(k).plus(1); i.lte(n); i = i.plus(1)) {
+        result = result.times(i);
+      }
+      return result;
+    }
+
+    // TODO: implement support for collection in permutations
+  });
+});
+
+/**
+ * Test whether BigNumber n is a positive integer
+ * @param {BigNumber} n
+ * @returns {boolean} isPositiveInteger
+ */
+exports.createPermutations = createPermutations;
+function isPositiveInteger(n) {
+  return n.isInteger() && n.gte(0);
+}

package/lib/cjs/function/probability/pickRandom.js

@@ -0,0 +1,155 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPickRandom = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _seededRNG = require("./util/seededRNG.js");
+var name = 'pickRandom';
+var dependencies = ['typed', 'config', '?on'];
+var createPickRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    on = _ref.on;
+  // seeded pseudo random number generator
+  var rng = (0, _seededRNG.createRng)(config.randomSeed);
+  if (on) {
+    on('config', function (curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = (0, _seededRNG.createRng)(curr.randomSeed);
+      }
+    });
+  }
+
+  /**
+   * Random pick one or more values from a one dimensional array.
+   * Array elements are picked using a random function with uniform or weighted distribution.
+   *
+   * Syntax:
+   *
+   *     math.pickRandom(array)
+   *     math.pickRandom(array, number)
+   *     math.pickRandom(array, weights)
+   *     math.pickRandom(array, number, weights)
+   *     math.pickRandom(array, weights, number)
+   *     math.pickRandom(array, { weights, number, elementWise })
+   *
+   * Examples:
+   *
+   *     math.pickRandom([3, 6, 12, 2])                  // returns one of the values in the array
+   *     math.pickRandom([3, 6, 12, 2], 2)               // returns an array of two of the values in the array
+   *     math.pickRandom([3, 6, 12, 2], { number: 2 })   // returns an array of two of the values in the array
+   *     math.pickRandom([3, 6, 12, 2], [1, 3, 2, 1])    // returns one of the values in the array with weighted distribution
+   *     math.pickRandom([3, 6, 12, 2], 2, [1, 3, 2, 1]) // returns an array of two of the values in the array with weighted distribution
+   *     math.pickRandom([3, 6, 12, 2], [1, 3, 2, 1], 2) // returns an array of two of the values in the array with weighted distribution
+   *
+   *     math.pickRandom([{x: 1.0, y: 2.0}, {x: 1.1, y: 2.0}], { elementWise: false })
+   *         // returns one of the items in the array
+   *
+   * See also:
+   *
+   *     random, randomInt
+   *
+   * @param {Array | Matrix} array     A one dimensional array
+   * @param {Int} number               An int or float
+   * @param {Array | Matrix} weights   An array of ints or floats
+   * @return {number | Array}          Returns a single random value from array when number is 1 or undefined.
+   *                                   Returns an array with the configured number of elements when number is > 1.
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(possibles) {
+      return _pickRandom(possibles, {});
+    },
+    'Array | Matrix, Object': function ArrayMatrixObject(possibles, options) {
+      return _pickRandom(possibles, options);
+    },
+    'Array | Matrix, number': function ArrayMatrixNumber(possibles, number) {
+      return _pickRandom(possibles, {
+        number: number
+      });
+    },
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(possibles, weights) {
+      return _pickRandom(possibles, {
+        weights: weights
+      });
+    },
+    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(possibles, weights, number) {
+      return _pickRandom(possibles, {
+        number: number,
+        weights: weights
+      });
+    },
+    'Array | Matrix, number, Array | Matrix': function ArrayMatrixNumberArrayMatrix(possibles, number, weights) {
+      return _pickRandom(possibles, {
+        number: number,
+        weights: weights
+      });
+    }
+  });
+
+  /**
+   * @param {Array | Matrix} possibles
+   * @param {{
+   *   number?: number,
+   *   weights?: Array | Matrix,
+   *   elementWise: boolean
+   * }} options
+   * @returns {number | Array}
+   * @private
+   */
+  function _pickRandom(possibles, _ref2) {
+    var number = _ref2.number,
+      weights = _ref2.weights,
+      _ref2$elementWise = _ref2.elementWise,
+      elementWise = _ref2$elementWise === void 0 ? true : _ref2$elementWise;
+    var single = typeof number === 'undefined';
+    if (single) {
+      number = 1;
+    }
+    var createMatrix = (0, _is.isMatrix)(possibles) ? possibles.create : (0, _is.isMatrix)(weights) ? weights.create : null;
+    possibles = possibles.valueOf(); // get Array
+    if (weights) {
+      weights = weights.valueOf(); // get Array
+    }
+
+    if (elementWise === true) {
+      possibles = (0, _array.flatten)(possibles);
+      weights = (0, _array.flatten)(weights);
+    }
+    var totalWeights = 0;
+    if (typeof weights !== 'undefined') {
+      if (weights.length !== possibles.length) {
+        throw new Error('Weights must have the same length as possibles');
+      }
+      for (var i = 0, len = weights.length; i < len; i++) {
+        if (!(0, _is.isNumber)(weights[i]) || weights[i] < 0) {
+          throw new Error('Weights must be an array of positive numbers');
+        }
+        totalWeights += weights[i];
+      }
+    }
+    var length = possibles.length;
+    var result = [];
+    var pick;
+    while (result.length < number) {
+      if (typeof weights === 'undefined') {
+        pick = possibles[Math.floor(rng() * length)];
+      } else {
+        var randKey = rng() * totalWeights;
+        for (var _i = 0, _len = possibles.length; _i < _len; _i++) {
+          randKey -= weights[_i];
+          if (randKey < 0) {
+            pick = possibles[_i];
+            break;
+          }
+        }
+      }
+      result.push(pick);
+    }
+    return single ? result[0] : createMatrix ? createMatrix(result) : result;
+  }
+});
+exports.createPickRandom = createPickRandom;