mathjs 8.1.0 → 12.2.1

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 createMultiplyScalar = exports.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
@@ -38,18 +34,10 @@ var createMultiplyScalar = /* #__PURE__ */(0, _factory.factory)(name, dependenci
       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;
+      return y.multiply(x);
     },
-    'Unit, Unit': function UnitUnit(x, y) {
+    'Unit, number | Fraction | BigNumber | Complex | Unit': function UnitNumberFractionBigNumberComplexUnit(x, y) {
       return x.multiply(y);
     }
   });
-});
-exports.createMultiplyScalar = createMultiplyScalar;
+});

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 createNorm = exports.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.
    *
@@ -81,10 +78,6 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     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);
     },
@@ -92,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
@@ -140,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;
@@ -190,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;
-    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
@@ -271,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
@@ -301,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);
@@ -320,5 +288,4 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       }
     }
   }
-});
-exports.createNorm = createNorm;
+});

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

@@ -4,51 +4,42 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createNthRootNumber = exports.createNthRoot = void 0;
-
 var _factory = require("../../utils/factory.js");
-
-var _algorithm = require("../../type/matrix/utils/algorithm01.js");
-
-var _algorithm2 = require("../../type/matrix/utils/algorithm02.js");
-
-var _algorithm3 = require("../../type/matrix/utils/algorithm06.js");
-
-var _algorithm4 = require("../../type/matrix/utils/algorithm11.js");
-
-var _algorithm5 = require("../../type/matrix/utils/algorithm13.js");
-
-var _algorithm6 = require("../../type/matrix/utils/algorithm14.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 dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'concat'];
+var createNthRoot = exports.createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix,
-      equalScalar = _ref.equalScalar,
-      _BigNumber = _ref.BigNumber;
-  var algorithm01 = (0, _algorithm.createAlgorithm01)({
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    _BigNumber = _ref.BigNumber,
+    concat = _ref.concat;
+  var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
     typed: typed
   });
-  var algorithm02 = (0, _algorithm2.createAlgorithm02)({
+  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm06 = (0, _algorithm3.createAlgorithm06)({
+  var matAlgo06xS0S0 = (0, _matAlgo06xS0S.createMatAlgo06xS0S0)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm11 = (0, _algorithm4.createAlgorithm11)({
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
     typed: typed,
     equalScalar: equalScalar
   });
-  var algorithm13 = (0, _algorithm5.createAlgorithm13)({
-    typed: typed
-  });
-  var algorithm14 = (0, _algorithm6.createAlgorithm14)({
-    typed: typed
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
   });
+
   /**
    * Calculate the nth root of a value.
    * The principal nth root of a positive real number A, is the positive real
@@ -65,9 +56,9 @@ var createNthRoot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *
    * 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:
    *
@@ -78,92 +69,81 @@ 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`
    */
-
-  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 (0, _index.nthRootNumber)(x, 2);
-    },
+    number: _index.nthRootNumber,
     'number, number': _index.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, BigNumber': _bigNthRoot,
-    'Array | Matrix': function ArrayMatrix(x) {
-      return this(x, 2);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // sparse + sparse
-        return algorithm06(x, y, this);
-      } 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) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // dense + sparse
-        return algorithm01(x, y, this, 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) {
-      // density must be one (no zeros in matrix)
-      if (y.density() === 1) {
-        // sparse - scalar
-        return algorithm11(y, x, this, 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();
-    }
-  });
+    Complex: complexErr,
+    'Complex, number': complexErr,
+    Array: typed.referTo('DenseMatrix,number', function (selfDn) {
+      return function (x) {
+        return selfDn(matrix(x), 2).valueOf();
+      };
+    }),
+    DenseMatrix: typed.referTo('DenseMatrix,number', function (selfDn) {
+      return function (x) {
+        return selfDn(x, 2);
+      };
+    }),
+    SparseMatrix: typed.referTo('SparseMatrix,number', function (selfSn) {
+      return function (x) {
+        return selfSn(x, 2);
+      };
+    }),
+    'SparseMatrix, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // sparse + sparse
+          return matAlgo06xS0S0(x, y, self);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    }),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // dense + sparse
+          return matAlgo01xDSid(x, y, self, false);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    }),
+    'Array, SparseMatrix': typed.referTo('DenseMatrix,SparseMatrix', function (selfDS) {
+      return function (x, y) {
+        return selfDS(matrix(x), y);
+      };
+    }),
+    'number | BigNumber, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // density must be one (no zeros in matrix)
+        if (y.density() === 1) {
+          // sparse - scalar
+          return matAlgo11xS0s(y, x, self, true);
+        } else {
+          // throw exception
+          throw new Error('Root must be non-zero');
+        }
+      };
+    })
+  }, 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
@@ -171,52 +151,42 @@ 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));
   }
 });
-exports.createNthRoot = createNthRoot;
-var createNthRootNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed'], function (_ref2) {
+var createNthRootNumber = exports.createNthRootNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed'], function (_ref2) {
   var typed = _ref2.typed;
   return typed(name, {
     number: _index.nthRootNumber,
     'number, number': _index.nthRootNumber
   });
-});
-exports.createNthRootNumber = createNthRootNumber;
+});