mathjs 11.2.1 → 11.3.1

package/lib/esm/function/arithmetic/multiplyScalar.js

@@ -6,7 +6,6 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _re
   var {
     typed
   } = _ref;
-
   /**
    * Multiply two scalar values, `x * y`.
    * This function is meant for internal use: it is used by the public function

package/lib/esm/function/arithmetic/norm.js

@@ -17,7 +17,6 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
     ctranspose,
     eigs
   } = _ref;
-
   /**
    * Calculate the norm of a number, vector or matrix.
    *
@@ -82,47 +81,45 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
       return _norm(x, p);
     }
   });
+
   /**
    * Calculate the plus infinity norm for a vector
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
   function _vectorNormPlusInfinity(x) {
     // norm(x, Infinity) = max(abs(x))
-    var pinf = 0; // skip zeros since abs(0) === 0
-
+    var pinf = 0;
+    // skip zeros since abs(0) === 0
     x.forEach(function (value) {
       var v = abs(value);
-
       if (larger(v, pinf)) {
         pinf = v;
       }
     }, true);
     return pinf;
   }
+
   /**
    * Calculate the minus infinity norm for a vector
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _vectorNormMinusInfinity(x) {
     // norm(x, -Infinity) = min(abs(x))
-    var ninf; // skip zeros since abs(0) === 0
-
+    var ninf;
+    // skip zeros since abs(0) === 0
     x.forEach(function (value) {
       var v = abs(value);
-
       if (!ninf || smaller(v, ninf)) {
         ninf = v;
       }
     }, true);
     return ninf || 0;
   }
+
   /**
    * Calculate the norm for a vector
    * @param {Matrix} x
@@ -130,48 +127,40 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _vectorNorm(x, p) {
     // check p
     if (p === Number.POSITIVE_INFINITY || p === 'inf') {
       return _vectorNormPlusInfinity(x);
     }
-
     if (p === Number.NEGATIVE_INFINITY || p === '-inf') {
       return _vectorNormMinusInfinity(x);
     }
-
     if (p === 'fro') {
       return _norm(x, 2);
     }
-
     if (typeof p === 'number' && !isNaN(p)) {
       // check p != 0
       if (!equalScalar(p, 0)) {
         // norm(x, p) = sum(abs(xi) ^ p) ^ 1/p
-        var n = 0; // skip zeros since abs(0) === 0
-
+        var n = 0;
+        // skip zeros since abs(0) === 0
         x.forEach(function (value) {
           n = add(pow(abs(value), p), n);
         }, true);
         return pow(n, 1 / p);
       }
-
       return Number.POSITIVE_INFINITY;
-    } // invalid parameter value
-
-
+    }
+    // invalid parameter value
     throw new Error('Unsupported parameter value');
   }
+
   /**
    * Calculate the Frobenius norm for a matrix
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _matrixNormFrobenius(x) {
     // norm(x) = sqrt(sum(diag(x'x)))
     var fro = 0;
@@ -180,80 +169,72 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
     });
     return abs(sqrt(fro));
   }
+
   /**
    * Calculate the norm L1 for a matrix
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _matrixNormOne(x) {
     // norm(x) = the largest column sum
-    var c = []; // result
-
-    var maxc = 0; // skip zeros since abs(0) == 0
-
+    var c = [];
+    // result
+    var maxc = 0;
+    // skip zeros since abs(0) == 0
     x.forEach(function (value, index) {
       var j = index[1];
       var cj = add(c[j] || 0, abs(value));
-
       if (larger(cj, maxc)) {
         maxc = cj;
       }
-
       c[j] = cj;
     }, true);
     return maxc;
   }
+
   /**
    * Calculate the norm L2 for a matrix
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _matrixNormTwo(x) {
     // norm(x) = sqrt( max eigenvalue of A*.A)
     var sizeX = x.size();
-
     if (sizeX[0] !== sizeX[1]) {
       throw new RangeError('Invalid matrix dimensions');
     }
-
     var tx = ctranspose(x);
     var squaredX = multiply(tx, x);
     var eigenVals = eigs(squaredX).values.toArray();
     var rho = eigenVals[eigenVals.length - 1];
     return abs(sqrt(rho));
   }
+
   /**
    * Calculate the infinity norm for a matrix
    * @param {Matrix} x
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _matrixNormInfinity(x) {
     // norm(x) = the largest row sum
-    var r = []; // result
-
-    var maxr = 0; // skip zeros since abs(0) == 0
-
+    var r = [];
+    // result
+    var maxr = 0;
+    // skip zeros since abs(0) == 0
     x.forEach(function (value, index) {
       var i = index[0];
       var ri = add(r[i] || 0, abs(value));
-
       if (larger(ri, maxr)) {
         maxr = ri;
       }
-
       r[i] = ri;
     }, true);
     return maxr;
   }
+
   /**
    * Calculate the norm for a 2D Matrix (M*N)
    * @param {Matrix} x
@@ -261,29 +242,24 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _matrixNorm(x, p) {
     // check p
     if (p === 1) {
       return _matrixNormOne(x);
     }
-
     if (p === Number.POSITIVE_INFINITY || p === 'inf') {
       return _matrixNormInfinity(x);
     }
-
     if (p === 'fro') {
       return _matrixNormFrobenius(x);
     }
-
     if (p === 2) {
       return _matrixNormTwo(x);
     } // invalid parameter value
 
-
     throw new Error('Unsupported parameter value ' + p);
   }
+
   /**
    * Calculate the norm for an array
    * @param {Matrix} x
@@ -291,17 +267,15 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {number} Returns the norm
    * @private
    */
-
-
   function _norm(x, p) {
     // size
-    var sizeX = x.size(); // check if it is a vector
+    var sizeX = x.size();
 
+    // check if it is a vector
     if (sizeX.length === 1) {
       return _vectorNorm(x, p);
-    } // MxN matrix
-
-
+    }
+    // MxN matrix
     if (sizeX.length === 2) {
       if (sizeX[0] && sizeX[1]) {
         return _matrixNorm(x, p);

package/lib/esm/function/arithmetic/nthRoot.js

@@ -33,6 +33,7 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   });
+
   /**
    * Calculate the nth root of a value.
    * The principal nth root of a positive real number A, is the positive real
@@ -62,11 +63,9 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {number | BigNumber} [root=2]    The root.
    * @return {number | Complex | Array | Matrix} Returns the nth root of `a`
    */
-
   function complexErr() {
     throw new Error('Complex number not supported in function nthRoot. Use nthRoots instead.');
   }
-
   return typed(name, {
     number: nthRootNumber,
     'number, number': nthRootNumber,
@@ -114,6 +113,7 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
     Ss: matAlgo11xS0s,
     sS: false
   }));
+
   /**
    * Calculate the nth root of a for BigNumbers, solve x^root == a
    * https://rosettacode.org/wiki/Nth_root#JavaScript
@@ -121,42 +121,34 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {BigNumber} root
    * @private
    */
-
   function _bigNthRoot(a, root) {
     var precision = _BigNumber.precision;
-
     var Big = _BigNumber.clone({
       precision: precision + 2
     });
-
     var zero = new _BigNumber(0);
     var one = new Big(1);
     var inv = root.isNegative();
-
     if (inv) {
       root = root.neg();
     }
-
     if (root.isZero()) {
       throw new Error('Root must be non-zero');
     }
-
     if (a.isNegative() && !root.abs().mod(2).equals(1)) {
       throw new Error('Root must be odd when a is negative.');
-    } // edge cases zero and infinity
-
+    }
 
+    // edge cases zero and infinity
     if (a.isZero()) {
       return inv ? new Big(Infinity) : 0;
     }
-
     if (!a.isFinite()) {
       return inv ? zero : a;
     }
-
-    var x = a.abs().pow(one.div(root)); // If a < 0, we require that root is an odd integer,
+    var x = a.abs().pow(one.div(root));
+    // If a < 0, we require that root is an odd integer,
     // so (-1) ^ (1/root) = -1
-
     x = a.isNeg() ? x.neg() : x;
     return new _BigNumber((inv ? one.div(x) : x).toPrecision(precision));
   }

package/lib/esm/function/arithmetic/nthRoots.js

@@ -8,7 +8,6 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
     divideScalar,
     Complex
   } = _ref;
-
   /**
    * Each function here returns a real multiple of i as a Complex value.
    * @param  {number} val
@@ -24,21 +23,21 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
   }, function imagNeg(val) {
     return new Complex(0, -val);
   }];
+
   /**
    * Calculate the nth root of a Complex Number a using De Movire's Theorem.
    * @param  {Complex} a
    * @param  {number} root
    * @return {Array} array of n Complex Roots
    */
-
   function _nthComplexRoots(a, root) {
     if (root < 0) throw new Error('Root must be greater than zero');
     if (root === 0) throw new Error('Root must be non-zero');
     if (root % 1 !== 0) throw new Error('Root must be an integer');
     if (a === 0 || a.abs() === 0) return [new Complex(0, 0)];
     var aIsNumeric = typeof a === 'number';
-    var offset; // determine the offset (argument of a)/(pi/2)
-
+    var offset;
+    // determine the offset (argument of a)/(pi/2)
     if (aIsNumeric || a.re === 0 || a.im === 0) {
       if (aIsNumeric) {
         offset = 2 * +(a < 0); // numeric value on the real axis
@@ -53,27 +52,24 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
     var abs = a.abs();
     var roots = [];
     var r = Math.pow(abs, 1 / root);
-
     for (var k = 0; k < root; k++) {
       var halfPiFactor = (offset + 4 * k) / root;
       /**
        * If (offset + 4*k)/root is an integral multiple of pi/2
        * then we can produce a more exact result.
        */
-
       if (halfPiFactor === Math.round(halfPiFactor)) {
         roots.push(_calculateExactResult[halfPiFactor % 4](r));
         continue;
       }
-
       roots.push(new Complex({
         r,
         phi: (arg + 2 * Math.PI * k) / root
       }));
     }
-
     return roots;
   }
+
   /**
    * Calculate the nth roots of a value.
    * An nth root of a positive real number A,
@@ -106,8 +102,6 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param {number | BigNumber | Fraction | Complex} x Number to be rounded
    * @return {number | BigNumber | Fraction | Complex}            Rounded value
    */
-
-
   return typed(name, {
     Complex: function Complex(x) {
       return _nthComplexRoots(x, 2);

package/lib/esm/function/arithmetic/pow.js

@@ -16,7 +16,6 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     fraction,
     Complex
   } = _ref;
-
   /**
    * Calculates the power of x to y, `x ^ y`.
    *
@@ -69,11 +68,9 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     'Fraction, Fraction': function FractionFraction(x, y) {
       var result = x.pow(y);
-
       if (result != null) {
         return result;
       }
-
       if (config.predictable) {
         throw new Error('Result of pow is non-rational and cannot be expressed as a fraction');
       } else {
@@ -92,6 +89,7 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x.pow(y);
     }
   });
+
   /**
    * Calculates the power of x to y, x^y, for two numbers.
    * @param {number} x
@@ -99,7 +97,6 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | Complex} res
    * @private
    */
-
   function _pow(x, y) {
     // Alternatively could define a 'realmode' config option or something, but
     // 'predictable' will work for now
@@ -108,37 +105,38 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       try {
         var yFrac = fraction(y);
         var yNum = number(yFrac);
-
         if (y === yNum || Math.abs((y - yNum) / y) < 1e-14) {
           if (yFrac.d % 2 === 1) {
             return (yFrac.n % 2 === 0 ? 1 : -1) * Math.pow(-x, y);
           }
         }
-      } catch (ex) {// fraction() throws an error if y is Infinity, etc.
-      } // Unable to express y as a fraction, so continue on
+      } catch (ex) {
+        // fraction() throws an error if y is Infinity, etc.
+      }
+
+      // Unable to express y as a fraction, so continue on
+    }
 
-    } // **for predictable mode** x^Infinity === NaN if x < -1
+    // **for predictable mode** x^Infinity === NaN if x < -1
     // N.B. this behavour is different from `Math.pow` which gives
     // (-2)^Infinity === Infinity
-
-
     if (config.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
       return NaN;
     }
-
     if (isInteger(y) || x >= 0 || config.predictable) {
       return powNumber(x, y);
     } else {
       // TODO: the following infinity checks are duplicated from powNumber. Deduplicate this somehow
+
       // 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 new Complex(x, 0).pow(y, 0);
     }
   }
+
   /**
    * Calculate the power of a 2d array
    * @param {Array} x     must be a 2 dimensional, square matrix
@@ -146,24 +144,18 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Array}
    * @private
    */
-
-
   function _powArray(x, y) {
     if (!isInteger(y)) {
       throw new TypeError('For A^b, b must be an integer (value is ' + y + ')');
-    } // verify that A is a 2 dimensional square matrix
-
-
+    }
+    // verify that A is a 2 dimensional square matrix
     var s = size(x);
-
     if (s.length !== 2) {
       throw new Error('For A^b, A must be 2 dimensional (A has ' + s.length + ' dimensions)');
     }
-
     if (s[0] !== s[1]) {
       throw new Error('For A^b, A must be square (size is ' + s[0] + 'x' + s[1] + ')');
     }
-
     if (y < 0) {
       try {
         return _powArray(inv(x), -y);
@@ -171,25 +163,21 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
         if (error.message === 'Cannot calculate inverse, determinant is zero') {
           throw new TypeError('For A^b, when A is not invertible, b must be a positive integer (value is ' + y + ')');
         }
-
         throw error;
       }
     }
-
     var res = identity(s[0]).valueOf();
     var px = x;
-
     while (y >= 1) {
       if ((y & 1) === 1) {
         res = multiply(px, res);
       }
-
       y >>= 1;
       px = multiply(px, px);
     }
-
     return res;
   }
+
   /**
    * Calculate the power of a 2d matrix
    * @param {Matrix} x     must be a 2 dimensional, square matrix
@@ -197,8 +185,6 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @returns {Matrix}
    * @private
    */
-
-
   function _powMatrix(x, y) {
     return matrix(_powArray(x.valueOf(), y));
   }

package/lib/esm/function/arithmetic/round.js

@@ -27,6 +27,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
   var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
+
   /**
    * Round a value towards the nearest integer.
    * For matrices, the function is evaluated element wise.
@@ -62,7 +63,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
-
   return typed(name, {
     number: roundNumber,
     'number, number': roundNumber,
@@ -70,7 +70,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
-
       return new BigNumber(x).toDecimalPlaces(n.toNumber());
     },
     Complex: function Complex(x) {
@@ -80,16 +79,13 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (n % 1) {
         throw new TypeError(NO_INT);
       }
-
       return x.round(n);
     },
     'Complex, BigNumber': function ComplexBigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
-
       var _n = n.toNumber();
-
       return x.round(_n);
     },
     BigNumber: function BigNumber(x) {
@@ -99,7 +95,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
-
       return x.toDecimalPlaces(n.toNumber());
     },
     Fraction: function Fraction(x) {
@@ -109,14 +104,12 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (n % 1) {
         throw new TypeError(NO_INT);
       }
-
       return x.round(n);
     },
     'Fraction, BigNumber': function FractionBigNumber(x, n) {
       if (!n.isInteger()) {
         throw new TypeError(NO_INT);
       }
-
       return x.round(n.toNumber());
     },
     // deep map collection, skip zeros since round(0) = 0
@@ -137,7 +130,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
         // do not execute algorithm, result will be a zero matrix
         return zeros(y.size(), y.storage());
       }
-
       return matAlgo12xSfs(y, x, self, true);
     }),
     'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(self => (x, y) => {
@@ -146,7 +138,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
         // do not execute algorithm, result will be a zero matrix
         return zeros(y.size(), y.storage());
       }
-
       return matAlgo14xDs(y, x, self, true);
     }),
     'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(self => (x, y) => {

package/lib/esm/function/arithmetic/sign.js

@@ -10,7 +10,6 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
     complex,
     Fraction: _Fraction
   } = _ref;
-
   /**
    * Compute the sign of a value. The sign of a value x is:
    *
@@ -58,7 +57,6 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
       if (!x._isDerived() && x.units[0].unit.offset !== 0) {
         throw new TypeError('sign is ambiguous for units with offset');
       }
-
       return typed.find(self, x.valueType())(x.value);
     })
   });

package/lib/esm/function/arithmetic/sqrt.js

@@ -7,7 +7,6 @@ export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     Complex
   } = _ref;
-
   /**
    * Calculate the square root of a value.
    *
@@ -52,13 +51,13 @@ export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x.pow(0.5);
     }
   });
+
   /**
    * Calculate sqrt for a number
    * @param {number} x
    * @returns {number | Complex} Returns the square root of x
    * @private
    */
-
   function _sqrtNumber(x) {
     if (isNaN(x)) {
       return NaN;

package/lib/esm/function/arithmetic/square.js

@@ -6,7 +6,6 @@ export var createSquare = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Compute the square of a value, `x * x`.
    * To avoid confusion with multiplying a square matrix by itself,