mathjs 12.4.3 → 13.0.0

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

@@ -5,18 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 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 = exports.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;
+const name = 'kldivergence';
+const dependencies = ['typed', 'matrix', 'divide', 'sum', 'multiply', 'map', 'dotDivide', 'log', 'isNumeric'];
+const createKldivergence = exports.createKldivergence = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    divide,
+    sum,
+    multiply,
+    map,
+    dotDivide,
+    log,
+    isNumeric
+  } = _ref;
   /**
      * Calculate the Kullback-Leibler (KL) divergence  between two distributions
      *
@@ -34,22 +36,22 @@ var createKldivergence = exports.createKldivergence = /* #__PURE__ */(0, _factor
      * @return {number}              Returns distance between q and p
      */
   return typed(name, {
-    'Array, Array': function ArrayArray(q, p) {
+    'Array, Array': function (q, p) {
       return _kldiv(matrix(q), matrix(p));
     },
-    'Matrix, Array': function MatrixArray(q, p) {
+    'Matrix, Array': function (q, p) {
       return _kldiv(q, matrix(p));
     },
-    'Array, Matrix': function ArrayMatrix(q, p) {
+    'Array, Matrix': function (q, p) {
       return _kldiv(matrix(q), p);
     },
-    'Matrix, Matrix': function MatrixMatrix(q, p) {
+    'Matrix, Matrix': function (q, p) {
       return _kldiv(q, p);
     }
   });
   function _kldiv(q, p) {
-    var plength = p.size().length;
-    var qlength = q.size().length;
+    const plength = p.size().length;
+    const qlength = q.size().length;
     if (plength > 1) {
       throw new Error('first object must be one dimensional');
     }
@@ -61,19 +63,17 @@ var createKldivergence = exports.createKldivergence = /* #__PURE__ */(0, _factor
     }
 
     // Before calculation, apply normalization
-    var sumq = sum(q);
+    const sumq = sum(q);
     if (sumq === 0) {
       throw new Error('Sum of elements in first object must be non zero');
     }
-    var sump = sum(p);
+    const 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);
-    })));
+    const qnorm = divide(q, sum(q));
+    const pnorm = divide(p, sum(p));
+    const result = sum(multiply(qnorm, map(dotDivide(qnorm, pnorm), x => log(x))));
     if (isNumeric(result)) {
       return result;
     } else {

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

@@ -14,18 +14,20 @@ var _number = require("../../utils/number.js");
 // [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 = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var Complex = _ref.Complex,
-    typed = _ref.typed;
+const name = 'lgamma';
+const dependencies = ['Complex', 'typed'];
+const createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    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;
+  const SMALL_RE = 7;
+  const 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].
@@ -37,7 +39,7 @@ var createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(n
    * ...
    * 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];
+  const 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,
@@ -64,15 +66,15 @@ var createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(n
   return typed(name, {
     number: _index.lgammaNumber,
     Complex: lgammaComplex,
-    BigNumber: function BigNumber() {
+    BigNumber: function () {
       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)
+    const TWOPI = 6.2831853071795864769252842; // 2*pi
+    const LOGPI = 1.1447298858494001741434262; // log(pi)
 
-    var REFLECTION = 0.1;
+    const REFLECTION = 0.1;
     if (n.isNaN()) {
       return new Complex(NaN, NaN);
     } else if (n.im === 0) {
@@ -81,9 +83,9 @@ var createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(n
       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));
+      const tmp = (0, _number.copysign)(TWOPI, n.im) * Math.floor(0.5 * n.re + 0.25);
+      const a = n.mul(Math.PI).sin().log();
+      const 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);
@@ -100,22 +102,22 @@ var createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(n
 
     // 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);
+    const 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;
+    const rz = new Complex(1, 0).div(z);
+    const rzz = rz.div(z);
+    let a = coeffs[0];
+    let b = coeffs[1];
+    const r = 2 * rzz.re;
+    const s = rzz.re * rzz.re + rzz.im * rzz.im;
+    for (let i = 2; i < 8; i++) {
+      const tmp = b;
       b = -s * a + coeffs[i];
       a = r * a + tmp;
     }
-    var rightPart = rz.mul(rzz.mul(a).add(b));
+    const rightPart = rz.mul(rzz.mul(a).add(b));
 
     // plus left and right
 
@@ -125,13 +127,13 @@ var createLgamma = exports.createLgamma = /* #__PURE__ */(0, _factory.factory)(n
     // 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;
+    let signflips = 0;
+    let sb = 0;
+    let shiftprod = z;
     z = z.add(1);
     while (z.re <= SMALL_RE) {
       shiftprod = shiftprod.mul(z);
-      var nsb = shiftprod.im < 0 ? 1 : 0;
+      const nsb = shiftprod.im < 0 ? 1 : 0;
       if (nsb !== 0 && sb === 0) signflips++;
       sb = nsb;
       z = z.add(1);

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

@@ -6,16 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 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 = exports.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;
+const name = 'multinomial';
+const dependencies = ['typed', 'add', 'divide', 'multiply', 'factorial', 'isInteger', 'isPositive'];
+const createMultinomial = exports.createMultinomial = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    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.
    *
@@ -38,9 +40,9 @@ var createMultinomial = exports.createMultinomial = /* #__PURE__ */(0, _factory.
    * @return {Number | BigNumber}         Multinomial coefficient.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(a) {
-      var sum = 0;
-      var denom = 1;
+    'Array | Matrix': function (a) {
+      let sum = 0;
+      let denom = 1;
       (0, _collection.deepForEach)(a, function (ai) {
         if (!isInteger(ai) || !isPositive(ai)) {
           throw new TypeError('Positive integer value expected in function multinomial');

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

@@ -7,11 +7,13 @@ 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 = exports.createPermutations = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    factorial = _ref.factorial;
+const name = 'permutations';
+const dependencies = ['typed', 'factorial'];
+const createPermutations = exports.createPermutations = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    factorial
+  } = _ref;
   /**
    * Compute the number of ways of obtaining an ordered subset of `k` elements
    * from a set of `n` elements.
@@ -39,7 +41,7 @@ var createPermutations = exports.createPermutations = /* #__PURE__ */(0, _factor
    */
   return typed(name, {
     'number | BigNumber': factorial,
-    'number, number': function numberNumber(n, k) {
+    'number, number': function (n, k) {
       if (!(0, _number.isInteger)(n) || n < 0) {
         throw new TypeError('Positive integer value expected in function permutations');
       }
@@ -52,15 +54,15 @@ var createPermutations = exports.createPermutations = /* #__PURE__ */(0, _factor
       // Permute n objects, k at a time
       return (0, _product.product)(n - k + 1, n);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(n, k) {
-      var result, i;
+    'BigNumber, BigNumber': function (n, k) {
+      let 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);
+      const 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);

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

@@ -8,14 +8,16 @@ 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 = exports.createPickRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    on = _ref.on;
+const name = 'pickRandom';
+const dependencies = ['typed', 'config', '?on'];
+const createPickRandom = exports.createPickRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    on
+  } = _ref;
   // seeded pseudo random number generator
-  var rng = (0, _seededRNG.createRng)(config.randomSeed);
+  let rng = (0, _seededRNG.createRng)(config.randomSeed);
   if (on) {
     on('config', function (curr, prev) {
       if (curr.randomSeed !== prev.randomSeed) {
@@ -60,32 +62,32 @@ var createPickRandom = exports.createPickRandom = /* #__PURE__ */(0, _factory.fa
    *                                   Returns an array with the configured number of elements when number is defined.
    */
   return typed(name, {
-    'Array | Matrix': function ArrayMatrix(possibles) {
+    'Array | Matrix': function (possibles) {
       return _pickRandom(possibles, {});
     },
-    'Array | Matrix, Object': function ArrayMatrixObject(possibles, options) {
+    'Array | Matrix, Object': function (possibles, options) {
       return _pickRandom(possibles, options);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(possibles, number) {
+    'Array | Matrix, number': function (possibles, number) {
       return _pickRandom(possibles, {
-        number: number
+        number
       });
     },
-    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(possibles, weights) {
+    'Array | Matrix, Array | Matrix': function (possibles, weights) {
       return _pickRandom(possibles, {
-        weights: weights
+        weights
       });
     },
-    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(possibles, weights, number) {
+    'Array | Matrix, Array | Matrix, number': function (possibles, weights, number) {
       return _pickRandom(possibles, {
-        number: number,
-        weights: weights
+        number,
+        weights
       });
     },
-    'Array | Matrix, number, Array | Matrix': function ArrayMatrixNumberArrayMatrix(possibles, number, weights) {
+    'Array | Matrix, number, Array | Matrix': function (possibles, number, weights) {
       return _pickRandom(possibles, {
-        number: number,
-        weights: weights
+        number,
+        weights
       });
     }
   });
@@ -101,15 +103,16 @@ var createPickRandom = exports.createPickRandom = /* #__PURE__ */(0, _factory.fa
    * @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';
+    let {
+      number,
+      weights,
+      elementWise = true
+    } = _ref2;
+    const single = typeof number === 'undefined';
     if (single) {
       number = 1;
     }
-    var createMatrix = (0, _is.isMatrix)(possibles) ? possibles.create : (0, _is.isMatrix)(weights) ? weights.create : null;
+    const 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
@@ -118,30 +121,30 @@ var createPickRandom = exports.createPickRandom = /* #__PURE__ */(0, _factory.fa
       possibles = (0, _array.flatten)(possibles);
       weights = (0, _array.flatten)(weights);
     }
-    var totalWeights = 0;
+    let 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++) {
+      for (let 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;
+    const length = possibles.length;
+    const result = [];
+    let 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];
+        let randKey = rng() * totalWeights;
+        for (let i = 0, len = possibles.length; i < len; i++) {
+          randKey -= weights[i];
           if (randKey < 0) {
-            pick = possibles[_i];
+            pick = possibles[i];
             break;
           }
         }

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

@@ -8,14 +8,16 @@ var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
 var _seededRNG = require("./util/seededRNG.js");
 var _randomMatrix2 = require("./util/randomMatrix.js");
-var name = 'random';
-var dependencies = ['typed', 'config', '?on'];
-var createRandom = exports.createRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    on = _ref.on;
+const name = 'random';
+const dependencies = ['typed', 'config', '?on'];
+const createRandom = exports.createRandom = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    on
+  } = _ref;
   // seeded pseudo random number generator
-  var rng = (0, _seededRNG.createRng)(config.randomSeed);
+  let rng = (0, _seededRNG.createRng)(config.randomSeed);
   if (on) {
     on('config', function (curr, prev) {
       if (curr.randomSeed !== prev.randomSeed) {
@@ -55,29 +57,15 @@ var createRandom = exports.createRandom = /* #__PURE__ */(0, _factory.factory)(n
    * @return {number | Array | Matrix} A random number
    */
   return typed(name, {
-    '': function _() {
-      return _random(0, 1);
-    },
-    number: function number(max) {
-      return _random(0, max);
-    },
-    'number, number': function numberNumber(min, max) {
-      return _random(min, max);
-    },
-    'Array | Matrix': function ArrayMatrix(size) {
-      return _randomMatrix(size, 0, 1);
-    },
-    'Array | Matrix, number': function ArrayMatrixNumber(size, max) {
-      return _randomMatrix(size, 0, max);
-    },
-    'Array | Matrix, number, number': function ArrayMatrixNumberNumber(size, min, max) {
-      return _randomMatrix(size, min, max);
-    }
+    '': () => _random(0, 1),
+    number: max => _random(0, max),
+    'number, number': (min, max) => _random(min, max),
+    'Array | Matrix': size => _randomMatrix(size, 0, 1),
+    'Array | Matrix, number': (size, max) => _randomMatrix(size, 0, max),
+    'Array | Matrix, number, number': (size, min, max) => _randomMatrix(size, min, max)
   });
   function _randomMatrix(size, min, max) {
-    var res = (0, _randomMatrix2.randomMatrix)(size.valueOf(), function () {
-      return _random(min, max);
-    });
+    const res = (0, _randomMatrix2.randomMatrix)(size.valueOf(), () => _random(min, max));
     return (0, _is.isMatrix)(size) ? size.create(res) : res;
   }
   function _random(min, max) {
@@ -87,13 +75,15 @@ var createRandom = exports.createRandom = /* #__PURE__ */(0, _factory.factory)(n
 
 // number only implementation of random, no matrix support
 // TODO: there is quite some duplicate code in both createRandom and createRandomNumber, can we improve that?
-var createRandomNumber = exports.createRandomNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', '?on'], function (_ref2) {
-  var typed = _ref2.typed,
-    config = _ref2.config,
-    on = _ref2.on,
-    matrix = _ref2.matrix;
+const createRandomNumber = exports.createRandomNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', '?on'], _ref2 => {
+  let {
+    typed,
+    config,
+    on,
+    matrix
+  } = _ref2;
   // seeded pseudo random number generator1
-  var rng = (0, _seededRNG.createRng)(config.randomSeed);
+  let rng = (0, _seededRNG.createRng)(config.randomSeed);
   if (on) {
     on('config', function (curr, prev) {
       if (curr.randomSeed !== prev.randomSeed) {
@@ -102,15 +92,9 @@ var createRandomNumber = exports.createRandomNumber = /* #__PURE__ */(0, _factor
     });
   }
   return typed(name, {
-    '': function _() {
-      return _random(0, 1);
-    },
-    number: function number(max) {
-      return _random(0, max);
-    },
-    'number, number': function numberNumber(min, max) {
-      return _random(min, max);
-    }
+    '': () => _random(0, 1),
+    number: max => _random(0, max),
+    'number, number': (min, max) => _random(min, max)
   });
   function _random(min, max) {
     return min + rng() * (max - min);

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

@@ -8,14 +8,16 @@ var _factory = require("../../utils/factory.js");
 var _randomMatrix = require("./util/randomMatrix.js");
 var _seededRNG = require("./util/seededRNG.js");
 var _is = require("../../utils/is.js");
-var name = 'randomInt';
-var dependencies = ['typed', 'config', '?on'];
-var createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    on = _ref.on;
+const name = 'randomInt';
+const dependencies = ['typed', 'config', '?on'];
+const createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    on
+  } = _ref;
   // seeded pseudo random number generator
-  var rng = (0, _seededRNG.createRng)(config.randomSeed);
+  let rng = (0, _seededRNG.createRng)(config.randomSeed);
   if (on) {
     on('config', function (curr, prev) {
       if (curr.randomSeed !== prev.randomSeed) {
@@ -54,29 +56,15 @@ var createRandomInt = exports.createRandomInt = /* #__PURE__ */(0, _factory.fact
    * @return {number | Array | Matrix} A random integer value
    */
   return typed(name, {
-    '': function _() {
-      return _randomInt(0, 1);
-    },
-    number: function number(max) {
-      return _randomInt(0, max);
-    },
-    'number, number': function numberNumber(min, max) {
-      return _randomInt(min, max);
-    },
-    'Array | Matrix': function ArrayMatrix(size) {
-      return _randomIntMatrix(size, 0, 1);
-    },
-    'Array | Matrix, number': function ArrayMatrixNumber(size, max) {
-      return _randomIntMatrix(size, 0, max);
-    },
-    'Array | Matrix, number, number': function ArrayMatrixNumberNumber(size, min, max) {
-      return _randomIntMatrix(size, min, max);
-    }
+    '': () => _randomInt(0, 1),
+    number: max => _randomInt(0, max),
+    'number, number': (min, max) => _randomInt(min, max),
+    'Array | Matrix': size => _randomIntMatrix(size, 0, 1),
+    'Array | Matrix, number': (size, max) => _randomIntMatrix(size, 0, max),
+    'Array | Matrix, number, number': (size, min, max) => _randomIntMatrix(size, min, max)
   });
   function _randomIntMatrix(size, min, max) {
-    var res = (0, _randomMatrix.randomMatrix)(size.valueOf(), function () {
-      return _randomInt(min, max);
-    });
+    const res = (0, _randomMatrix.randomMatrix)(size.valueOf(), () => _randomInt(min, max));
     return (0, _is.isMatrix)(size) ? size.create(res) : res;
   }
   function _randomInt(min, max) {

package/lib/cjs/function/probability/util/randomMatrix.js

@@ -11,14 +11,14 @@ exports.randomMatrix = randomMatrix;
  * @returns {Array}
  */
 function randomMatrix(size, random) {
-  var data = [];
+  const data = [];
   size = size.slice(0);
   if (size.length > 1) {
-    for (var i = 0, length = size.shift(); i < length; i++) {
+    for (let i = 0, length = size.shift(); i < length; i++) {
       data.push(randomMatrix(size, random));
     }
   } else {
-    for (var _i = 0, _length = size.shift(); _i < _length; _i++) {
+    for (let i = 0, length = size.shift(); i < length; i++) {
       data.push(random());
     }
   }

package/lib/cjs/function/probability/util/seededRNG.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createRng = createRng;
 var _seedrandom = _interopRequireDefault(require("seedrandom"));
-var singletonRandom = /* #__PURE__ */(0, _seedrandom["default"])(Date.now());
+const singletonRandom = /* #__PURE__ */(0, _seedrandom.default)(Date.now());
 function createRng(randomSeed) {
-  var random;
+  let random;
 
   // create a new random generator with given seed
   function setSeed(seed) {
-    random = seed === null ? singletonRandom : (0, _seedrandom["default"])(String(seed));
+    random = seed === null ? singletonRandom : (0, _seedrandom.default)(String(seed));
   }
 
   // initialize a seeded pseudo random number generator with config's random seed