mathjs-min 11.7.2

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

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRandomNumber = exports.createRandom = void 0;
+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 = /* #__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);
+      }
+    });
+  }
+
+  /**
+   * 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, {
+    '': 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);
+    }
+  });
+  function _randomMatrix(size, min, max) {
+    var res = (0, _randomMatrix2.randomMatrix)(size.valueOf(), function () {
+      return _random(min, max);
+    });
+    return (0, _is.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?
+exports.createRandom = createRandom;
+var createRandomNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', '?on'], function (_ref2) {
+  var typed = _ref2.typed,
+    config = _ref2.config,
+    on = _ref2.on,
+    matrix = _ref2.matrix;
+  // seeded pseudo random number generator1
+  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);
+      }
+    });
+  }
+  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);
+    }
+  });
+  function _random(min, max) {
+    return min + rng() * (max - min);
+  }
+});
+exports.createRandomNumber = createRandomNumber;

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

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRandomInt = void 0;
+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 = /* #__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);
+      }
+    });
+  }
+
+  /**
+   * 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, {
+    '': 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);
+    }
+  });
+  function _randomIntMatrix(size, min, max) {
+    var res = (0, _randomMatrix.randomMatrix)(size.valueOf(), function () {
+      return _randomInt(min, max);
+    });
+    return (0, _is.isMatrix)(size) ? size.create(res) : res;
+  }
+  function _randomInt(min, max) {
+    return Math.floor(min + rng() * (max - min));
+  }
+});
+exports.createRandomInt = createRandomInt;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randomMatrix = randomMatrix;
+/**
+ * This is a util function for generating a random matrix recursively.
+ * @param {number[]} size
+ * @param {function} random
+ * @returns {Array}
+ */
+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/cjs/function/probability/util/seededRNG.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRng = createRng;
+var _seedrandom = _interopRequireDefault(require("seedrandom"));
+var singletonRandom = /* #__PURE__ */(0, _seedrandom["default"])(Date.now());
+function createRng(randomSeed) {
+  var random;
+
+  // create a new random generator with given seed
+  function setSeed(seed) {
+    random = seed === null ? singletonRandom : (0, _seedrandom["default"])(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/cjs/function/relational/compare.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCompareNumber = exports.createCompare = void 0;
+var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
+var _number = require("../../utils/number.js");
+var _factory = require("../../utils/factory.js");
+var _matAlgo03xDSf = require("../../type/matrix/utils/matAlgo03xDSf.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matAlgo05xSfSf = require("../../type/matrix/utils/matAlgo05xSfSf.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var _compareUnits = require("./compareUnits.js");
+var name = 'compare';
+var dependencies = ['typed', 'config', 'matrix', 'equalScalar', 'BigNumber', 'Fraction', 'DenseMatrix', 'concat'];
+var createCompare = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    equalScalar = _ref.equalScalar,
+    matrix = _ref.matrix,
+    BigNumber = _ref.BigNumber,
+    Fraction = _ref.Fraction,
+    DenseMatrix = _ref.DenseMatrix,
+    concat = _ref.concat;
+  var matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
+    typed: typed
+  });
+  var matAlgo05xSfSf = (0, _matAlgo05xSfSf.createMatAlgo05xSfSf)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
+  });
+  var compareUnits = (0, _compareUnits.createCompareUnits)({
+    typed: 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: typed,
+    config: config
+  }), {
+    'boolean, boolean': function booleanBoolean(x, y) {
+      return x === y ? 0 : x > y ? 1 : -1;
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return (0, _nearlyEqual.nearlyEqual)(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
+  }));
+});
+exports.createCompare = createCompare;
+var createCompareNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config'], function (_ref2) {
+  var typed = _ref2.typed,
+    config = _ref2.config;
+  return typed(name, {
+    'number, number': function numberNumber(x, y) {
+      return (0, _number.nearlyEqual)(x, y, config.epsilon) ? 0 : x > y ? 1 : -1;
+    }
+  });
+});
+exports.createCompareNumber = createCompareNumber;

package/lib/cjs/function/relational/compareNatural.js

@@ -0,0 +1,280 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCompareNatural = void 0;
+var _javascriptNaturalSort = _interopRequireDefault(require("javascript-natural-sort"));
+var _is = require("../../utils/is.js");
+var _factory = require("../../utils/factory.js");
+var name = 'compareNatural';
+var dependencies = ['typed', 'compare'];
+var createCompareNatural = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    compare = _ref.compare;
+  var compareBooleans = compare.signatures['boolean,boolean'];
+
+  /**
+   * Compare two values of any type in a deterministic, natural way.
+   *
+   * For numeric values, the function works the same as `math.compare`.
+   * For types of values that can't be compared mathematically,
+   * the function compares in a natural way.
+   *
+   * For numeric values, 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 Complex numbers, first the real parts are compared. If equal,
+   * the imaginary parts are compared.
+   *
+   * Strings are compared with a natural sorting algorithm, which
+   * orders strings in a "logic" way following some heuristics.
+   * This differs from the function `compare`, which converts the string
+   * into a numeric value and compares that. The function `compareText`
+   * on the other hand compares text lexically.
+   *
+   * Arrays and Matrices are compared value by value until there is an
+   * unequal pair of values encountered. Objects are compared by sorted
+   * keys until the keys or their values are unequal.
+   *
+   * Syntax:
+   *
+   *    math.compareNatural(x, y)
+   *
+   * Examples:
+   *
+   *    math.compareNatural(6, 1)              // returns 1
+   *    math.compareNatural(2, 3)              // returns -1
+   *    math.compareNatural(7, 7)              // returns 0
+   *
+   *    math.compareNatural('10', '2')         // returns 1
+   *    math.compareText('10', '2')            // returns -1
+   *    math.compare('10', '2')                // returns 1
+   *
+   *    math.compareNatural('Answer: 10', 'Answer: 2') // returns 1
+   *    math.compareText('Answer: 10', 'Answer: 2')    // returns -1
+   *    math.compare('Answer: 10', 'Answer: 2')
+   *        // Error: Cannot convert "Answer: 10" to a number
+   *
+   *    const a = math.unit('5 cm')
+   *    const b = math.unit('40 mm')
+   *    math.compareNatural(a, b)              // returns 1
+   *
+   *    const c = math.complex('2 + 3i')
+   *    const d = math.complex('2 + 4i')
+   *    math.compareNatural(c, d)              // returns -1
+   *
+   *    math.compareNatural([1, 2, 4], [1, 2, 3]) // returns 1
+   *    math.compareNatural([1, 2, 3], [1, 2])    // returns 1
+   *    math.compareNatural([1, 5], [1, 2, 3])    // returns 1
+   *    math.compareNatural([1, 2], [1, 2])       // returns 0
+   *
+   *    math.compareNatural({a: 2}, {a: 4})       // returns -1
+   *
+   * See also:
+   *
+   *    compare, compareText
+   *
+   * @param  {*} x First value to compare
+   * @param  {*} y Second value to compare
+   * @return {number} Returns the result of the comparison:
+   *                  1 when x > y, -1 when x < y, and 0 when x == y.
+   */
+  return typed(name, {
+    'any, any': _compareNatural
+  }); // just to check # args
+
+  function _compareNatural(x, y) {
+    var typeX = (0, _is.typeOf)(x);
+    var typeY = (0, _is.typeOf)(y);
+    var c;
+
+    // numeric types
+    if ((typeX === 'number' || typeX === 'BigNumber' || typeX === 'Fraction') && (typeY === 'number' || typeY === 'BigNumber' || typeY === 'Fraction')) {
+      c = compare(x, y);
+      if (c.toString() !== '0') {
+        // c can be number, BigNumber, or Fraction
+        return c > 0 ? 1 : -1; // return a number
+      } else {
+        return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+      }
+    }
+
+    // matrix types
+    var matTypes = ['Array', 'DenseMatrix', 'SparseMatrix'];
+    if (matTypes.includes(typeX) || matTypes.includes(typeY)) {
+      c = compareMatricesAndArrays(_compareNatural, x, y);
+      if (c !== 0) {
+        return c;
+      } else {
+        return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+      }
+    }
+
+    // in case of different types, order by name of type, i.e. 'BigNumber' < 'Complex'
+    if (typeX !== typeY) {
+      return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+    }
+    if (typeX === 'Complex') {
+      return compareComplexNumbers(x, y);
+    }
+    if (typeX === 'Unit') {
+      if (x.equalBase(y)) {
+        return _compareNatural(x.value, y.value);
+      }
+
+      // compare by units
+      return compareArrays(_compareNatural, x.formatUnits(), y.formatUnits());
+    }
+    if (typeX === 'boolean') {
+      return compareBooleans(x, y);
+    }
+    if (typeX === 'string') {
+      return (0, _javascriptNaturalSort["default"])(x, y);
+    }
+    if (typeX === 'Object') {
+      return compareObjects(_compareNatural, x, y);
+    }
+    if (typeX === 'null') {
+      return 0;
+    }
+    if (typeX === 'undefined') {
+      return 0;
+    }
+
+    // this should not occur...
+    throw new TypeError('Unsupported type of value "' + typeX + '"');
+  }
+
+  /**
+   * Compare mixed matrix/array types, by converting to same-shaped array.
+   * This comparator is non-deterministic regarding input types.
+   * @param {Array | SparseMatrix | DenseMatrix | *} x
+   * @param {Array | SparseMatrix | DenseMatrix | *} y
+   * @returns {number} Returns the comparison result: -1, 0, or 1
+   */
+  function compareMatricesAndArrays(compareNatural, x, y) {
+    if ((0, _is.isSparseMatrix)(x) && (0, _is.isSparseMatrix)(y)) {
+      return compareArrays(compareNatural, x.toJSON().values, y.toJSON().values);
+    }
+    if ((0, _is.isSparseMatrix)(x)) {
+      // note: convert to array is expensive
+      return compareMatricesAndArrays(compareNatural, x.toArray(), y);
+    }
+    if ((0, _is.isSparseMatrix)(y)) {
+      // note: convert to array is expensive
+      return compareMatricesAndArrays(compareNatural, x, y.toArray());
+    }
+
+    // convert DenseArray into Array
+    if ((0, _is.isDenseMatrix)(x)) {
+      return compareMatricesAndArrays(compareNatural, x.toJSON().data, y);
+    }
+    if ((0, _is.isDenseMatrix)(y)) {
+      return compareMatricesAndArrays(compareNatural, x, y.toJSON().data);
+    }
+
+    // convert scalars to array
+    if (!Array.isArray(x)) {
+      return compareMatricesAndArrays(compareNatural, [x], y);
+    }
+    if (!Array.isArray(y)) {
+      return compareMatricesAndArrays(compareNatural, x, [y]);
+    }
+    return compareArrays(compareNatural, x, y);
+  }
+
+  /**
+   * Compare two Arrays
+   *
+   * - First, compares value by value
+   * - Next, if all corresponding values are equal,
+   *   look at the length: longest array will be considered largest
+   *
+   * @param {Array} x
+   * @param {Array} y
+   * @returns {number} Returns the comparison result: -1, 0, or 1
+   */
+  function compareArrays(compareNatural, x, y) {
+    // compare each value
+    for (var i = 0, ii = Math.min(x.length, y.length); i < ii; i++) {
+      var v = compareNatural(x[i], y[i]);
+      if (v !== 0) {
+        return v;
+      }
+    }
+
+    // compare the size of the arrays
+    if (x.length > y.length) {
+      return 1;
+    }
+    if (x.length < y.length) {
+      return -1;
+    }
+
+    // both Arrays have equal size and content
+    return 0;
+  }
+
+  /**
+   * Compare two objects
+   *
+   * - First, compare sorted property names
+   * - Next, compare the property values
+   *
+   * @param {Object} x
+   * @param {Object} y
+   * @returns {number} Returns the comparison result: -1, 0, or 1
+   */
+  function compareObjects(compareNatural, x, y) {
+    var keysX = Object.keys(x);
+    var keysY = Object.keys(y);
+
+    // compare keys
+    keysX.sort(_javascriptNaturalSort["default"]);
+    keysY.sort(_javascriptNaturalSort["default"]);
+    var c = compareArrays(compareNatural, keysX, keysY);
+    if (c !== 0) {
+      return c;
+    }
+
+    // compare values
+    for (var i = 0; i < keysX.length; i++) {
+      var v = compareNatural(x[keysX[i]], y[keysY[i]]);
+      if (v !== 0) {
+        return v;
+      }
+    }
+    return 0;
+  }
+});
+
+/**
+ * Compare two complex numbers, `x` and `y`:
+ *
+ * - First, compare the real values of `x` and `y`
+ * - If equal, compare the imaginary values of `x` and `y`
+ *
+ * @params {Complex} x
+ * @params {Complex} y
+ * @returns {number} Returns the comparison result: -1, 0, or 1
+ */
+exports.createCompareNatural = createCompareNatural;
+function compareComplexNumbers(x, y) {
+  if (x.re > y.re) {
+    return 1;
+  }
+  if (x.re < y.re) {
+    return -1;
+  }
+  if (x.im > y.im) {
+    return 1;
+  }
+  if (x.im < y.im) {
+    return -1;
+  }
+  return 0;
+}