npm - mathjs - Versions diffs - 11.2.0 → 11.3.0 - Mend

mathjs 11.2.0 → 11.3.0

Files changed (1322) hide show

package/lib/esm/utils/bignumber/bitwise.js CHANGED Viewed

@@ -23,71 +23,57 @@ export function bitAndBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitAnd');
   }
   var BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
   if (x.isZero() || y.eq(-1) || x.eq(y)) {
     return x;
   }
   if (y.isZero() || x.eq(-1)) {
     return y;
   }
   if (!x.isFinite() || !y.isFinite()) {
     if (!x.isFinite() && !y.isFinite()) {
       if (x.isNegative() === y.isNegative()) {
         return x;
       }
       return new BigNumber(0);
     }
     if (!x.isFinite()) {
       if (y.isNegative()) {
         return x;
       }
       if (x.isNegative()) {
         return new BigNumber(0);
       }
       return y;
     }
     if (!y.isFinite()) {
       if (x.isNegative()) {
         return y;
       }
       if (y.isNegative()) {
         return new BigNumber(0);
       }
       return x;
     }
   }
   return bitwise(x, y, function (a, b) {
     return a & b;
   });
 }
 /**
  * Bitwise not
  * @param {BigNumber} x
  * @return {BigNumber} Result of ~`x`, fully precise
  *
  */
 export function bitNotBigNumber(x) {
   if (x.isFinite() && !x.isInteger()) {
     throw new Error('Integer expected in function bitNot');
   }
   var BigNumber = x.constructor;
   var prevPrec = BigNumber.precision;
   BigNumber.config({
@@ -100,6 +86,7 @@ export function bitNotBigNumber(x) {
   });
   return result;
 }
 /**
  * Bitwise OR for BigNumbers
  *
@@ -120,44 +107,35 @@ export function bitNotBigNumber(x) {
  * @param {BigNumber} y
  * @return {BigNumber} Result of `x` | `y`, fully precise
  */
 export function bitOrBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitOr');
   }
   var BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
   var negOne = new BigNumber(-1);
   if (x.isZero() || y.eq(negOne) || x.eq(y)) {
     return y;
   }
   if (y.isZero() || x.eq(negOne)) {
     return x;
   }
   if (!x.isFinite() || !y.isFinite()) {
     if (!x.isFinite() && !x.isNegative() && y.isNegative() || x.isNegative() && !y.isNegative() && !y.isFinite()) {
       return negOne;
     }
     if (x.isNegative() && y.isNegative()) {
       return x.isFinite() ? x : y;
     }
     return x.isFinite() ? y : x;
   }
   return bitwise(x, y, function (a, b) {
     return a | b;
   });
 }
 /**
  * Applies bitwise function to numbers
  * @param {BigNumber} x
@@ -165,35 +143,28 @@ export function bitOrBigNumber(x, y) {
  * @param {function (a, b)} func
  * @return {BigNumber}
  */
 export function bitwise(x, y, func) {
   var BigNumber = x.constructor;
   var xBits, yBits;
   var xSign = +(x.s < 0);
   var ySign = +(y.s < 0);
   if (xSign) {
     xBits = decCoefficientToBinaryString(bitNotBigNumber(x));
     for (var i = 0; i < xBits.length; ++i) {
       xBits[i] ^= 1;
     }
   } else {
     xBits = decCoefficientToBinaryString(x);
   }
   if (ySign) {
     yBits = decCoefficientToBinaryString(bitNotBigNumber(y));
     for (var _i = 0; _i < yBits.length; ++_i) {
       yBits[_i] ^= 1;
     }
   } else {
     yBits = decCoefficientToBinaryString(y);
   }
   var minBits, maxBits, minSign;
   if (xBits.length <= yBits.length) {
     minBits = xBits;
     maxBits = yBits;
@@ -203,7 +174,6 @@ export function bitwise(x, y, func) {
     maxBits = xBits;
     minSign = ySign;
   }
   var shortLen = minBits.length;
   var longLen = maxBits.length;
   var expFuncVal = func(xSign, ySign) ^ 1;
@@ -214,100 +184,79 @@ export function bitwise(x, y, func) {
   BigNumber.config({
     precision: 1E9
   });
   while (shortLen > 0) {
     if (func(minBits[--shortLen], maxBits[--longLen]) === expFuncVal) {
       outVal = outVal.plus(twoPower);
     }
     twoPower = twoPower.times(two);
   }
   while (longLen > 0) {
     if (func(minSign, maxBits[--longLen]) === expFuncVal) {
       outVal = outVal.plus(twoPower);
     }
     twoPower = twoPower.times(two);
   }
   BigNumber.config({
     precision: prevPrec
   });
   if (expFuncVal === 0) {
     outVal.s = -outVal.s;
   }
   return outVal;
 }
-/* Extracted from decimal.js, and edited to specialize. */
+/* Extracted from decimal.js, and edited to specialize. */
 function decCoefficientToBinaryString(x) {
   // Convert to string
   var a = x.d; // array with digits
   var r = a[0] + '';
   for (var i = 1; i < a.length; ++i) {
     var s = a[i] + '';
     for (var z = 7 - s.length; z--;) {
       s = '0' + s;
     }
     r += s;
   }
   var j = r.length;
   while (r.charAt(j) === '0') {
     j--;
   }
   var xe = x.e;
   var str = r.slice(0, j + 1 || 1);
   var strL = str.length;
   if (xe > 0) {
     if (++xe > strL) {
       // Append zeros.
       xe -= strL;
       while (xe--) {
         str += '0';
       }
     } else if (xe < strL) {
       str = str.slice(0, xe) + '.' + str.slice(xe);
     }
-  } // Convert from base 10 (decimal) to base 2
+  }
+  // Convert from base 10 (decimal) to base 2
   var arr = [0];
   for (var _i2 = 0; _i2 < str.length;) {
     var arrL = arr.length;
     while (arrL--) {
       arr[arrL] *= 10;
     }
     arr[0] += parseInt(str.charAt(_i2++)); // convert to int
     for (var _j = 0; _j < arr.length; ++_j) {
       if (arr[_j] > 1) {
         if (arr[_j + 1] === null || arr[_j + 1] === undefined) {
           arr[_j + 1] = 0;
         }
         arr[_j + 1] += arr[_j] >> 1;
         arr[_j] &= 1;
       }
     }
   }
   return arr.reverse();
 }
 /**
  * Bitwise XOR for BigNumbers
  *
@@ -327,53 +276,41 @@ function decCoefficientToBinaryString(x) {
  * @return {BigNumber} Result of `x` ^ `y`, fully precise
  *
  */
 export function bitXor(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitXor');
   }
   var BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
   if (x.isZero()) {
     return y;
   }
   if (y.isZero()) {
     return x;
   }
   if (x.eq(y)) {
     return new BigNumber(0);
   }
   var negOne = new BigNumber(-1);
   if (x.eq(negOne)) {
     return bitNotBigNumber(y);
   }
   if (y.eq(negOne)) {
     return bitNotBigNumber(x);
   }
   if (!x.isFinite() || !y.isFinite()) {
     if (!x.isFinite() && !y.isFinite()) {
       return negOne;
     }
     return new BigNumber(x.isNegative() === y.isNegative() ? Infinity : -Infinity);
   }
   return bitwise(x, y, function (a, b) {
     return a ^ b;
   });
 }
 /**
  * Bitwise left shift
  *
@@ -392,33 +329,28 @@ export function bitXor(x, y) {
  * @return {BigNumber} Result of `x` << `y`
  *
  */
 export function leftShiftBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function leftShift');
   }
   var BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
     return new BigNumber(NaN);
   }
   if (x.isZero() || y.isZero()) {
     return x;
   }
   if (!x.isFinite() && !y.isFinite()) {
     return new BigNumber(NaN);
-  } // Math.pow(2, y) is fully precise for y < 55, and fast
+  }
+  // Math.pow(2, y) is fully precise for y < 55, and fast
   if (y.lt(55)) {
     return x.times(Math.pow(2, y.toNumber()) + '');
   }
   return x.times(new BigNumber(2).pow(y));
 }
 /*
  * Special Cases:
  *   n >> -n =  N
@@ -438,38 +370,30 @@ export function leftShiftBigNumber(x, y) {
  * @return {BigNumber} Result of `x` >> `y`
  *
  */
 export function rightArithShiftBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function rightArithShift');
   }
   var BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
     return new BigNumber(NaN);
   }
   if (x.isZero() || y.isZero()) {
     return x;
   }
   if (!y.isFinite()) {
     if (x.isNegative()) {
       return new BigNumber(-1);
     }
     if (!x.isFinite()) {
       return new BigNumber(NaN);
     }
     return new BigNumber(0);
-  } // Math.pow(2, y) is fully precise for y < 55, and fast
+  }
+  // Math.pow(2, y) is fully precise for y < 55, and fast
   if (y.lt(55)) {
     return x.div(Math.pow(2, y.toNumber()) + '').floor();
   }
   return x.div(new BigNumber(2).pow(y)).floor();
 }

package/lib/esm/utils/bignumber/constants.js CHANGED Viewed

@@ -1,48 +1,49 @@
 import { memoize } from '../function.js';
 /**
  * Calculate BigNumber e
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns e
  */
 export var createBigNumberE = memoize(function (BigNumber) {
   return new BigNumber(1).exp();
 }, {
   hasher
 });
 /**
  * Calculate BigNumber golden ratio, phi = (1+sqrt(5))/2
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns phi
  */
 export var createBigNumberPhi = memoize(function (BigNumber) {
   return new BigNumber(1).plus(new BigNumber(5).sqrt()).div(2);
 }, {
   hasher
 });
 /**
  * Calculate BigNumber pi.
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns pi
  */
 export var createBigNumberPi = memoize(function (BigNumber) {
   return BigNumber.acos(-1);
 }, {
   hasher
 });
 /**
  * Calculate BigNumber tau, tau = 2 * pi
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns tau
  */
 export var createBigNumberTau = memoize(function (BigNumber) {
   return createBigNumberPi(BigNumber).times(2);
 }, {
   hasher
 });
 /**
  * Create a hash for a BigNumber constructor function. The created has is
  * the configured precision
@@ -51,7 +52,6 @@ export var createBigNumberTau = memoize(function (BigNumber) {
  * @return {number} precision
  * @private
  */
 function hasher(args) {
   return args[0].precision;
 }

package/lib/esm/utils/bignumber/formatter.js CHANGED Viewed

@@ -1,4 +1,5 @@
 import { isInteger } from '../number.js';
 /**
  * Formats a BigNumber in a given base
  * @param {BigNumber} n
@@ -6,50 +7,40 @@ import { isInteger } from '../number.js';
  * @param {number} size
  * @returns {string}
  */
 function formatBigNumberToBase(n, base, size) {
   var BigNumberCtor = n.constructor;
   var big2 = new BigNumberCtor(2);
   var suffix = '';
   if (size) {
     if (size < 1) {
       throw new Error('size must be in greater than 0');
     }
     if (!isInteger(size)) {
       throw new Error('size must be an integer');
     }
     if (n.greaterThan(big2.pow(size - 1).sub(1)) || n.lessThan(big2.pow(size - 1).mul(-1))) {
       throw new Error("Value must be in range [-2^".concat(size - 1, ", 2^").concat(size - 1, "-1]"));
     }
     if (!n.isInteger()) {
       throw new Error('Value must be an integer');
     }
     if (n.lessThan(0)) {
       n = n.add(big2.pow(size));
     }
     suffix = "i".concat(size);
   }
   switch (base) {
     case 2:
       return "".concat(n.toBinary()).concat(suffix);
     case 8:
       return "".concat(n.toOctal()).concat(suffix);
     case 16:
       return "".concat(n.toHexadecimal()).concat(suffix);
     default:
       throw new Error("Base ".concat(base, " not supported "));
   }
 }
 /**
  * Convert a BigNumber to a formatted string representation.
  *
@@ -131,119 +122,108 @@ function formatBigNumberToBase(n, base, size) {
  * @param {Object | Function | number} [options]
  * @return {string} str The formatted value
  */
 export function format(value, options) {
   if (typeof options === 'function') {
     // handle format(value, fn)
     return options(value);
-  } // handle special cases
+  }
+  // handle special cases
   if (!value.isFinite()) {
     return value.isNaN() ? 'NaN' : value.gt(0) ? 'Infinity' : '-Infinity';
-  } // default values for options
+  }
+  // default values for options
   var notation = 'auto';
   var precision;
   var wordSize;
   if (options !== undefined) {
     // determine notation from options
     if (options.notation) {
       notation = options.notation;
-    } // determine precision from options
+    }
+    // determine precision from options
     if (typeof options === 'number') {
       precision = options;
     } else if (options.precision) {
       precision = options.precision;
     }
     if (options.wordSize) {
       wordSize = options.wordSize;
       if (typeof wordSize !== 'number') {
         throw new Error('Option "wordSize" must be a number');
       }
     }
-  } // handle the various notations
+  }
+  // handle the various notations
   switch (notation) {
     case 'fixed':
       return toFixed(value, precision);
     case 'exponential':
       return toExponential(value, precision);
     case 'engineering':
       return toEngineering(value, precision);
     case 'bin':
       return formatBigNumberToBase(value, 2, wordSize);
     case 'oct':
       return formatBigNumberToBase(value, 8, wordSize);
     case 'hex':
       return formatBigNumberToBase(value, 16, wordSize);
     case 'auto':
       {
         // determine lower and upper bound for exponential notation.
         // TODO: implement support for upper and lower to be BigNumbers themselves
         var lowerExp = options && options.lowerExp !== undefined ? options.lowerExp : -3;
-        var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5; // handle special case zero
+        var upperExp = options && options.upperExp !== undefined ? options.upperExp : 5;
-        if (value.isZero()) return '0'; // determine whether or not to output exponential notation
+        // handle special case zero
+        if (value.isZero()) return '0';
+        // determine whether or not to output exponential notation
         var str;
         var rounded = value.toSignificantDigits(precision);
         var exp = rounded.e;
         if (exp >= lowerExp && exp < upperExp) {
           // normal number notation
           str = rounded.toFixed();
         } else {
           // exponential notation
           str = toExponential(value, precision);
-        } // remove trailing zeros after the decimal point
+        }
+        // remove trailing zeros after the decimal point
         return str.replace(/((\.\d*?)(0+))($|e)/, function () {
           var digits = arguments[2];
           var e = arguments[4];
           return digits !== '.' ? digits + e : e;
         });
       }
     default:
       throw new Error('Unknown notation "' + notation + '". ' + 'Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.');
   }
 }
 /**
  * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
  * @param {BigNumber | string} value
  * @param {number} [precision]        Optional number of significant figures to return.
  */
 export function toEngineering(value, precision) {
   // find nearest lower multiple of 3 for exponent
   var e = value.e;
-  var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3; // find difference in exponents, and calculate the value without exponent
+  var newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
+  // find difference in exponents, and calculate the value without exponent
   var valueWithoutExp = value.mul(Math.pow(10, -newExp));
   var valueStr = valueWithoutExp.toPrecision(precision);
   if (valueStr.indexOf('e') !== -1) {
     valueStr = valueWithoutExp.toString();
   }
   return valueStr + 'e' + (e >= 0 ? '+' : '') + newExp.toString();
 }
 /**
  * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
  * @param {BigNumber} value
@@ -252,7 +232,6 @@ export function toEngineering(value, precision) {
  *                              is used.
  * @returns {string} str
  */
 export function toExponential(value, precision) {
   if (precision !== undefined) {
     return value.toExponential(precision - 1); // Note the offset of one
@@ -260,13 +239,13 @@ export function toExponential(value, precision) {
     return value.toExponential();
   }
 }
 /**
  * Format a number with fixed notation.
  * @param {BigNumber} value
  * @param {number} [precision=undefined] Optional number of decimals after the
  *                                       decimal point. Undefined by default.
  */
 export function toFixed(value, precision) {
   return value.toFixed(precision);
 }