mathjs 8.1.0 → 12.2.1

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

@@ -2,11 +2,10 @@ import { factory } from '../../utils/factory.js';
 import { multiplyNumber } from '../../plain/number/index.js';
 var name = 'multiplyScalar';
 var dependencies = ['typed'];
-export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Multiply two scalar values, `x * y`.
    * This function is meant for internal use: it is used by the public function
@@ -30,18 +29,7 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, (_r
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.mul(y);
     },
-    'number | Fraction | BigNumber | Complex, Unit': function numberFractionBigNumberComplexUnit(x, y) {
-      var res = y.clone();
-      res.value = res.value === null ? res._normalize(x) : this(res.value, x);
-      return res;
-    },
-    'Unit, number | Fraction | BigNumber | Complex': function UnitNumberFractionBigNumberComplex(x, y) {
-      var res = x.clone();
-      res.value = res.value === null ? res._normalize(y) : this(res.value, y);
-      return res;
-    },
-    'Unit, Unit': function UnitUnit(x, y) {
-      return x.multiply(y);
-    }
+    'number | Fraction | BigNumber | Complex, Unit': (x, y) => y.multiply(x),
+    'Unit, number | Fraction | BigNumber | Complex | Unit': (x, y) => x.multiply(y)
   });
 });

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

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 var name = 'norm';
 var dependencies = ['typed', 'abs', 'add', 'pow', 'conj', 'sqrt', 'multiply', 'equalScalar', 'larger', 'smaller', 'matrix', 'ctranspose', 'eigs'];
-export var createNorm = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     abs,
@@ -17,7 +17,6 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     ctranspose,
     eigs
   } = _ref;
-
   /**
    * Calculate the norm of a number, vector or matrix.
    *
@@ -75,10 +74,6 @@ export var createNorm = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     Matrix: function Matrix(x) {
       return _norm(x, 2);
     },
-    'number | Complex | BigNumber | boolean, number | BigNumber | string': function numberComplexBigNumberBooleanNumberBigNumberString(x) {
-      // ignore second parameter, TODO: remove the option of second parameter for these types
-      return this(x);
-    },
     'Array, number | BigNumber | string': function ArrayNumberBigNumberString(x, p) {
       return _norm(matrix(x), p);
     },
@@ -86,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
@@ -134,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;
@@ -184,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;
-    var rho = eigenVals.get([eigenVals.size()[0] - 1]);
+    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
@@ -265,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
@@ -295,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

@@ -1,41 +1,41 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm06 } from '../../type/matrix/utils/algorithm06.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { nthRootNumber } from '../../plain/number/index.js';
 var name = 'nthRoot';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber'];
-export var createNthRoot = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'concat'];
+export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     equalScalar,
-    BigNumber: _BigNumber
+    BigNumber: _BigNumber,
+    concat
   } = _ref;
-  var algorithm01 = createAlgorithm01({
+  var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm06 = createAlgorithm06({
+  var matAlgo06xS0S0 = createMatAlgo06xS0S0({
     typed,
     equalScalar
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
   });
+
   /**
    * Calculate the nth root of a value.
    * The principal nth root of a positive real number A, is the positive real
@@ -52,9 +52,9 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, (_ref) =>
    *
    * Examples:
    *
-   *     math.nthRoot(9, 2)    // returns 3, as 3^2 == 9
-   *     math.sqrt(9)          // returns 3, as 3^2 == 9
-   *     math.nthRoot(64, 3)   // returns 4, as 4^3 == 64
+   *     math.nthRoot(9, 2)    // returns 3 (since 3^2 == 9)
+   *     math.sqrt(9)          // returns 3 (since 3^2 == 9)
+   *     math.nthRoot(64, 3)   // returns 4 (since 4^3 == 64)
    *
    * See also:
    *
@@ -65,92 +65,57 @@ 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`
    */
-
-  var complexErr = '' + 'Complex number not supported in function nthRoot. ' + 'Use nthRoots instead.';
+  function complexErr() {
+    throw new Error('Complex number not supported in function nthRoot. Use nthRoots instead.');
+  }
   return typed(name, {
-    number: function number(x) {
-      return nthRootNumber(x, 2);
-    },
+    number: nthRootNumber,
     'number, number': nthRootNumber,
-    BigNumber: function BigNumber(x) {
-      return _bigNthRoot(x, new _BigNumber(2));
-    },
-    Complex: function Complex(x) {
-      throw new Error(complexErr);
-    },
-    'Complex, number': function ComplexNumber(x, y) {
-      throw new Error(complexErr);
-    },
+    BigNumber: x => _bigNthRoot(x, new _BigNumber(2)),
     'BigNumber, BigNumber': _bigNthRoot,
-    'Array | Matrix': function ArrayMatrix(x) {
-      return this(x, 2);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
+    Complex: complexErr,
+    'Complex, number': complexErr,
+    Array: typed.referTo('DenseMatrix,number', selfDn => x => selfDn(matrix(x), 2).valueOf()),
+    DenseMatrix: typed.referTo('DenseMatrix,number', selfDn => x => selfDn(x, 2)),
+    SparseMatrix: typed.referTo('SparseMatrix,number', selfSn => x => selfSn(x, 2)),
+    'SparseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => {
       // density must be one (no zeros in matrix)
       if (y.density() === 1) {
         // sparse + sparse
-        return algorithm06(x, y, this);
+        return matAlgo06xS0S0(x, y, self);
       } else {
         // throw exception
         throw new Error('Root must be non-zero');
       }
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
+    }),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => {
       // density must be one (no zeros in matrix)
       if (y.density() === 1) {
         // dense + sparse
-        return algorithm01(x, y, this, false);
+        return matAlgo01xDSid(x, y, self, false);
       } else {
         // throw exception
         throw new Error('Root must be non-zero');
       }
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
+    }),
+    'Array, SparseMatrix': typed.referTo('DenseMatrix,SparseMatrix', selfDS => (x, y) => selfDS(matrix(x), y)),
+    'number | BigNumber, SparseMatrix': typed.referToSelf(self => (x, y) => {
       // density must be one (no zeros in matrix)
       if (y.density() === 1) {
         // sparse - scalar
-        return algorithm11(y, x, this, true);
+        return matAlgo11xS0s(y, x, self, true);
       } else {
         // throw exception
         throw new Error('Root must be non-zero');
       }
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y)).valueOf();
-    }
-  });
+    })
+  }, matrixAlgorithmSuite({
+    scalar: 'number | BigNumber',
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: false
+  }));
+
   /**
    * Calculate the nth root of a for BigNumbers, solve x^root == a
    * https://rosettacode.org/wiki/Nth_root#JavaScript
@@ -158,47 +123,39 @@ 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));
   }
 });
-export var createNthRootNumber = /* #__PURE__ */factory(name, ['typed'], (_ref2) => {
+export var createNthRootNumber = /* #__PURE__ */factory(name, ['typed'], _ref2 => {
   var {
     typed
   } = _ref2;

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

@@ -1,14 +1,13 @@
 import { factory } from '../../utils/factory.js';
 var name = 'nthRoots';
 var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
-export var createNthRoots = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     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
@@ -48,32 +47,28 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, (_ref) =>
         offset = 2 * +(a.im < 0) + 1; // complex value on the imaginary axis
       }
     }
-
     var arg = a.arg();
     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,
+        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,
@@ -92,22 +87,21 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, (_ref) =>
    *    //   {re: 1, im: 0},
    *    //   {re: -1, im: 0}
    *    // ]
-   *    nthRoots(1, 3)
+   *    math.nthRoots(1, 3)
    *    // returns [
    *    //   { re: 1, im: 0 },
    *    //   { re: -0.4999999999999998, im: 0.8660254037844387 },
    *    //   { re: -0.5000000000000004, im: -0.8660254037844385 }
-   *    ]
+   *    // ]
    *
    * See also:
    *
    *    nthRoot, pow, sqrt
    *
    * @param {number | BigNumber | Fraction | Complex} x Number to be rounded
-   * @return {number | BigNumber | Fraction | Complex}            Rounded value
+   * @param {number} [root=2] Optional root, default value is 2
+   * @return {number | BigNumber | Fraction | Complex} Returns the nth roots
    */
-
-
   return typed(name, {
     Complex: function Complex(x) {
       return _nthComplexRoots(x, 2);