mathjs 11.2.0 → 11.3.0

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

@@ -4,16 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createMultiplyScalar = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var _index = require("../../plain/number/index.js");
-
 var name = 'multiplyScalar';
 var dependencies = ['typed'];
 var createMultiplyScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
   /**
    * Multiply two scalar values, `x * y`.
    * This function is meant for internal use: it is used by the public function

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

@@ -4,26 +4,23 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createNorm = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'norm';
 var dependencies = ['typed', 'abs', 'add', 'pow', 'conj', 'sqrt', 'multiply', 'equalScalar', 'larger', 'smaller', 'matrix', 'ctranspose', 'eigs'];
 var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      abs = _ref.abs,
-      add = _ref.add,
-      pow = _ref.pow,
-      conj = _ref.conj,
-      sqrt = _ref.sqrt,
-      multiply = _ref.multiply,
-      equalScalar = _ref.equalScalar,
-      larger = _ref.larger,
-      smaller = _ref.smaller,
-      matrix = _ref.matrix,
-      ctranspose = _ref.ctranspose,
-      eigs = _ref.eigs;
-
+    abs = _ref.abs,
+    add = _ref.add,
+    pow = _ref.pow,
+    conj = _ref.conj,
+    sqrt = _ref.sqrt,
+    multiply = _ref.multiply,
+    equalScalar = _ref.equalScalar,
+    larger = _ref.larger,
+    smaller = _ref.smaller,
+    matrix = _ref.matrix,
+    ctranspose = _ref.ctranspose,
+    eigs = _ref.eigs;
   /**
    * Calculate the norm of a number, vector or matrix.
    *
@@ -88,47 +85,45 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       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
@@ -136,48 +131,40 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * @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;
@@ -186,80 +173,72 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     });
     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
@@ -267,29 +246,24 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * @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
@@ -297,17 +271,15 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
    * @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/cjs/function/arithmetic/nthRoot.js

@@ -4,28 +4,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createNthRootNumber = exports.createNthRoot = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var _matAlgo01xDSid = require("../../type/matrix/utils/matAlgo01xDSid.js");
-
 var _matAlgo02xDS = require("../../type/matrix/utils/matAlgo02xDS0.js");
-
 var _matAlgo06xS0S = require("../../type/matrix/utils/matAlgo06xS0S0.js");
-
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
-
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
-
 var _index = require("../../plain/number/index.js");
-
 var name = 'nthRoot';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber'];
 var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      equalScalar = _ref.equalScalar,
-      _BigNumber = _ref.BigNumber;
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    _BigNumber = _ref.BigNumber;
   var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
     typed: typed
   });
@@ -45,6 +37,7 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     typed: typed,
     matrix: matrix
   });
+
   /**
    * Calculate the nth root of a value.
    * The principal nth root of a positive real number A, is the positive real
@@ -74,11 +67,9 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    * @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: _index.nthRootNumber,
     'number, number': _index.nthRootNumber,
@@ -150,6 +141,7 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     Ss: matAlgo11xS0s,
     sS: false
   }));
+
   /**
    * Calculate the nth root of a for BigNumbers, solve x^root == a
    * https://rosettacode.org/wiki/Nth_root#JavaScript
@@ -157,42 +149,34 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    * @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/cjs/function/arithmetic/nthRoots.js

@@ -4,17 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createNthRoots = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'nthRoots';
 var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
 var createNthRoots = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      config = _ref.config,
-      divideScalar = _ref.divideScalar,
-      Complex = _ref.Complex;
-
+    config = _ref.config,
+    divideScalar = _ref.divideScalar,
+    Complex = _ref.Complex;
   /**
    * Each function here returns a real multiple of i as a Complex value.
    * @param  {number} val
@@ -30,21 +27,21 @@ var createNthRoots = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   }, 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
@@ -59,27 +56,24 @@ var createNthRoots = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     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: 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,
@@ -112,8 +106,6 @@ var createNthRoots = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @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/cjs/function/arithmetic/pow.js

@@ -4,28 +4,22 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createPow = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var _number = require("../../utils/number.js");
-
 var _array = require("../../utils/array.js");
-
 var _index = require("../../plain/number/index.js");
-
 var name = 'pow';
 var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'inv', 'fraction', 'number', 'Complex'];
 var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      config = _ref.config,
-      identity = _ref.identity,
-      multiply = _ref.multiply,
-      matrix = _ref.matrix,
-      inv = _ref.inv,
-      number = _ref.number,
-      fraction = _ref.fraction,
-      Complex = _ref.Complex;
-
+    config = _ref.config,
+    identity = _ref.identity,
+    multiply = _ref.multiply,
+    matrix = _ref.matrix,
+    inv = _ref.inv,
+    number = _ref.number,
+    fraction = _ref.fraction,
+    Complex = _ref.Complex;
   /**
    * Calculates the power of x to y, `x ^ y`.
    *
@@ -78,11 +72,9 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
     },
     '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 {
@@ -101,6 +93,7 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       return x.pow(y);
     }
   });
+
   /**
    * Calculates the power of x to y, x^y, for two numbers.
    * @param {number} x
@@ -108,7 +101,6 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @return {number | Complex} res
    * @private
    */
-
   function _pow(x, y) {
     // Alternatively could define a 'realmode' config option or something, but
     // 'predictable' will work for now
@@ -117,37 +109,38 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       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 ((0, _number.isInteger)(y) || x >= 0 || config.predictable) {
       return (0, _index.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
@@ -155,24 +148,18 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @returns {Array}
    * @private
    */
-
-
   function _powArray(x, y) {
     if (!(0, _number.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 = (0, _array.arraySize)(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);
@@ -180,25 +167,21 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
         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
@@ -206,8 +189,6 @@ var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    * @returns {Matrix}
    * @private
    */
-
-
   function _powMatrix(x, y) {
     return matrix(_powArray(x.valueOf(), y));
   }