mathjs 8.1.0 → 12.2.1

package/lib/esm/function/algebra/symbolicEqual.js

@@ -0,0 +1,60 @@
+import { isConstantNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    simplify,
+    typed,
+    OperatorNode
+  } = _ref;
+  /**
+   * Attempts to determine if two expressions are symbolically equal, i.e.
+   * one is the result of valid algebraic manipulations on the other.
+   * Currently, this simply checks if the difference of the two expressions
+   * simplifies down to 0. So there are two important caveats:
+   * 1. whether two expressions are symbolically equal depends on the
+   *     manipulations allowed. Therefore, this function takes an optional
+   *     third argument, which are the options that control the behavior
+   *     as documented for the `simplify()` function.
+   * 2. it is in general intractable to find the minimal simplification of
+   *     an arbitrarily complicated expression. So while a `true` value
+   *     of `symbolicEqual` ensures that the two expressions can be manipulated
+   *     to match each other, a `false` value does not absolutely rule this out.
+   *
+   * Syntax:
+   *
+   *     math.symbolicEqual(expr1, expr2)
+   *     math.symbolicEqual(expr1, expr2, options)
+   *
+   * Examples:
+   *
+   *     math.symbolicEqual('x*y', 'y*x') // Returns true
+   *     math.symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}}) // Returns false
+   *     math.symbolicEqual('x/y', '(y*x^(-1))^(-1)') // Returns true
+   *     math.symbolicEqual('abs(x)','x') // Returns false
+   *     math.symbolicEqual('abs(x)','x', simplify.positiveContext) // Returns true
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node|string} expr1  The first expression to compare
+   * @param {Node|string} expr2  The second expression to compare
+   * @param {Object} [options] Optional option object, passed to simplify
+   * @returns {boolean}
+   *     Returns true if a valid manipulation making the expressions equal
+   *     is found.
+   */
+  function _symbolicEqual(e1, e2) {
+    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    var diff = new OperatorNode('-', 'subtract', [e1, e2]);
+    var simplified = simplify(diff, {}, options);
+    return isConstantNode(simplified) && !simplified.value;
+  }
+  return typed(name, {
+    'Node, Node': _symbolicEqual,
+    'Node, Node, Object': _symbolicEqual
+  });
+});

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

@@ -3,11 +3,10 @@ import { deepMap } from '../../utils/collection.js';
 import { absNumber } from '../../plain/number/index.js';
 var name = 'abs';
 var dependencies = ['typed'];
-export var createAbs = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createAbs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Calculate the absolute value of a number. For matrices, the function is
    * evaluated element wise.
@@ -34,21 +33,8 @@ export var createAbs = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    */
   return typed(name, {
     number: absNumber,
-    Complex: function Complex(x) {
-      return x.abs();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.abs();
-    },
-    Fraction: function Fraction(x) {
-      return x.abs();
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since abs(0) = 0
-      return deepMap(x, this, true);
-    },
-    Unit: function Unit(x) {
-      return x.abs();
-    }
+    'Complex | BigNumber | Fraction | Unit': x => x.abs(),
+    // deep map collection, skip zeros since abs(0) = 0
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self, true))
   });
 });

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

@@ -1,128 +1,83 @@
 import { factory } from '../../utils/factory.js';
-import { extend } from '../../utils/object.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
-import { createAlgorithm04 } from '../../type/matrix/utils/algorithm04.js';
-import { createAlgorithm10 } from '../../type/matrix/utils/algorithm10.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 { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'add';
-var dependencies = ['typed', 'matrix', 'addScalar', 'equalScalar', 'DenseMatrix', 'SparseMatrix'];
-export var createAdd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'matrix', 'addScalar', 'equalScalar', 'DenseMatrix', 'SparseMatrix', 'concat'];
+export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     addScalar,
     equalScalar,
     DenseMatrix,
-    SparseMatrix
+    SparseMatrix,
+    concat
   } = _ref;
-  var algorithm01 = createAlgorithm01({
+  var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
-  var algorithm04 = createAlgorithm04({
+  var matAlgo04xSidSid = createMatAlgo04xSidSid({
     typed,
     equalScalar
   });
-  var algorithm10 = createAlgorithm10({
+  var matAlgo10xSids = createMatAlgo10xSids({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
   });
   /**
-   * Add two or more values, `x + y`.
-   * For matrices, the function is evaluated element wise.
-   *
-   * Syntax:
-   *
-   *    math.add(x, y)
-   *    math.add(x, y, z, ...)
-   *
-   * Examples:
-   *
-   *    math.add(2, 3)               // returns number 5
-   *    math.add(2, 3, 4)            // returns number 9
-   *
-   *    const a = math.complex(2, 3)
-   *    const b = math.complex(-4, 1)
-   *    math.add(a, b)               // returns Complex -2 + 4i
-   *
-   *    math.add([1, 2, 3], 4)       // returns Array [5, 6, 7]
-   *
-   *    const c = math.unit('5 cm')
-   *    const d = math.unit('2.1 mm')
-   *    math.add(c, d)               // returns Unit 52.1 mm
-   *
-   *    math.add("2.3", "4")         // returns number 6.3
-   *
-   * See also:
-   *
-   *    subtract, sum
-   *
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First value to add
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to add
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
-   */
-
-  return typed(name, extend({
-    // we extend the signatures of addScalar with signatures dealing with matrices
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      return algorithm13(x, y, addScalar);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm01(x, y, addScalar, false);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm01(y, x, addScalar, true);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm04(x, y, addScalar);
-    },
-    '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));
-    },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
-      return algorithm14(x, y, addScalar, false);
-    },
-    'SparseMatrix, any': function SparseMatrixAny(x, y) {
-      return algorithm10(x, y, addScalar, false);
-    },
-    'any, DenseMatrix': function anyDenseMatrix(x, y) {
-      return algorithm14(y, x, addScalar, true);
-    },
-    'any, SparseMatrix': function anySparseMatrix(x, y) {
-      return algorithm10(y, x, addScalar, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, addScalar, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, addScalar, true).valueOf();
-    },
+  * Add two or more values, `x + y`.
+  * For matrices, the function is evaluated element wise.
+  *
+  * Syntax:
+  *
+  *    math.add(x, y)
+  *    math.add(x, y, z, ...)
+  *
+  * Examples:
+  *
+  *    math.add(2, 3)               // returns number 5
+  *    math.add(2, 3, 4)            // returns number 9
+  *
+  *    const a = math.complex(2, 3)
+  *    const b = math.complex(-4, 1)
+  *    math.add(a, b)               // returns Complex -2 + 4i
+  *
+  *    math.add([1, 2, 3], 4)       // returns Array [5, 6, 7]
+  *
+  *    const c = math.unit('5 cm')
+  *    const d = math.unit('2.1 mm')
+  *    math.add(c, d)               // returns Unit 52.1 mm
+  *
+  *    math.add("2.3", "4")         // returns number 6.3
+  *
+  * See also:
+  *
+  *    subtract, sum
+  *
+  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x First value to add
+  * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Second value to add
+  * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Sum of `x` and `y`
+  */
+  return typed(name, {
     'any, any': addScalar,
-    '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;
-    }
-  }, addScalar.signatures));
+    })
+  }, matrixAlgorithmSuite({
+    elop: addScalar,
+    DS: matAlgo01xDSid,
+    SS: matAlgo04xSidSid,
+    Ss: matAlgo10xSids
+  }));
 });

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

@@ -2,11 +2,10 @@ import { factory } from '../../utils/factory.js';
 import { addNumber } from '../../plain/number/index.js';
 var name = 'addScalar';
 var dependencies = ['typed'];
-export var createAddScalar = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createAddScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
   /**
    * Add two scalar values, `x + y`.
    * This function is meant for internal use: it is used by the public function
@@ -30,14 +29,18 @@ export var createAddScalar = /* #__PURE__ */factory(name, dependencies, (_ref) =
     'Fraction, Fraction': function FractionFraction(x, y) {
       return x.add(y);
     },
-    'Unit, Unit': function UnitUnit(x, y) {
-      if (x.value === null || x.value === undefined) throw new Error('Parameter x contains a unit with undefined value');
-      if (y.value === null || y.value === undefined) throw new Error('Parameter y contains a unit with undefined value');
+    'Unit, Unit': typed.referToSelf(self => (x, y) => {
+      if (x.value === null || x.value === undefined) {
+        throw new Error('Parameter x contains a unit with undefined value');
+      }
+      if (y.value === null || y.value === undefined) {
+        throw new Error('Parameter y contains a unit with undefined value');
+      }
       if (!x.equalBase(y)) throw new Error('Units do not match');
       var res = x.clone();
-      res.value = this(res.value, y.value);
+      res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
       res.fixPrefix = false;
       return res;
-    }
+    })
   });
 });

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

@@ -1,10 +1,9 @@
 import { factory } from '../../utils/factory.js';
 import { isBigNumber, isComplex, isFraction } from '../../utils/is.js';
-import { deepMap } from '../../utils/collection.js';
 import { cbrtNumber } from '../../plain/number/index.js';
 var name = 'cbrt';
 var dependencies = ['config', 'typed', 'isNegative', 'unaryMinus', 'matrix', 'Complex', 'BigNumber', 'Fraction'];
-export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
     typed,
@@ -15,11 +14,12 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     BigNumber,
     Fraction
   } = _ref;
-
   /**
    * Calculate the cubic root of a value.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix cube root, this function does not
+   * apply to matrices. For a matrix, to take the cube root elementwise,
+   * see the examples.
    *
    * Syntax:
    *
@@ -32,7 +32,7 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *    math.cube(3)                   // returns 27
    *    math.cbrt(-64)                 // returns -4
    *    math.cbrt(math.unit('27 m^3')) // returns Unit 3 m
-   *    math.cbrt([27, 64, 125])       // returns [3, 4, 5]
+   *    math.map([27, 64, 125], x => math.cbrt(x))       // returns [3, 4, 5]
    *
    *    const x = math.complex('8i')
    *    math.cbrt(x)                   // returns Complex 1.7320508075689 + i
@@ -46,30 +46,28 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *
    *    square, sqrt, cube
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x
+   * @param {number | BigNumber | Complex | Unit} x
    *            Value for which to calculate the cubic root.
    * @param {boolean} [allRoots]  Optional, false by default. Only applicable
    *            when `x` is a number or complex number. If true, all complex
    *            roots are returned, if false (default) the principal root is
    *            returned.
-   * @return {number | BigNumber | Complex | Unit | Array | Matrix}
+   * @return {number | BigNumber | Complex | Unit}
    *            Returns the cubic root of `x`
    */
   return typed(name, {
     number: cbrtNumber,
     // note: signature 'number, boolean' is also supported,
     //       created by typed as it knows how to convert number to Complex
+
     Complex: _cbrtComplex,
     'Complex, boolean': _cbrtComplex,
     BigNumber: function BigNumber(x) {
       return x.cbrt();
     },
-    Unit: _cbrtUnit,
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since cbrt(0) = 0
-      return deepMap(x, this, true);
-    }
+    Unit: _cbrtUnit
   });
+
   /**
    * Calculate the cubic root for a complex number
    * @param {Complex} x
@@ -79,14 +77,14 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    * @returns {Complex | Array.<Complex> | Matrix.<Complex>} Returns the cubic root(s) of x
    * @private
    */
-
   function _cbrtComplex(x, allRoots) {
     // https://www.wikiwand.com/en/Cube_root#/Complex_numbers
+
     var arg3 = x.arg() / 3;
-    var abs = x.abs(); // principal root:
+    var abs = x.abs();
 
+    // principal root:
     var principal = new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3).exp());
-
     if (allRoots) {
       var all = [principal, new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex(cbrtNumber(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
       return config.matrix === 'Array' ? all : matrix(all);
@@ -94,33 +92,28 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       return principal;
     }
   }
+
   /**
    * Calculate the cubic root for a Unit
    * @param {Unit} x
    * @return {Unit} Returns the cubic root of x
    * @private
    */
-
-
   function _cbrtUnit(x) {
     if (x.value && isComplex(x.value)) {
       var result = x.clone();
       result.value = 1.0;
       result = result.pow(1.0 / 3); // Compute the units
-
       result.value = _cbrtComplex(x.value); // Compute the value
-
       return result;
     } else {
       var negate = isNegative(x.value);
-
       if (negate) {
         x.value = unaryMinus(x.value);
-      } // TODO: create a helper function for this
-
+      }
 
+      // TODO: create a helper function for this
       var third;
-
       if (isBigNumber(x.value)) {
         third = new BigNumber(1).div(3);
       } else if (isFraction(x.value)) {
@@ -128,13 +121,10 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       } else {
         third = 1 / 3;
       }
-
       var _result = x.pow(third);
-
       if (negate) {
         _result.value = unaryMinus(_result.value);
       }
-
       return _result;
     }
   }

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

@@ -3,26 +3,63 @@ 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 { ceilNumber } from '../../plain/number/index.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 { 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'];
-export var createCeil = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.ceil(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
   var {
     typed,
     config,
     round,
     matrix,
-    equalScalar
-  } = _ref;
-  var algorithm11 = createAlgorithm11({
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
+  var ceilNumber = createCeilNumber({
+    typed,
+    config,
+    round
+  });
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -60,31 +97,18 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
-
   return typed('ceil', {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return ceilNumber(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
-      }
-    },
+    number: ceilNumber.signatures.number,
+    'number,number': ceilNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return x.ceil();
     },
     'Complex, number': function ComplexNumber(x, n) {
       return x.ceil(n);
     },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
     BigNumber: function BigNumber(x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x);
@@ -105,23 +129,33 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     'Fraction, number': function FractionNumber(x, n) {
       return x.ceil(n);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since ceil(0) = 0
-      return deepMap(x, this, true);
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.ceil(n.toNumber());
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // 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 | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+      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 => 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();
-    }
+      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 matAlgo14xDs(y, x, self, true);
+      }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

@@ -1,16 +1,15 @@
 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'];
-export var createCube = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _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 +22,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 +42,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);
     }