mathjs-min 11.7.2

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

@@ -0,0 +1,50 @@
+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);
+    }
+  });
+});

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

@@ -0,0 +1,78 @@
+import { isInteger } from '../../utils/number.js';
+import { product } from '../../utils/product.js';
+import { factory } from '../../utils/factory.js';
+var name = 'permutations';
+var dependencies = ['typed', 'factorial'];
+export var createPermutations = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    factorial
+  } = _ref;
+  /**
+   * 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 (!isInteger(n) || n < 0) {
+        throw new TypeError('Positive integer value expected in function permutations');
+      }
+      if (!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 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
+ */
+function isPositiveInteger(n) {
+  return n.isInteger() && n.gte(0);
+}

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

@@ -0,0 +1,151 @@
+import { flatten } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { isMatrix, isNumber } from '../../utils/is.js';
+import { createRng } from './util/seededRNG.js';
+var name = 'pickRandom';
+var dependencies = ['typed', 'config', '?on'];
+export var createPickRandom = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    on
+  } = _ref;
+  // seeded pseudo random number generator
+  var rng = createRng(config.randomSeed);
+  if (on) {
+    on('config', function (curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = 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
+      });
+    },
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(possibles, weights) {
+      return _pickRandom(possibles, {
+        weights
+      });
+    },
+    'Array | Matrix, Array | Matrix, number': function ArrayMatrixArrayMatrixNumber(possibles, weights, number) {
+      return _pickRandom(possibles, {
+        number,
+        weights
+      });
+    },
+    'Array | Matrix, number, Array | Matrix': function ArrayMatrixNumberArrayMatrix(possibles, number, weights) {
+      return _pickRandom(possibles, {
+        number,
+        weights
+      });
+    }
+  });
+
+  /**
+   * @param {Array | Matrix} possibles
+   * @param {{
+   *   number?: number,
+   *   weights?: Array | Matrix,
+   *   elementWise: boolean
+   * }} options
+   * @returns {number | Array}
+   * @private
+   */
+  function _pickRandom(possibles, _ref2) {
+    var {
+      number,
+      weights,
+      elementWise = true
+    } = _ref2;
+    var single = typeof number === 'undefined';
+    if (single) {
+      number = 1;
+    }
+    var createMatrix = isMatrix(possibles) ? possibles.create : isMatrix(weights) ? weights.create : null;
+    possibles = possibles.valueOf(); // get Array
+    if (weights) {
+      weights = weights.valueOf(); // get Array
+    }
+
+    if (elementWise === true) {
+      possibles = flatten(possibles);
+      weights = 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 (!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;
+  }
+});

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

@@ -0,0 +1,96 @@
+import { factory } from '../../utils/factory.js';
+import { isMatrix } from '../../utils/is.js';
+import { createRng } from './util/seededRNG.js';
+import { randomMatrix } from './util/randomMatrix.js';
+var name = 'random';
+var dependencies = ['typed', 'config', '?on'];
+export var createRandom = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    on
+  } = _ref;
+  // seeded pseudo random number generator
+  var rng = createRng(config.randomSeed);
+  if (on) {
+    on('config', function (curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = createRng(curr.randomSeed);
+      }
+    });
+  }
+
+  /**
+   * Return a random number larger or equal to `min` and smaller than `max`
+   * using a uniform distribution.
+   *
+   * Syntax:
+   *
+   *     math.random()                // generate a random number between 0 and 1
+   *     math.random(max)             // generate a random number between 0 and max
+   *     math.random(min, max)        // generate a random number between min and max
+   *     math.random(size)            // generate a matrix with random numbers between 0 and 1
+   *     math.random(size, max)       // generate a matrix with random numbers between 0 and max
+   *     math.random(size, min, max)  // generate a matrix with random numbers between min and max
+   *
+   * Examples:
+   *
+   *     math.random()       // returns a random number between 0 and 1
+   *     math.random(100)    // returns a random number between 0 and 100
+   *     math.random(30, 40) // returns a random number between 30 and 40
+   *     math.random([2, 3]) // returns a 2x3 matrix with random numbers between 0 and 1
+   *
+   * See also:
+   *
+   *     randomInt, pickRandom
+   *
+   * @param {Array | Matrix} [size] If provided, an array or matrix with given
+   *                                size and filled with random values is returned
+   * @param {number} [min]  Minimum boundary for the random value, included
+   * @param {number} [max]  Maximum boundary for the random value, excluded
+   * @return {number | Array | Matrix} A random number
+   */
+  return typed(name, {
+    '': () => _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 = randomMatrix(size.valueOf(), () => _random(min, max));
+    return isMatrix(size) ? size.create(res) : res;
+  }
+  function _random(min, max) {
+    return min + rng() * (max - min);
+  }
+});
+
+// number only implementation of random, no matrix support
+// TODO: there is quite some duplicate code in both createRandom and createRandomNumber, can we improve that?
+export var createRandomNumber = /* #__PURE__ */factory(name, ['typed', 'config', '?on'], _ref2 => {
+  var {
+    typed,
+    config,
+    on,
+    matrix
+  } = _ref2;
+  // seeded pseudo random number generator1
+  var rng = createRng(config.randomSeed);
+  if (on) {
+    on('config', function (curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = createRng(curr.randomSeed);
+      }
+    });
+  }
+  return typed(name, {
+    '': () => _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/esm/function/probability/randomInt.js

@@ -0,0 +1,67 @@
+import { factory } from '../../utils/factory.js';
+import { randomMatrix } from './util/randomMatrix.js';
+import { createRng } from './util/seededRNG.js';
+import { isMatrix } from '../../utils/is.js';
+var name = 'randomInt';
+var dependencies = ['typed', 'config', '?on'];
+export var createRandomInt = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    on
+  } = _ref;
+  // seeded pseudo random number generator
+  var rng = createRng(config.randomSeed);
+  if (on) {
+    on('config', function (curr, prev) {
+      if (curr.randomSeed !== prev.randomSeed) {
+        rng = createRng(curr.randomSeed);
+      }
+    });
+  }
+
+  /**
+   * Return a random integer number larger or equal to `min` and smaller than `max`
+   * using a uniform distribution.
+   *
+   * Syntax:
+   *
+   *     math.randomInt()                // generate a random integer between 0 and 1
+   *     math.randomInt(max)             // generate a random integer between 0 and max
+   *     math.randomInt(min, max)        // generate a random integer between min and max
+   *     math.randomInt(size)            // generate a matrix with random integer between 0 and 1
+   *     math.randomInt(size, max)       // generate a matrix with random integer between 0 and max
+   *     math.randomInt(size, min, max)  // generate a matrix with random integer between min and max
+   *
+   * Examples:
+   *
+   *     math.randomInt(100)    // returns a random integer between 0 and 100
+   *     math.randomInt(30, 40) // returns a random integer between 30 and 40
+   *     math.randomInt([2, 3]) // returns a 2x3 matrix with random integers between 0 and 1
+   *
+   * See also:
+   *
+   *     random, pickRandom
+   *
+   * @param {Array | Matrix} [size] If provided, an array or matrix with given
+   *                                size and filled with random values is returned
+   * @param {number} [min]  Minimum boundary for the random value, included
+   * @param {number} [max]  Maximum boundary for the random value, excluded
+   * @return {number | Array | Matrix} A random integer value
+   */
+  return typed(name, {
+    '': () => _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 = randomMatrix(size.valueOf(), () => _randomInt(min, max));
+    return isMatrix(size) ? size.create(res) : res;
+  }
+  function _randomInt(min, max) {
+    return Math.floor(min + rng() * (max - min));
+  }
+});

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

@@ -0,0 +1,20 @@
+/**
+ * This is a util function for generating a random matrix recursively.
+ * @param {number[]} size
+ * @param {function} random
+ * @returns {Array}
+ */
+export function randomMatrix(size, random) {
+  var data = [];
+  size = size.slice(0);
+  if (size.length > 1) {
+    for (var i = 0, length = size.shift(); i < length; i++) {
+      data.push(randomMatrix(size, random));
+    }
+  } else {
+    for (var _i = 0, _length = size.shift(); _i < _length; _i++) {
+      data.push(random());
+    }
+  }
+  return data;
+}

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

@@ -0,0 +1,19 @@
+import seedrandom from 'seedrandom';
+var singletonRandom = /* #__PURE__ */seedrandom(Date.now());
+export function createRng(randomSeed) {
+  var random;
+
+  // create a new random generator with given seed
+  function setSeed(seed) {
+    random = seed === null ? singletonRandom : seedrandom(String(seed));
+  }
+
+  // initialize a seeded pseudo random number generator with config's random seed
+  setSeed(randomSeed);
+
+  // wrapper function so the rng can be updated via generator
+  function rng() {
+    return random();
+  }
+  return rng;
+}

package/lib/esm/function/relational/compare.js

@@ -0,0 +1,111 @@
+import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
+import { nearlyEqual } from '../../utils/number.js';
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo05xSfSf } from '../../type/matrix/utils/matAlgo05xSfSf.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+import { createCompareUnits } from './compareUnits.js';
+var name = 'compare';
+var dependencies = ['typed', 'config', 'matrix', 'equalScalar', 'BigNumber', 'Fraction', 'DenseMatrix', 'concat'];
+export var createCompare = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    equalScalar,
+    matrix,
+    BigNumber,
+    Fraction,
+    DenseMatrix,
+    concat
+  } = _ref;
+  var matAlgo03xDSf = createMatAlgo03xDSf({
+    typed
+  });
+  var matAlgo05xSfSf = createMatAlgo05xSfSf({
+    typed,
+    equalScalar
+  });
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+  var compareUnits = createCompareUnits({
+    typed
+  });
+
+  /**
+   * Compare two values. Returns 1 when x > y, -1 when x < y, and 0 when x == y.
+   *
+   * x and y are considered equal when the relative difference between x and y
+   * is smaller than the configured epsilon. The function cannot be used to
+   * compare values smaller than approximately 2.22e-16.
+   *
+   * For matrices, the function is evaluated element wise.
+   * Strings are compared by their numerical value.
+   *
+   * Syntax:
+   *
+   *    math.compare(x, y)
+   *
+   * Examples:
+   *
+   *    math.compare(6, 1)           // returns 1
+   *    math.compare(2, 3)           // returns -1
+   *    math.compare(7, 7)           // returns 0
+   *    math.compare('10', '2')      // returns 1
+   *    math.compare('1000', '1e3')  // returns 0
+   *
+   *    const a = math.unit('5 cm')
+   *    const b = math.unit('40 mm')
+   *    math.compare(a, b)           // returns 1
+   *
+   *    math.compare(2, [1, 2, 3])   // returns [1, 0, -1]
+   *
+   * See also:
+   *
+   *    equal, unequal, smaller, smallerEq, larger, largerEq, compareNatural, compareText
+   *
+   * @param  {number | BigNumber | Fraction | Unit | string | Array | Matrix} x First value to compare
+   * @param  {number | BigNumber | Fraction | Unit | string | Array | Matrix} y Second value to compare
+   * @return {number | BigNumber | Fraction | Array | Matrix} Returns the result of the comparison:
+   *                                                          1 when x > y, -1 when x < y, and 0 when x == y.
+   */
+  return typed(name, createCompareNumber({
+    typed,
+    config
+  }), {
+    'boolean, boolean': function booleanBoolean(x, y) {
+      return x === y ? 0 : x > y ? 1 : -1;
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return bigNearlyEqual(x, y, config.epsilon) ? new BigNumber(0) : new BigNumber(x.cmp(y));
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return new Fraction(x.compare(y));
+    },
+    'Complex, Complex': function ComplexComplex() {
+      throw new TypeError('No ordering relation is defined for complex numbers');
+    }
+  }, compareUnits, matrixAlgorithmSuite({
+    SS: matAlgo05xSfSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo12xSfs
+  }));
+});
+export var createCompareNumber = /* #__PURE__ */factory(name, ['typed', 'config'], _ref2 => {
+  var {
+    typed,
+    config
+  } = _ref2;
+  return typed(name, {
+    'number, number': function numberNumber(x, y) {
+      return nearlyEqual(x, y, config.epsilon) ? 0 : x > y ? 1 : -1;
+    }
+  });
+});