mathjs-min 11.7.2

package/lib/esm/plain/number/combinations.js

@@ -0,0 +1,33 @@
+import { isInteger } from '../../utils/number.js';
+import { product } from '../../utils/product.js';
+export function combinationsNumber(n, k) {
+  if (!isInteger(n) || n < 0) {
+    throw new TypeError('Positive integer value expected in function combinations');
+  }
+  if (!isInteger(k) || k < 0) {
+    throw new TypeError('Positive integer value expected in function combinations');
+  }
+  if (k > n) {
+    throw new TypeError('k must be less than or equal to n');
+  }
+  var nMinusk = n - k;
+  var answer = 1;
+  var firstnumerator = k < nMinusk ? nMinusk + 1 : k + 1;
+  var nextdivisor = 2;
+  var lastdivisor = k < nMinusk ? k : nMinusk;
+  // balance multiplications and divisions to try to keep intermediate values
+  // in exact-integer range as long as possible
+  for (var nextnumerator = firstnumerator; nextnumerator <= n; ++nextnumerator) {
+    answer *= nextnumerator;
+    while (nextdivisor <= lastdivisor && answer % nextdivisor === 0) {
+      answer /= nextdivisor;
+      ++nextdivisor;
+    }
+  }
+  // for big n, k, floating point may have caused weirdness in remainder
+  if (nextdivisor <= lastdivisor) {
+    answer /= product(nextdivisor, lastdivisor);
+  }
+  return answer;
+}
+combinationsNumber.signature = 'number, number';

package/lib/esm/plain/number/constants.js

@@ -0,0 +1,4 @@
+export var pi = Math.PI;
+export var tau = 2 * Math.PI;
+export var e = Math.E;
+export var phi = 1.6180339887498948; // eslint-disable-line no-loss-of-precision

package/lib/esm/plain/number/index.js

@@ -0,0 +1,9 @@
+export * from './arithmetic.js';
+export * from './bitwise.js';
+export * from './combinations.js';
+export * from './constants.js';
+export * from './logical.js';
+export * from './relational.js';
+export * from './probability.js';
+export * from './trigonometry.js';
+export * from './utils.js';

package/lib/esm/plain/number/logical.js

@@ -0,0 +1,18 @@
+var n1 = 'number';
+var n2 = 'number, number';
+export function notNumber(x) {
+  return !x;
+}
+notNumber.signature = n1;
+export function orNumber(x, y) {
+  return !!(x || y);
+}
+orNumber.signature = n2;
+export function xorNumber(x, y) {
+  return !!x !== !!y;
+}
+xorNumber.signature = n2;
+export function andNumber(x, y) {
+  return !!(x && y);
+}
+andNumber.signature = n2;

package/lib/esm/plain/number/probability.js

@@ -0,0 +1,77 @@
+/* eslint-disable no-loss-of-precision */
+
+import { isInteger } from '../../utils/number.js';
+import { product } from '../../utils/product.js';
+export function gammaNumber(n) {
+  var x;
+  if (isInteger(n)) {
+    if (n <= 0) {
+      return isFinite(n) ? Infinity : NaN;
+    }
+    if (n > 171) {
+      return Infinity; // Will overflow
+    }
+
+    return product(1, n - 1);
+  }
+  if (n < 0.5) {
+    return Math.PI / (Math.sin(Math.PI * n) * gammaNumber(1 - n));
+  }
+  if (n >= 171.35) {
+    return Infinity; // will overflow
+  }
+
+  if (n > 85.0) {
+    // Extended Stirling Approx
+    var twoN = n * n;
+    var threeN = twoN * n;
+    var fourN = threeN * n;
+    var fiveN = fourN * n;
+    return Math.sqrt(2 * Math.PI / n) * Math.pow(n / Math.E, n) * (1 + 1 / (12 * n) + 1 / (288 * twoN) - 139 / (51840 * threeN) - 571 / (2488320 * fourN) + 163879 / (209018880 * fiveN) + 5246819 / (75246796800 * fiveN * n));
+  }
+  --n;
+  x = gammaP[0];
+  for (var i = 1; i < gammaP.length; ++i) {
+    x += gammaP[i] / (n + i);
+  }
+  var t = n + gammaG + 0.5;
+  return Math.sqrt(2 * Math.PI) * Math.pow(t, n + 0.5) * Math.exp(-t) * x;
+}
+gammaNumber.signature = 'number';
+
+// TODO: comment on the variables g and p
+
+export var gammaG = 4.7421875;
+export var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5];
+
+// lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
+
+// log(2 * pi) / 2
+export var lnSqrt2PI = 0.91893853320467274178;
+export var lgammaG = 5; // Lanczos parameter "g"
+export var lgammaN = 7; // Range of coefficients "n"
+
+export var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+export function lgammaNumber(n) {
+  if (n < 0) return NaN;
+  if (n === 0) return Infinity;
+  if (!isFinite(n)) return n;
+  if (n < 0.5) {
+    // Use Euler's reflection formula:
+    // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))
+    return Math.log(Math.PI / Math.sin(Math.PI * n)) - lgammaNumber(1 - n);
+  }
+
+  // Compute the logarithm of the Gamma function using the Lanczos method
+
+  n = n - 1;
+  var base = n + lgammaG + 0.5; // Base of the Lanczos exponential
+  var sum = lgammaSeries[0];
+
+  // We start with the terms that have the smallest coefficients and largest denominator
+  for (var i = lgammaN - 1; i >= 1; i--) {
+    sum += lgammaSeries[i] / (n + i);
+  }
+  return lnSqrt2PI + (n + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+lgammaNumber.signature = 'number';

package/lib/esm/plain/number/trigonometry.js

@@ -0,0 +1,112 @@
+import { acosh, asinh, atanh, cosh, sign, sinh, tanh } from '../../utils/number.js';
+var n1 = 'number';
+var n2 = 'number, number';
+export function acosNumber(x) {
+  return Math.acos(x);
+}
+acosNumber.signature = n1;
+export function acoshNumber(x) {
+  return acosh(x);
+}
+acoshNumber.signature = n1;
+export function acotNumber(x) {
+  return Math.atan(1 / x);
+}
+acotNumber.signature = n1;
+export function acothNumber(x) {
+  return isFinite(x) ? (Math.log((x + 1) / x) + Math.log(x / (x - 1))) / 2 : 0;
+}
+acothNumber.signature = n1;
+export function acscNumber(x) {
+  return Math.asin(1 / x);
+}
+acscNumber.signature = n1;
+export function acschNumber(x) {
+  var xInv = 1 / x;
+  return Math.log(xInv + Math.sqrt(xInv * xInv + 1));
+}
+acschNumber.signature = n1;
+export function asecNumber(x) {
+  return Math.acos(1 / x);
+}
+asecNumber.signature = n1;
+export function asechNumber(x) {
+  var xInv = 1 / x;
+  var ret = Math.sqrt(xInv * xInv - 1);
+  return Math.log(ret + xInv);
+}
+asechNumber.signature = n1;
+export function asinNumber(x) {
+  return Math.asin(x);
+}
+asinNumber.signature = n1;
+export function asinhNumber(x) {
+  return asinh(x);
+}
+asinhNumber.signature = n1;
+export function atanNumber(x) {
+  return Math.atan(x);
+}
+atanNumber.signature = n1;
+export function atan2Number(y, x) {
+  return Math.atan2(y, x);
+}
+atan2Number.signature = n2;
+export function atanhNumber(x) {
+  return atanh(x);
+}
+atanhNumber.signature = n1;
+export function cosNumber(x) {
+  return Math.cos(x);
+}
+cosNumber.signature = n1;
+export function coshNumber(x) {
+  return cosh(x);
+}
+coshNumber.signature = n1;
+export function cotNumber(x) {
+  return 1 / Math.tan(x);
+}
+cotNumber.signature = n1;
+export function cothNumber(x) {
+  var e = Math.exp(2 * x);
+  return (e + 1) / (e - 1);
+}
+cothNumber.signature = n1;
+export function cscNumber(x) {
+  return 1 / Math.sin(x);
+}
+cscNumber.signature = n1;
+export function cschNumber(x) {
+  // consider values close to zero (+/-)
+  if (x === 0) {
+    return Number.POSITIVE_INFINITY;
+  } else {
+    return Math.abs(2 / (Math.exp(x) - Math.exp(-x))) * sign(x);
+  }
+}
+cschNumber.signature = n1;
+export function secNumber(x) {
+  return 1 / Math.cos(x);
+}
+secNumber.signature = n1;
+export function sechNumber(x) {
+  return 2 / (Math.exp(x) + Math.exp(-x));
+}
+sechNumber.signature = n1;
+export function sinNumber(x) {
+  return Math.sin(x);
+}
+sinNumber.signature = n1;
+export function sinhNumber(x) {
+  return sinh(x);
+}
+sinhNumber.signature = n1;
+export function tanNumber(x) {
+  return Math.tan(x);
+}
+tanNumber.signature = n1;
+export function tanhNumber(x) {
+  return tanh(x);
+}
+tanhNumber.signature = n1;

package/lib/esm/plain/number/utils.js

@@ -0,0 +1,22 @@
+import { isInteger } from '../../utils/number.js';
+var n1 = 'number';
+export function isIntegerNumber(x) {
+  return isInteger(x);
+}
+isIntegerNumber.signature = n1;
+export function isNegativeNumber(x) {
+  return x < 0;
+}
+isNegativeNumber.signature = n1;
+export function isPositiveNumber(x) {
+  return x > 0;
+}
+isPositiveNumber.signature = n1;
+export function isZeroNumber(x) {
+  return x === 0;
+}
+isZeroNumber.signature = n1;
+export function isNaNNumber(x) {
+  return Number.isNaN(x);
+}
+isNaNNumber.signature = n1;

package/lib/esm/type/bignumber/BigNumber.js

@@ -0,0 +1,57 @@
+import Decimal from 'decimal.js';
+import { factory } from '../../utils/factory.js';
+var name = 'BigNumber';
+var dependencies = ['?on', 'config'];
+export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    on,
+    config
+  } = _ref;
+  var BigNumber = Decimal.clone({
+    precision: config.precision,
+    modulo: Decimal.EUCLID
+  });
+  BigNumber.prototype = Object.create(BigNumber.prototype);
+
+  /**
+   * Attach type information
+   */
+  BigNumber.prototype.type = 'BigNumber';
+  BigNumber.prototype.isBigNumber = true;
+
+  /**
+   * Get a JSON representation of a BigNumber containing
+   * type information
+   * @returns {Object} Returns a JSON object structured as:
+   *                   `{"mathjs": "BigNumber", "value": "0.2"}`
+   */
+  BigNumber.prototype.toJSON = function () {
+    return {
+      mathjs: 'BigNumber',
+      value: this.toString()
+    };
+  };
+
+  /**
+   * Instantiate a BigNumber from a JSON object
+   * @param {Object} json  a JSON object structured as:
+   *                       `{"mathjs": "BigNumber", "value": "0.2"}`
+   * @return {BigNumber}
+   */
+  BigNumber.fromJSON = function (json) {
+    return new BigNumber(json.value);
+  };
+  if (on) {
+    // listen for changed in the configuration, automatically apply changed precision
+    on('config', function (curr, prev) {
+      if (curr.precision !== prev.precision) {
+        BigNumber.config({
+          precision: curr.precision
+        });
+      }
+    });
+  }
+  return BigNumber;
+}, {
+  isClass: true
+});

package/lib/esm/type/bignumber/function/bignumber.js

@@ -0,0 +1,74 @@
+import { factory } from '../../../utils/factory.js';
+import { deepMap } from '../../../utils/collection.js';
+var name = 'bignumber';
+var dependencies = ['typed', 'BigNumber'];
+export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    BigNumber
+  } = _ref;
+  /**
+   * Create a BigNumber, which can store numbers with arbitrary precision.
+   * When a matrix is provided, all elements will be converted to BigNumber.
+   *
+   * Syntax:
+   *
+   *    math.bignumber(x)
+   *
+   * Examples:
+   *
+   *    0.1 + 0.2                                  // returns number 0.30000000000000004
+   *    math.bignumber(0.1) + math.bignumber(0.2)  // returns BigNumber 0.3
+   *
+   *
+   *    7.2e500                                    // returns number Infinity
+   *    math.bignumber('7.2e500')                  // returns BigNumber 7.2e500
+   *
+   * See also:
+   *
+   *    boolean, complex, index, matrix, string, unit
+   *
+   * @param {number | string | Fraction | BigNumber | Array | Matrix | boolean | null} [value]  Value for the big number,
+   *                                                    0 by default.
+   * @returns {BigNumber} The created bignumber
+   */
+  return typed('bignumber', {
+    '': function _() {
+      return new BigNumber(0);
+    },
+    number: function number(x) {
+      // convert to string to prevent errors in case of >15 digits
+      return new BigNumber(x + '');
+    },
+    string: function string(x) {
+      var wordSizeSuffixMatch = x.match(/(0[box][0-9a-fA-F]*)i([0-9]*)/);
+      if (wordSizeSuffixMatch) {
+        // x has a word size suffix
+        var size = wordSizeSuffixMatch[2];
+        var n = BigNumber(wordSizeSuffixMatch[1]);
+        var twoPowSize = new BigNumber(2).pow(Number(size));
+        if (n.gt(twoPowSize.sub(1))) {
+          throw new SyntaxError("String \"".concat(x, "\" is out of range"));
+        }
+        var twoPowSizeSubOne = new BigNumber(2).pow(Number(size) - 1);
+        if (n.gte(twoPowSizeSubOne)) {
+          return n.sub(twoPowSize);
+        } else {
+          return n;
+        }
+      }
+      return new BigNumber(x);
+    },
+    BigNumber: function BigNumber(x) {
+      // we assume a BigNumber is immutable
+      return x;
+    },
+    Fraction: function Fraction(x) {
+      return new BigNumber(x.n).div(x.d).times(x.s);
+    },
+    null: function _null(x) {
+      return new BigNumber(0);
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/type/boolean.js

@@ -0,0 +1,70 @@
+import { factory } from '../utils/factory.js';
+import { deepMap } from '../utils/collection.js';
+var name = 'boolean';
+var dependencies = ['typed'];
+export var createBoolean = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Create a boolean or convert a string or number to a boolean.
+   * In case of a number, `true` is returned for non-zero numbers, and `false` in
+   * case of zero.
+   * Strings can be `'true'` or `'false'`, or can contain a number.
+   * When value is a matrix, all elements will be converted to boolean.
+   *
+   * Syntax:
+   *
+   *    math.boolean(x)
+   *
+   * Examples:
+   *
+   *    math.boolean(0)     // returns false
+   *    math.boolean(1)     // returns true
+   *    math.boolean(-3)     // returns true
+   *    math.boolean('true')     // returns true
+   *    math.boolean('false')     // returns false
+   *    math.boolean([1, 0, 1, 1])     // returns [true, false, true, true]
+   *
+   * See also:
+   *
+   *    bignumber, complex, index, matrix, string, unit
+   *
+   * @param {string | number | boolean | Array | Matrix | null} value  A value of any type
+   * @return {boolean | Array | Matrix} The boolean value
+   */
+  return typed(name, {
+    '': function _() {
+      return false;
+    },
+    boolean: function boolean(x) {
+      return x;
+    },
+    number: function number(x) {
+      return !!x;
+    },
+    null: function _null(x) {
+      return false;
+    },
+    BigNumber: function BigNumber(x) {
+      return !x.isZero();
+    },
+    string: function string(x) {
+      // try case insensitive
+      var lcase = x.toLowerCase();
+      if (lcase === 'true') {
+        return true;
+      } else if (lcase === 'false') {
+        return false;
+      }
+
+      // test whether value is a valid number
+      var num = Number(x);
+      if (x !== '' && !isNaN(num)) {
+        return !!num;
+      }
+      throw new Error('Cannot convert "' + x + '" to a boolean');
+    },
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
+  });
+});

package/lib/esm/type/chain/Chain.js

@@ -0,0 +1,213 @@
+import { isChain } from '../../utils/is.js';
+import { format } from '../../utils/string.js';
+import { hasOwnProperty, lazy } from '../../utils/object.js';
+import { factory } from '../../utils/factory.js';
+var name = 'Chain';
+var dependencies = ['?on', 'math', 'typed'];
+export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    on,
+    math,
+    typed
+  } = _ref;
+  /**
+   * @constructor Chain
+   * Wrap any value in a chain, allowing to perform chained operations on
+   * the value.
+   *
+   * All methods available in the math.js library can be called upon the chain,
+   * and then will be evaluated with the value itself as first argument.
+   * The chain can be closed by executing chain.done(), which will return
+   * the final value.
+   *
+   * The Chain has a number of special functions:
+   * - done()             Finalize the chained operation and return the
+   *                      chain's value.
+   * - valueOf()          The same as done()
+   * - toString()         Returns a string representation of the chain's value.
+   *
+   * @param {*} [value]
+   */
+  function Chain(value) {
+    if (!(this instanceof Chain)) {
+      throw new SyntaxError('Constructor must be called with the new operator');
+    }
+    if (isChain(value)) {
+      this.value = value.value;
+    } else {
+      this.value = value;
+    }
+  }
+
+  /**
+   * Attach type information
+   */
+  Chain.prototype.type = 'Chain';
+  Chain.prototype.isChain = true;
+
+  /**
+   * Close the chain. Returns the final value.
+   * Does the same as method valueOf()
+   * @returns {*} value
+   */
+  Chain.prototype.done = function () {
+    return this.value;
+  };
+
+  /**
+   * Close the chain. Returns the final value.
+   * Does the same as method done()
+   * @returns {*} value
+   */
+  Chain.prototype.valueOf = function () {
+    return this.value;
+  };
+
+  /**
+   * Get a string representation of the value in the chain
+   * @returns {string}
+   */
+  Chain.prototype.toString = function () {
+    return format(this.value);
+  };
+
+  /**
+   * Get a JSON representation of the chain
+   * @returns {Object}
+   */
+  Chain.prototype.toJSON = function () {
+    return {
+      mathjs: 'Chain',
+      value: this.value
+    };
+  };
+
+  /**
+   * Instantiate a Chain from its JSON representation
+   * @param {Object} json  An object structured like
+   *                       `{"mathjs": "Chain", value: ...}`,
+   *                       where mathjs is optional
+   * @returns {Chain}
+   */
+  Chain.fromJSON = function (json) {
+    return new Chain(json.value);
+  };
+
+  /**
+   * Create a proxy method for the chain
+   * @param {string} name
+   * @param {Function} fn      The function to be proxied
+   *                           If fn is no function, it is silently ignored.
+   * @private
+   */
+  function createProxy(name, fn) {
+    if (typeof fn === 'function') {
+      Chain.prototype[name] = chainify(fn);
+    }
+  }
+
+  /**
+   * Create a proxy method for the chain
+   * @param {string} name
+   * @param {function} resolver   The function resolving with the
+   *                              function to be proxied
+   * @private
+   */
+  function createLazyProxy(name, resolver) {
+    lazy(Chain.prototype, name, function outerResolver() {
+      var fn = resolver();
+      if (typeof fn === 'function') {
+        return chainify(fn);
+      }
+      return undefined; // if not a function, ignore
+    });
+  }
+
+  /**
+   * Make a function chainable
+   * @param {function} fn
+   * @return {Function} chain function
+   * @private
+   */
+  function chainify(fn) {
+    return function () {
+      // Here, `this` will be the context of a Chain instance
+      if (arguments.length === 0) {
+        return new Chain(fn(this.value));
+      }
+      var args = [this.value];
+      for (var i = 0; i < arguments.length; i++) {
+        args[i + 1] = arguments[i];
+      }
+      if (typed.isTypedFunction(fn)) {
+        var sigObject = typed.resolve(fn, args);
+        // We want to detect if a rest parameter has matched across the
+        // value in the chain and the current arguments of this call.
+        // That is the case if and only if the matching signature has
+        // exactly one parameter (which then must be a rest parameter
+        // as it is matching at least two actual arguments).
+        if (sigObject.params.length === 1) {
+          throw new Error('chain function ' + fn.name + ' cannot match rest parameter between chain value and additional arguments.');
+        }
+        return new Chain(sigObject.implementation.apply(fn, args));
+      }
+      return new Chain(fn.apply(fn, args));
+    };
+  }
+
+  /**
+   * Create a proxy for a single method, or an object with multiple methods.
+   * Example usage:
+   *
+   *   Chain.createProxy('add', function add (x, y) {...})
+   *   Chain.createProxy({
+   *     add:      function add (x, y) {...},
+   *     subtract: function subtract (x, y) {...}
+   *   }
+   *
+   * @param {string | Object} arg0   A name (string), or an object with
+   *                                 functions
+   * @param {*} [arg1]               A function, when arg0 is a name
+   */
+  Chain.createProxy = function (arg0, arg1) {
+    if (typeof arg0 === 'string') {
+      // createProxy(name, value)
+      createProxy(arg0, arg1);
+    } else {
+      var _loop = function _loop(_name) {
+        if (hasOwnProperty(arg0, _name) && excludedNames[_name] === undefined) {
+          createLazyProxy(_name, () => arg0[_name]);
+        }
+      };
+      // createProxy(values)
+      for (var _name in arg0) {
+        _loop(_name);
+      }
+    }
+  };
+  var excludedNames = {
+    expression: true,
+    docs: true,
+    type: true,
+    classes: true,
+    json: true,
+    error: true,
+    isChain: true // conflicts with the property isChain of a Chain instance
+  };
+
+  // create proxy for everything that is in math.js
+  Chain.createProxy(math);
+
+  // register on the import event, automatically add a proxy for every imported function.
+  if (on) {
+    on('import', function (name, resolver, path) {
+      if (!path) {
+        // an imported function (not a data type or something special)
+        createLazyProxy(name, resolver);
+      }
+    });
+  }
+  return Chain;
+}, {
+  isClass: true
+});