mathjs 11.2.1 → 11.3.0

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

@@ -45,104 +45,99 @@ export function expm1Number(x) {
   return expm1(x);
 }
 expm1Number.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, optionally to a given base.
  * @param {number} x
  * @param {number | null | undefined} base
  * @return {number}
  */
-
 export function logNumber(x, y) {
   if (y) {
     return Math.log(x) / Math.log(y);
   }
-
   return Math.log(x);
 }
+
 /**
  * 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
@@ -150,7 +145,6 @@ 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
@@ -166,6 +160,7 @@ export function modNumber(x, y) {
   }
 }
 modNumber.signature = n2;
+
 /**
  * Calculate the nth root of a, solve x^root == a
  * http://rosettacode.org/wiki/Nth_root#JavaScript
@@ -173,40 +168,35 @@ modNumber.signature = n2;
  * @param {number} [2] root
  * @private
  */
-
 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
@@ -225,6 +215,7 @@ export function nthRootNumber(a) {
    return inv ? 1 / x : x
   */
 }
+
 export function signNumber(x) {
   return sign(x);
 }
@@ -237,6 +228,7 @@ export function squareNumber(x) {
   return x * x;
 }
 squareNumber.signature = n1;
+
 /**
  * Calculate xgcd for two numbers
  * @param {number} a
@@ -244,24 +236,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;
@@ -274,35 +260,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
@@ -310,22 +293,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));
 }
+
 /**
  * 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,36 +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 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
+  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
-
-
+  }
+  // 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,25 +1,22 @@
 /* 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
   }
@@ -32,26 +29,26 @@ 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]; // lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
-// log(2 * pi) / 2
+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];
@@ -59,23 +56,22 @@ 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
+  }
 
+  // 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];
 
-  var sum = lgammaSeries[0]; // We start with the terms that have the smallest coefficients and largest denominator
-
+  // 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

@@ -12,37 +12,35 @@ export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, _re
     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) {
@@ -53,7 +51,6 @@ export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, _re
       }
     });
   }
-
   return BigNumber;
 }, {
   isClass: true

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

@@ -7,7 +7,6 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
     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.
@@ -43,26 +42,21 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
     },
     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) {

package/lib/esm/type/boolean.js

@@ -6,7 +6,6 @@ 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,20 +52,17 @@ 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': typed.referToSelf(self => x => deepMap(x, self))