mathjs 8.1.0 → 12.2.1

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

@@ -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

@@ -1,40 +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);
+}, {
+  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);
+}, {
+  hasher
+});
+
 /**
  * Calculate BigNumber pi.
  * @param {function} BigNumber   BigNumber constructor
  * @returns {BigNumber} Returns pi
  */
-
 export var createBigNumberPi = memoize(function (BigNumber) {
   return BigNumber.acos(-1);
-}, hasher);
+}, {
+  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);
+}, {
+  hasher
+});
+
 /**
  * Create a hash for a BigNumber constructor function. The created has is
  * the configured precision
@@ -43,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

@@ -1,3 +1,46 @@
+import { isInteger } from '../number.js';
+
+/**
+ * Formats a BigNumber in a given base
+ * @param {BigNumber} n
+ * @param {number} base
+ * @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.
  *
@@ -25,6 +68,20 @@
  *                                          Lower bound is included, upper bound
  *                                          is excluded.
  *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
  *                     {number} precision   A number between 0 and 16 to round
  *                                          the digits of the number.
  *                                          In case of notations 'exponential',
@@ -69,95 +126,105 @@ 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) {
+    } else if (options.precision !== undefined) {
       precision = options.precision;
     }
-  } // handle the various notations
-
+    if (options.wordSize) {
+      wordSize = options.wordSize;
+      if (typeof wordSize !== 'number') {
+        throw new Error('Option "wordSize" must be a number');
+      }
+    }
+  }
 
+  // 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", or "fixed".');
+      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 {BigNumber} 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();
+    var BigNumber = value.constructor;
+    valueStr = new BigNumber(valueStr).toFixed();
   }
-
   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
@@ -166,7 +233,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
@@ -174,13 +240,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);
 }