mathjs 8.1.0 → 12.2.1

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

@@ -1,4 +1,4 @@
-import { isInteger, log2, log10, cbrt, expm1, sign, toFixed, log1p } from '../../utils/number.js';
+import { cbrt, expm1, isInteger, log10, log1p, log2, sign, toFixed } from '../../utils/number.js';
 var n1 = 'number';
 var n2 = 'number, number';
 export function absNumber(a) {
@@ -33,10 +33,6 @@ export function cbrtNumber(x) {
   return cbrt(x);
 }
 cbrtNumber.signature = n1;
-export function ceilNumber(x) {
-  return Math.ceil(x);
-}
-ceilNumber.signature = n1;
 export function cubeNumber(x) {
   return x * x * x;
 }
@@ -49,108 +45,99 @@ export function expm1Number(x) {
   return expm1(x);
 }
 expm1Number.signature = n1;
-export function fixNumber(x) {
-  return x > 0 ? Math.floor(x) : Math.ceil(x);
-}
-fixNumber.signature = n1;
-export function floorNumber(x) {
-  return Math.floor(x);
-}
-floorNumber.signature = n1;
+
 /**
  * Calculate gcd for numbers
  * @param {number} a
  * @param {number} b
  * @returns {number} Returns the greatest common denominator of a and b
  */
-
 export function gcdNumber(a, b) {
   if (!isInteger(a) || !isInteger(b)) {
     throw new Error('Parameters in function gcd must be integer numbers');
-  } // https://en.wikipedia.org/wiki/Euclidean_algorithm
-
+  }
 
+  // https://en.wikipedia.org/wiki/Euclidean_algorithm
   var r;
-
   while (b !== 0) {
     r = a % b;
     a = b;
     b = r;
   }
-
   return a < 0 ? -a : a;
 }
 gcdNumber.signature = n2;
+
 /**
  * Calculate lcm for two numbers
  * @param {number} a
  * @param {number} b
  * @returns {number} Returns the least common multiple of a and b
  */
-
 export function lcmNumber(a, b) {
   if (!isInteger(a) || !isInteger(b)) {
     throw new Error('Parameters in function lcm must be integer numbers');
   }
-
   if (a === 0 || b === 0) {
     return 0;
-  } // https://en.wikipedia.org/wiki/Euclidean_algorithm
-  // evaluate lcm here inline to reduce overhead
-
+  }
 
+  // https://en.wikipedia.org/wiki/Euclidean_algorithm
+  // evaluate lcm here inline to reduce overhead
   var t;
   var prod = a * b;
-
   while (b !== 0) {
     t = b;
     b = a % t;
     a = t;
   }
-
   return Math.abs(prod / a);
 }
 lcmNumber.signature = n2;
+
 /**
- * Calculate the logarithm of a value.
+ * Calculate the logarithm of a value, optionally to a given base.
  * @param {number} x
+ * @param {number | null | undefined} base
  * @return {number}
  */
-
-export function logNumber(x) {
+export function logNumber(x, y) {
+  if (y) {
+    return Math.log(x) / Math.log(y);
+  }
   return Math.log(x);
 }
-logNumber.signature = n1;
+
 /**
  * Calculate the 10-base logarithm of a number
  * @param {number} x
  * @return {number}
  */
-
 export function log10Number(x) {
   return log10(x);
 }
 log10Number.signature = n1;
+
 /**
  * Calculate the 2-base logarithm of a number
  * @param {number} x
  * @return {number}
  */
-
 export function log2Number(x) {
   return log2(x);
 }
 log2Number.signature = n1;
+
 /**
  * Calculate the natural logarithm of a `number+1`
  * @param {number} x
  * @returns {number}
  */
-
 export function log1pNumber(x) {
   return log1p(x);
 }
 log1pNumber.signature = n1;
+
 /**
  * Calculate the modulus of two numbers
  * @param {number} x
@@ -158,62 +145,50 @@ log1pNumber.signature = n1;
  * @returns {number} res
  * @private
  */
-
 export function modNumber(x, y) {
-  if (y > 0) {
-    // We don't use JavaScript's % operator here as this doesn't work
-    // correctly for x < 0 and x === 0
-    // see https://en.wikipedia.org/wiki/Modulo_operation
-    return x - y * Math.floor(x / y);
-  } else if (y === 0) {
-    return x;
-  } else {
-    // y < 0
-    // TODO: implement mod for a negative divisor
-    throw new Error('Cannot calculate mod for a negative divisor');
-  }
+  // We don't use JavaScript's % operator here as this doesn't work
+  // correctly for x < 0 and x === 0
+  // see https://en.wikipedia.org/wiki/Modulo_operation
+  return y === 0 ? x : x - y * Math.floor(x / y);
 }
 modNumber.signature = n2;
+
 /**
  * Calculate the nth root of a, solve x^root == a
  * http://rosettacode.org/wiki/Nth_root#JavaScript
  * @param {number} a
- * @param {number} root
+ * @param {number} [2] root
  * @private
  */
-
-export function nthRootNumber(a, root) {
+export function nthRootNumber(a) {
+  var root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
   var inv = root < 0;
-
   if (inv) {
     root = -root;
   }
-
   if (root === 0) {
     throw new Error('Root must be non-zero');
   }
-
   if (a < 0 && Math.abs(root) % 2 !== 1) {
     throw new Error('Root must be odd when a is negative.');
-  } // edge cases zero and infinity
-
+  }
 
+  // edge cases zero and infinity
   if (a === 0) {
     return inv ? Infinity : 0;
   }
-
   if (!isFinite(a)) {
     return inv ? 0 : a;
   }
-
-  var x = Math.pow(Math.abs(a), 1 / root); // If a < 0, we require that root is an odd integer,
+  var x = Math.pow(Math.abs(a), 1 / root);
+  // If a < 0, we require that root is an odd integer,
   // so (-1) ^ (1/root) = -1
-
   x = a < 0 ? -x : x;
-  return inv ? 1 / x : x; // Very nice algorithm, but fails with nthRoot(-2, 3).
+  return inv ? 1 / x : x;
+
+  // Very nice algorithm, but fails with nthRoot(-2, 3).
   // Newton's method has some well-known problems at times:
   // https://en.wikipedia.org/wiki/Newton%27s_method#Failure_analysis
-
   /*
   let x = 1 // Initial guess
   let xPrev = 1
@@ -232,7 +207,6 @@ export function nthRootNumber(a, root) {
    return inv ? 1 / x : x
   */
 }
-nthRootNumber.signature = n2;
 export function signNumber(x) {
   return sign(x);
 }
@@ -245,6 +219,7 @@ export function squareNumber(x) {
   return x * x;
 }
 squareNumber.signature = n1;
+
 /**
  * Calculate xgcd for two numbers
  * @param {number} a
@@ -252,24 +227,18 @@ squareNumber.signature = n1;
  * @return {number} result
  * @private
  */
-
 export function xgcdNumber(a, b) {
   // source: https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
   var t; // used to swap two variables
-
   var q; // quotient
-
   var r; // remainder
-
   var x = 0;
   var lastx = 1;
   var y = 1;
   var lasty = 0;
-
   if (!isInteger(a) || !isInteger(b)) {
     throw new Error('Parameters in function xgcd must be integer numbers');
   }
-
   while (b) {
     q = Math.floor(a / b);
     r = a - q * b;
@@ -282,35 +251,32 @@ export function xgcdNumber(a, b) {
     a = b;
     b = r;
   }
-
   var res;
-
   if (a < 0) {
     res = [-a, -lastx, -lasty];
   } else {
     res = [a, a ? lastx : 0, lasty];
   }
-
   return res;
 }
 xgcdNumber.signature = n2;
+
 /**
  * Calculates the power of x to y, x^y, for two numbers.
  * @param {number} x
  * @param {number} y
  * @return {number} res
  */
-
 export function powNumber(x, y) {
   // x^Infinity === 0 if -1 < x < 1
   // A real number 0 is returned instead of complex(0)
   if (x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity) {
     return 0;
   }
-
   return Math.pow(x, y);
 }
 powNumber.signature = n2;
+
 /**
  * round a number to the given number of decimals, or to zero if decimals is
  * not provided
@@ -318,18 +284,19 @@ powNumber.signature = n2;
  * @param {number} decimals       number of decimals, between 0 and 15 (0 by default)
  * @return {number} roundedValue
  */
-
 export function roundNumber(value) {
   var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (!isInteger(decimals) || decimals < 0 || decimals > 15) {
+    throw new Error('Number of decimals in function round must be an integer from 0 to 15 inclusive');
+  }
   return parseFloat(toFixed(value, decimals));
 }
-roundNumber.signature = n2;
+
 /**
  * Calculate the norm of a number, the absolute value.
  * @param {number} x
  * @return {number}
  */
-
 export function normNumber(x) {
   return Math.abs(x);
 }

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

@@ -5,7 +5,6 @@ export function bitAndNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function bitAnd');
   }
-
   return x & y;
 }
 bitAndNumber.signature = n2;
@@ -13,7 +12,6 @@ export function bitNotNumber(x) {
   if (!isInteger(x)) {
     throw new Error('Integer expected in function bitNot');
   }
-
   return ~x;
 }
 bitNotNumber.signature = n1;
@@ -21,7 +19,6 @@ export function bitOrNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function bitOr');
   }
-
   return x | y;
 }
 bitOrNumber.signature = n2;
@@ -29,7 +26,6 @@ export function bitXorNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function bitXor');
   }
-
   return x ^ y;
 }
 bitXorNumber.signature = n2;
@@ -37,7 +33,6 @@ export function leftShiftNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function leftShift');
   }
-
   return x << y;
 }
 leftShiftNumber.signature = n2;
@@ -45,7 +40,6 @@ export function rightArithShiftNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function rightArithShift');
   }
-
   return x >> y;
 }
 rightArithShiftNumber.signature = n2;
@@ -53,7 +47,6 @@ export function rightLogShiftNumber(x, y) {
   if (!isInteger(x) || !isInteger(y)) {
     throw new Error('Integers expected in function rightLogShift');
   }
-
   return x >>> y;
 }
 rightLogShiftNumber.signature = n2;

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

@@ -4,24 +4,30 @@ 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 prodrange;
-
-  if (k < nMinusk) {
-    prodrange = product(nMinusk + 1, n);
-    return prodrange / product(1, 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;
+    }
   }
-
-  prodrange = product(k + 1, n);
-  return prodrange / product(1, nMinusk);
+  // 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/probability.js

@@ -1,29 +1,24 @@
 /* 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;
@@ -32,18 +27,49 @@ export function gammaNumber(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
+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];
+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/type/bignumber/BigNumber.js

@@ -2,48 +2,45 @@ 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) => {
+export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
     config
   } = _ref;
-  var EUCLID = 9; // Use euclidian division for mod calculation
-
   var BigNumber = Decimal.clone({
     precision: config.precision,
-    modulo: EUCLID
+    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) {
@@ -54,7 +51,6 @@ export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, (_r
       }
     });
   }
-
   return BigNumber;
 }, {
   isClass: true

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

@@ -2,12 +2,11 @@ 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) => {
+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.
@@ -42,20 +41,39 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, (_ref) =
       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;
     },
+    Unit: typed.referToSelf(self => x => {
+      var clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
+    }),
     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': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/type/boolean.js

@@ -2,11 +2,10 @@ 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) => {
+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
@@ -53,24 +52,19 @@ export var createBoolean = /* #__PURE__ */factory(name, dependencies, (_ref) =>
     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
-
+      }
 
+      // 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': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });