mathjs 10.6.2 → 11.0.0

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

@@ -3,9 +3,9 @@ import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
 import { nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.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';
 var name = 'ceil';
 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
 export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
@@ -44,15 +44,15 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     zeros,
     DenseMatrix
   } = _ref2;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   var ceilNumber = createCeilNumber({
@@ -133,32 +133,32 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, BigNumber': function FractionBigNumber(x, n) {
       return x.ceil(n.toNumber());
     },
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since ceil(0) = 0
-      return deepMap(x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
+      return deepMap(x, self, true);
+    }),
+    'Array, number | BigNumber': typed.referToSelf(self => (x, n) => {
       // deep map collection, skip zeros since ceil(0) = 0
-      return deepMap(x, i => this(i, n), 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);
-    },
-    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      return deepMap(x, i => self(i, n), 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);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
 
       if (y.storage() === 'dense') {
-        return algorithm14(y, x, this, true);
+        return matAlgo14xDs(y, x, self, true);
       }
 
-      return algorithm12(y, x, this, true);
-    }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

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

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

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { extend } from '../../utils/object.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 = 'divide';
 var dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
 export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -13,11 +13,11 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
     divideScalar,
     inv
   } = _ref;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   /**
@@ -62,14 +62,14 @@ export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
       return multiply(x, inv(y));
     },
     'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, divideScalar, false);
+      return matAlgo14xDs(x, y, divideScalar, false);
     },
     'SparseMatrix, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, divideScalar, false);
+      return matAlgo11xS0s(x, y, divideScalar, false);
     },
     'Array, any': function ArrayAny(x, y) {
       // use matrix implementation
-      return algorithm14(matrix(x), y, divideScalar, false).valueOf();
+      return matAlgo14xDs(matrix(x), y, divideScalar, false).valueOf();
     },
     'any, Array | Matrix': function anyArrayMatrix(x, y) {
       return multiply(x, inv(y));

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { typeOf } from '../../utils/is.js';
 var name = 'divideScalar';
 var dependencies = ['typed', 'numeric'];
 export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -33,23 +32,7 @@ export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.div(y);
     },
-    'Unit, number | Fraction | BigNumber': function UnitNumberFractionBigNumber(x, y) {
-      var res = x.clone(); // TODO: move the divide function to Unit.js, it uses internals of Unit
-
-      var one = numeric(1, typeOf(y));
-      res.value = this(res.value === null ? res._normalize(one) : res.value, y);
-      return res;
-    },
-    'number | Fraction | BigNumber, Unit': function numberFractionBigNumberUnit(x, y) {
-      var res = y.clone();
-      res = res.pow(-1); // TODO: move the divide function to Unit.js, it uses internals of Unit
-
-      var one = numeric(1, typeOf(x));
-      res.value = this(x, y.value === null ? y._normalize(one) : y.value);
-      return res;
-    },
-    'Unit, Unit': function UnitUnit(x, y) {
-      return x.divide(y);
-    }
+    'Unit, number | Complex | Fraction | BigNumber | Unit': (x, y) => x.divide(y),
+    'number | Fraction | Complex | BigNumber, Unit': (x, y) => y.divideInto(x)
   });
 });

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

@@ -1,11 +1,10 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
-import { createAlgorithm07 } from '../../type/matrix/utils/algorithm07.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'dotDivide';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix'];
 export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -16,30 +15,28 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
     divideScalar,
     DenseMatrix
   } = _ref;
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm07 = createAlgorithm07({
+  var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
     DenseMatrix
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Divide two matrices element wise. The function accepts both matrices and
@@ -68,51 +65,12 @@ export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Quotient, `x ./ y`
    */
 
-  return typed(name, {
-    'any, any': divideScalar,
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm07(x, y, divideScalar, false);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, divideScalar, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm03(x, y, divideScalar, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, divideScalar);
-    },
-    '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, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, divideScalar, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, divideScalar, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm12(y, x, divideScalar, true);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, divideScalar, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, divideScalar, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, divideScalar, true).valueOf();
-    }
-  });
+  return typed(name, matrixAlgorithmSuite({
+    elop: divideScalar,
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
 });

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm09 } from '../../type/matrix/utils/algorithm09.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 { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo09xS0Sf } from '../../type/matrix/utils/matAlgo09xS0Sf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'dotMultiply';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'multiplyScalar'];
 export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -13,23 +12,21 @@ export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref =
     equalScalar,
     multiplyScalar
   } = _ref;
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm09 = createAlgorithm09({
+  var matAlgo09xS0Sf = createMatAlgo09xS0Sf({
     typed,
     equalScalar
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Multiply two matrices element wise. The function accepts both matrices and
@@ -58,51 +55,10 @@ export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref =
    * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Multiplication of `x` and `y`
    */
 
-  return typed(name, {
-    'any, any': multiplyScalar,
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm09(x, y, multiplyScalar, false);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, multiplyScalar, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm02(x, y, multiplyScalar, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, multiplyScalar);
-    },
-    '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, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, multiplyScalar, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, multiplyScalar, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm11(y, x, multiplyScalar, true);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, multiplyScalar, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, multiplyScalar, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, multiplyScalar, true).valueOf();
-    }
-  });
+  return typed(name, matrixAlgorithmSuite({
+    elop: multiplyScalar,
+    SS: matAlgo09xS0Sf,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }));
 });

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

@@ -1,10 +1,9 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
-import { createAlgorithm07 } from '../../type/matrix/utils/algorithm07.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'dotPow';
 var dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix'];
 export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -15,27 +14,36 @@ export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     pow,
     DenseMatrix
   } = _ref;
-  var algorithm03 = createAlgorithm03({
+  var matAlgo03xDSf = createMatAlgo03xDSf({
     typed
   });
-  var algorithm07 = createAlgorithm07({
+  var matAlgo07xSSf = createMatAlgo07xSSf({
     typed,
     DenseMatrix
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
+  var powScalarSignatures = {};
+
+  for (var signature in pow.signatures) {
+    if (Object.prototype.hasOwnProperty.call(pow.signatures, signature)) {
+      if (!signature.includes('Matrix') && !signature.includes('Array')) {
+        powScalarSignatures[signature] = pow.signatures[signature];
+      }
+    }
+  }
+
+  var powScalar = typed(powScalarSignatures);
   /**
    * Calculates the power of x to y element wise.
    *
@@ -60,51 +68,11 @@ export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Complex | Unit | Array | Matrix}                     The value of `x` to the power `y`
    */
 
-  return typed(name, {
-    'any, any': pow,
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm07(x, y, pow, false);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm03(y, x, pow, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm03(x, y, pow, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, pow);
-    },
-    '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, any': function SparseMatrixAny(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm12(y, x, this, true);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    }
-  });
+  return typed(name, matrixAlgorithmSuite({
+    elop: powScalar,
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
 });

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { expNumber } from '../../plain/number/index.js';
 var name = 'exp';
 var dependencies = ['typed'];
@@ -9,8 +8,10 @@ export var createExp = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Calculate the exponent of a value.
-   * For matrices, the function is evaluated element wise.
+   * Calculate the exponential of a value.
+   * For matrices, if you want the matrix exponential of square matrix, use
+   * the `expm` function; if you want to take the exponential of each element,
+   * see the examples.
    *
    * Syntax:
    *
@@ -22,7 +23,7 @@ export var createExp = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    math.pow(math.e, 2)          // returns number 7.3890560989306495
    *    math.log(math.exp(2))        // returns number 2
    *
-   *    math.exp([1, 2, 3])
+   *    math.map([1, 2, 3], math.exp)
    *    // returns Array [
    *    //   2.718281828459045,
    *    //   7.3890560989306495,
@@ -31,10 +32,10 @@ export var createExp = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * See also:
    *
-   *    expm1, log, pow
+   *    expm1, expm, log, pow
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x  A number or matrix to exponentiate
-   * @return {number | BigNumber | Complex | Array | Matrix} Exponent of `x`
+   * @param {number | BigNumber | Complex} x  A number to exponentiate
+   * @return {number | BigNumber | Complex} Exponential of `x`
    */
   return typed(name, {
     number: expNumber,
@@ -43,10 +44,6 @@ export var createExp = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     BigNumber: function BigNumber(x) {
       return x.exp();
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // TODO: exp(sparse) should return a dense matrix since exp(0)==1
-      return deepMap(x, this);
     }
   });
 });

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { expm1Number } from '../../plain/number/index.js';
 var name = 'expm1';
 var dependencies = ['typed', 'Complex'];
@@ -11,7 +10,10 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * Calculate the value of subtracting 1 from the exponential value.
-   * For matrices, the function is evaluated element wise.
+   * This function is more accurate than `math.exp(x)-1` when `x` is near 0
+   * To avoid ambiguity with the matrix exponential `expm`, this function
+   * does not operate on matrices; if you wish to apply it elementwise, see
+   * the examples.
    *
    * Syntax:
    *
@@ -21,9 +23,11 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.expm1(2)                      // returns number 6.38905609893065
    *    math.pow(math.e, 2) - 1            // returns number 6.3890560989306495
+   *    math.expm1(1e-8)                   // returns number 1.0000000050000001e-8
+   *    math.exp(1e-8) - 1                 // returns number 9.9999999392253e-9
    *    math.log(math.expm1(2) + 1)        // returns number 2
    *
-   *    math.expm1([1, 2, 3])
+   *    math.map([1, 2, 3], math.expm1)
    *    // returns Array [
    *    //   1.718281828459045,
    *    //   6.3890560989306495,
@@ -32,10 +36,10 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * See also:
    *
-   *    exp, log, pow
+   *    exp, expm, log, pow
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x  A number or matrix to apply expm1
-   * @return {number | BigNumber | Complex | Array | Matrix} Exponent of `x`
+   * @param {number | BigNumber | Complex} x  A number or matrix to apply expm1
+   * @return {number | BigNumber | Complex} Exponential of `x`, minus one
    */
   return typed(name, {
     number: expm1Number,
@@ -45,9 +49,6 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     BigNumber: function BigNumber(x) {
       return x.exp().minus(1);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
     }
   });
 });