mathjs 10.6.2 → 11.0.0

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
 import { isMatrix } from '../../utils/is.js';
-import { extend } from '../../utils/object.js';
 import { arraySize } from '../../utils/array.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'multiply';
 var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'equalScalar', 'dot'];
 export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -15,11 +14,11 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     dot
   } = _ref;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
 
@@ -819,17 +818,17 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  return typed(name, extend({
+  return typed(name, multiplyScalar, {
     // we extend the signatures of multiplyScalar with signatures dealing with matrices
-    'Array, Array': function ArrayArray(x, y) {
+    'Array, Array': typed.referTo('Matrix, Matrix', selfMM => (x, y) => {
       // check dimensions
       _validateMatrixDimensions(arraySize(x), arraySize(y)); // use dense matrix implementation
 
 
-      var m = this(matrix(x), matrix(y)); // return array or scalar
+      var m = selfMM(matrix(x), matrix(y)); // return array or scalar
 
       return isMatrix(m) ? m.valueOf() : m;
-    },
+    }),
     'Matrix, Matrix': function MatrixMatrix(x, y) {
       // dimensions
       var xsize = x.size();
@@ -858,43 +857,40 @@ export var createMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return _multiplyMatrixMatrix(x, y);
     },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use Matrix * Matrix implementation
-      return this(x, matrix(y));
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
+    'Matrix, Array': typed.referTo('Matrix,Matrix', selfMM => (x, y) => selfMM(x, matrix(y))),
+    'Array, Matrix': typed.referToSelf(self => (x, y) => {
       // use Matrix * Matrix implementation
-      return this(matrix(x, y.storage()), y);
-    },
+      return self(matrix(x, y.storage()), y);
+    }),
     'SparseMatrix, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, multiplyScalar, false);
+      return matAlgo11xS0s(x, y, multiplyScalar, false);
     },
     'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, multiplyScalar, false);
+      return matAlgo14xDs(x, y, multiplyScalar, false);
     },
     'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm11(y, x, multiplyScalar, true);
+      return matAlgo11xS0s(y, x, multiplyScalar, true);
     },
     'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, multiplyScalar, true);
+      return matAlgo14xDs(y, x, multiplyScalar, true);
     },
     'Array, any': function ArrayAny(x, y) {
       // use matrix implementation
-      return algorithm14(matrix(x), y, multiplyScalar, false).valueOf();
+      return matAlgo14xDs(matrix(x), y, multiplyScalar, false).valueOf();
     },
     'any, Array': function anyArray(x, y) {
       // use matrix implementation
-      return algorithm14(matrix(y), x, multiplyScalar, true).valueOf();
+      return matAlgo14xDs(matrix(y), x, multiplyScalar, true).valueOf();
     },
     'any, any': multiplyScalar,
-    'any, any, ...any': function anyAnyAny(x, y, rest) {
-      var result = this(x, y);
+    'any, any, ...any': typed.referToSelf(self => (x, y, rest) => {
+      var result = self(x, y);
 
       for (var i = 0; i < rest.length; i++) {
-        result = this(result, rest[i]);
+        result = self(result, rest[i]);
       }
 
       return result;
-    }
-  }, multiplyScalar.signatures));
+    })
+  });
 });

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

@@ -30,18 +30,7 @@ export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _re
     '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

@@ -75,10 +75,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);
     },

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

@@ -1,10 +1,9 @@
 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'];
@@ -15,26 +14,24 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
     equalScalar,
     BigNumber: _BigNumber
   } = _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
   });
   /**
    * Calculate the nth root of a value.
@@ -66,89 +63,57 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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: 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

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

@@ -1,8 +1,8 @@
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 import { roundNumber } from '../../plain/number/index.js';
 var NO_INT = 'Number of decimals in function round must be an integer';
 var name = 'round';
@@ -16,15 +16,15 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber,
     DenseMatrix
   } = _ref;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   /**
@@ -119,41 +119,39 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return x.round(n.toNumber());
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since round(0) = 0
-      return deepMap(x, this, true);
-    },
-    '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);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
+    // deep map collection, skip zeros since round(0) = 0
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo11xS0s(x, y, self, false);
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo14xDs(x, y, self, false);
+    }),
+    'Array, number | BigNumber': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | Complex | BigNumber | Fraction, SparseMatrix': function numberComplexBigNumberFractionSparseMatrix(x, y) {
+      return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+    }),
+    'number | Complex | BigNumber | Fraction, SparseMatrix': typed.referToSelf(self => (x, y) => {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
         return zeros(y.size(), y.storage());
       }
 
-      return algorithm12(y, x, this, true);
-    },
-    'number | Complex | BigNumber | Fraction, DenseMatrix': function numberComplexBigNumberFractionDenseMatrix(x, y) {
+      return matAlgo12xSfs(y, x, self, true);
+    }),
+    'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(self => (x, y) => {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
         return zeros(y.size(), y.storage());
       }
 
-      return algorithm14(y, x, this, true);
-    },
-    'number | Complex | BigNumber | Fraction, Array': function numberComplexBigNumberFractionArray(x, y) {
+      return matAlgo14xDs(y, x, self, true);
+    }),
+    'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    }
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    })
   });
 });

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

@@ -52,16 +52,14 @@ export var createSign = /* #__PURE__ */factory(name, dependencies, _ref => {
     Fraction: function Fraction(x) {
       return new _Fraction(x.s, 1);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sign(0) = 0
-      return deepMap(x, this, true);
-    },
-    Unit: function Unit(x) {
+    // deep map collection, skip zeros since sign(0) = 0
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true)),
+    Unit: typed.referToSelf(self => x => {
       if (!x._isDerived() && x.units[0].unit.offset !== 0) {
         throw new TypeError('sign is ambiguous for units with offset');
       }
 
-      return this(x.value);
-    }
+      return typed.find(self, x.valueType())(x.value);
+    })
   });
 });

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 var name = 'sqrt';
 var dependencies = ['config', 'typed', 'Complex'];
 export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -12,7 +11,9 @@ export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Calculate the square root of a value.
    *
-   * For matrices, the function is evaluated element wise.
+   * For matrices, if you want the matrix square root of a square matrix,
+   * use the `sqrtm` function. If you wish to apply `sqrt` elementwise to
+   * a matrix M, use `math.map(M, math.sqrt)`.
    *
    * Syntax:
    *
@@ -28,9 +29,9 @@ export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    square, multiply, cube, cbrt, sqrtm
    *
-   * @param {number | BigNumber | Complex | Array | Matrix | Unit} x
+   * @param {number | BigNumber | Complex | Unit} x
    *            Value for which to calculate the square root.
-   * @return {number | BigNumber | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | Complex | Unit}
    *            Returns the square root of `x`
    */
   return typed('sqrt', {
@@ -46,10 +47,6 @@ export var createSqrt = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _sqrtNumber(x.toNumber());
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sqrt(0) = 0
-      return deepMap(x, this, true);
-    },
     Unit: function Unit(x) {
       // Someday will work for complex units when they are implemented
       return x.pow(0.5);

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { squareNumber } from '../../plain/number/index.js';
 var name = 'square';
 var dependencies = ['typed'];
@@ -10,7 +9,9 @@ export var createSquare = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * Compute the square of a value, `x * x`.
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with multiplying a square matrix by itself,
+   * this function does not apply to matrices. If you wish to square
+   * every element of a matrix, see the examples.
    *
    * Syntax:
    *
@@ -23,15 +24,15 @@ export var createSquare = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.pow(3, 2)           // returns number 9
    *    math.multiply(3, 3)      // returns number 9
    *
-   *    math.square([1, 2, 3, 4])  // returns Array [1, 4, 9, 16]
+   *    math.map([1, 2, 3, 4], math.square)  // returns Array [1, 4, 9, 16]
    *
    * See also:
    *
    *    multiply, cube, sqrt, pow
    *
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x
    *            Number for which to calculate the square
-   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit}
+   * @return {number | BigNumber | Fraction | Complex | Unit}
    *            Squared value
    */
   return typed(name, {
@@ -45,10 +46,6 @@ export var createSquare = /* #__PURE__ */factory(name, dependencies, _ref => {
     Fraction: function Fraction(x) {
       return x.mul(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since square(0) = 0
-      return deepMap(x, this, true);
-    },
     Unit: function Unit(x) {
       return x.pow(2);
     }