mathjs 10.6.2 → 11.0.0

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

@@ -1,10 +1,13 @@
 import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
+import { getOperator } from '../../expression/operators.js';
 import { createUtil } from './simplify/util.js';
 import { factory } from '../../utils/factory.js';
 var name = 'simplifyCore';
-var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+var dependencies = ['typed', 'parse', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
+    typed,
+    parse,
     equal,
     isZero,
     add,
@@ -24,6 +27,14 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
+  var nodeT = new ConstantNode(true);
+  var nodeF = new ConstantNode(false); // test if a node will always have a boolean value (true/false)
+  // not sure if this list is complete
+
+  function isAlwaysBoolean(node) {
+    return isOperatorNode(node) && ['and', 'not', 'or'].includes(node.op);
+  }
+
   var {
     hasProperty,
     isCommutative
@@ -34,49 +45,68 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
   });
   /**
    * simplifyCore() performs single pass simplification suitable for
-   * applications requiring ultimate performance. In contrast, simplify()
-   * extends simplifyCore() with additional passes to provide deeper
-   * simplification.
+   * applications requiring ultimate performance. To roughly summarize,
+   * it handles cases along the lines of simplifyConstant() but where
+   * knowledge of a single argument is sufficient to determine the value.
+   * In contrast, simplify() extends simplifyCore() with additional passes
+   * to provide deeper simplification (such as gathering like terms).
+   *
+   * Specifically, simplifyCore:
+   *
+   * * Converts all function calls with operator equivalents to their
+   *   operator forms.
+   * * Removes operators or function calls that are guaranteed to have no
+   *   effect (such as unary '+').
+   * * Removes double unary '-', '~', and 'not'
+   * * Eliminates addition/subtraction of 0 and multiplication/division/powers
+   *   by 1 or 0.
+   * * Converts addition of a negation into subtraction.
+   * * Eliminates logical operations with constant true or false leading
+   *   arguments.
+   * * Puts constants on the left of a product, if multiplication is
+   *   considered commutative by the options (which is the default)
    *
    * Syntax:
    *
    *     simplifyCore(expr)
+   *     simplifyCore(expr, options)
    *
    * Examples:
    *
-   *     const f = math.parse('2 * 1 * x ^ (2 - 1)')
-   *     math.simpifyCore(f)                          // Node {2 * x}
-   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplifyCore]) // Node {2 * x}
+   *     const f = math.parse('2 * 1 * x ^ (1 - 0)')
+   *     math.simplifyCore(f)                          // Node "2 * x"
+   *     math.simplify('2 * 1 * x ^ (1 - 0)', [math.simplifyCore]) // Node "2 * x"
    *
    * See also:
    *
-   *     simplify, resolve, derivative
+   *     simplify, simplifyConstant, resolve, derivative
    *
-   * @param {Node} node
+   * @param {Node | string} node
    *     The expression to be simplified
    * @param {Object} options
    *     Simplification options, as per simplify()
    * @return {Node} Returns expression with basic simplifications applied
    */
 
-  function simplifyCore(node, options) {
+  function _simplifyCore(nodeToSimplify) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     var context = options ? options.context : undefined;
 
-    if (hasProperty(node, 'trivial', context)) {
+    if (hasProperty(nodeToSimplify, 'trivial', context)) {
       // This node does nothing if it has only one argument, so if so,
       // return that argument simplified
-      if (isFunctionNode(node) && node.args.length === 1) {
-        return simplifyCore(node.args[0], options);
+      if (isFunctionNode(nodeToSimplify) && nodeToSimplify.args.length === 1) {
+        return _simplifyCore(nodeToSimplify.args[0], options);
       } // For other node types, we try the generic methods
 
 
       var simpChild = false;
       var childCount = 0;
-      node.forEach(c => {
+      nodeToSimplify.forEach(c => {
         ++childCount;
 
         if (childCount === 1) {
-          simpChild = simplifyCore(c, options);
+          simpChild = _simplifyCore(c, options);
         }
       });
 
@@ -85,33 +115,77 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
       }
     }
 
+    var node = nodeToSimplify;
+
+    if (isFunctionNode(node)) {
+      var op = getOperator(node.name);
+
+      if (op) {
+        // Replace FunctionNode with a new OperatorNode
+        if (node.args.length > 2 && hasProperty(node, 'associative', context)) {
+          // unflatten into binary operations since that's what simplifyCore handles
+          while (node.args.length > 2) {
+            var last = node.args.pop();
+            var seclast = node.args.pop();
+            node.args.push(new OperatorNode(op, node.name, [last, seclast]));
+          }
+        }
+
+        node = new OperatorNode(op, node.name, node.args);
+      } else {
+        return new FunctionNode(_simplifyCore(node.fn), node.args.map(n => _simplifyCore(n, options)));
+      }
+    }
+
     if (isOperatorNode(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0], options);
+      var a0 = _simplifyCore(node.args[0], options);
+
+      if (node.op === '~') {
+        // bitwise not
+        if (isOperatorNode(a0) && a0.isUnary() && a0.op === '~') {
+          return a0.args[0];
+        }
+      }
+
+      if (node.op === 'not') {
+        // logical not
+        if (isOperatorNode(a0) && a0.isUnary() && a0.op === 'not') {
+          // Has the effect of turning the argument into a boolean
+          // So can only eliminate the double negation if
+          // the inside is already boolean
+          if (isAlwaysBoolean(a0.args[0])) {
+            return a0.args[0];
+          }
+        }
+      }
+
+      var finish = true;
 
       if (node.op === '-') {
         // unary minus
         if (isOperatorNode(a0)) {
+          if (a0.isBinary() && a0.fn === 'subtract') {
+            node = new OperatorNode('-', 'subtract', [a0.args[1], a0.args[0]]);
+            finish = false; // continue to process the new binary node
+          }
+
           if (a0.isUnary() && a0.op === '-') {
             return a0.args[0];
-          } else if (a0.isBinary() && a0.fn === 'subtract') {
-            return new OperatorNode('-', 'subtract', [a0.args[1], a0.args[0]]);
           }
         }
-
-        return new OperatorNode(node.op, node.fn, [a0]);
       }
-    } else if (isOperatorNode(node) && node.isBinary()) {
-      var _a = simplifyCore(node.args[0], options);
 
-      var a1 = simplifyCore(node.args[1], options);
+      if (finish) return new OperatorNode(node.op, node.fn, [a0]);
+    }
+
+    if (isOperatorNode(node) && node.isBinary()) {
+      var _a = _simplifyCore(node.args[0], options);
+
+      var a1 = _simplifyCore(node.args[1], options);
 
       if (node.op === '+') {
-        if (isConstantNode(_a)) {
-          if (isZero(_a.value)) {
-            return a1;
-          } else if (isConstantNode(a1)) {
-            return new ConstantNode(add(_a.value, a1.value));
-          }
+        if (isConstantNode(_a) && isZero(_a.value)) {
+          return a1;
         }
 
         if (isConstantNode(a1) && isZero(a1.value)) {
@@ -119,39 +193,33 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
         }
 
         if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
-          return new OperatorNode('-', 'subtract', [_a, a1.args[0]]);
+          a1 = a1.args[0];
+          node = new OperatorNode('-', 'subtract', [_a, a1]);
         }
+      }
 
-        return new OperatorNode(node.op, node.fn, a1 ? [_a, a1] : [_a]);
-      } else if (node.op === '-') {
-        if (isConstantNode(_a) && a1) {
-          if (isConstantNode(a1)) {
-            return new ConstantNode(subtract(_a.value, a1.value));
-          } else if (isZero(_a.value)) {
-            return new OperatorNode('-', 'unaryMinus', [a1]);
-          }
-        } // if (node.fn === "subtract" && node.args.length === 2) {
+      if (node.op === '-') {
+        if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
+          return _simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
+        }
 
+        if (isConstantNode(_a) && isZero(_a.value)) {
+          return _simplifyCore(new OperatorNode('-', 'unaryMinus', [a1]));
+        }
 
-        if (node.fn === 'subtract') {
-          if (isConstantNode(a1) && isZero(a1.value)) {
-            return _a;
-          }
+        if (isConstantNode(a1) && isZero(a1.value)) {
+          return _a;
+        }
 
-          if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
-            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
-          }
+        return new OperatorNode(node.op, node.fn, [_a, a1]);
+      }
 
-          return new OperatorNode(node.op, node.fn, [_a, a1]);
-        }
-      } else if (node.op === '*') {
+      if (node.op === '*') {
         if (isConstantNode(_a)) {
           if (isZero(_a.value)) {
             return node0;
           } else if (equal(_a.value, 1)) {
             return a1;
-          } else if (isConstantNode(a1)) {
-            return new ConstantNode(multiply(_a.value, a1.value));
           }
         }
 
@@ -160,76 +228,109 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
-            var a00 = _a.args[0];
-
-            if (isConstantNode(a00)) {
-              var a00a1 = new ConstantNode(multiply(a00.value, a1.value));
-              return new OperatorNode(node.op, node.fn, [a00a1, _a.args[1]], node.implicit); // constants on left
-            }
           }
 
           if (isCommutative(node, context)) {
             return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
-          } else {
-            return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
           }
         }
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
-      } else if (node.op === '/') {
-        if (isConstantNode(_a)) {
-          if (isZero(_a.value)) {
-            return node0;
-          } else if (isConstantNode(a1) && (equal(a1.value, 1) || equal(a1.value, 2) || equal(a1.value, 4))) {
-            return new ConstantNode(divide(_a.value, a1.value));
-          }
+      }
+
+      if (node.op === '/') {
+        if (isConstantNode(_a) && isZero(_a.value)) {
+          return node0;
+        }
+
+        if (isConstantNode(a1) && equal(a1.value, 1)) {
+          return _a;
         }
 
         return new OperatorNode(node.op, node.fn, [_a, a1]);
-      } else if (node.op === '^') {
+      }
+
+      if (node.op === '^') {
         if (isConstantNode(a1)) {
           if (isZero(a1.value)) {
             return node1;
           } else if (equal(a1.value, 1)) {
             return _a;
+          }
+        }
+      }
+
+      if (node.op === 'and') {
+        if (isConstantNode(_a)) {
+          if (_a.value) {
+            if (isAlwaysBoolean(a1)) return a1;
           } else {
-            if (isConstantNode(_a)) {
-              // fold constant
-              return new ConstantNode(pow(_a.value, a1.value));
-            } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === '^') {
-              var a01 = _a.args[1];
-
-              if (isConstantNode(a01)) {
-                return new OperatorNode(node.op, node.fn, [_a.args[0], new ConstantNode(multiply(a01.value, a1.value))]);
-              }
-            }
+            return nodeF;
+          }
+        }
+
+        if (isConstantNode(a1)) {
+          if (a1.value) {
+            if (isAlwaysBoolean(_a)) return _a;
+          } else {
+            return nodeF;
+          }
+        }
+      }
+
+      if (node.op === 'or') {
+        if (isConstantNode(_a)) {
+          if (_a.value) {
+            return nodeT;
+          } else {
+            if (isAlwaysBoolean(a1)) return a1;
+          }
+        }
+
+        if (isConstantNode(a1)) {
+          if (a1.value) {
+            return nodeT;
+          } else {
+            if (isAlwaysBoolean(_a)) return _a;
           }
         }
       }
 
       return new OperatorNode(node.op, node.fn, [_a, a1]);
-    } else if (isFunctionNode(node)) {
-      return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
-    } else if (isArrayNode(node)) {
-      return new ArrayNode(node.items.map(n => simplifyCore(n, options)));
-    } else if (isAccessorNode(node)) {
-      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
-    } else if (isIndexNode(node)) {
-      return new IndexNode(node.dimensions.map(n => simplifyCore(n, options)));
-    } else if (isObjectNode(node)) {
+    }
+
+    if (isOperatorNode(node)) {
+      return new OperatorNode(node.op, node.fn, node.args.map(a => _simplifyCore(a, options)));
+    }
+
+    if (isArrayNode(node)) {
+      return new ArrayNode(node.items.map(n => _simplifyCore(n, options)));
+    }
+
+    if (isAccessorNode(node)) {
+      return new AccessorNode(_simplifyCore(node.object, options), _simplifyCore(node.index, options));
+    }
+
+    if (isIndexNode(node)) {
+      return new IndexNode(node.dimensions.map(n => _simplifyCore(n, options)));
+    }
+
+    if (isObjectNode(node)) {
       var newProps = {};
 
       for (var prop in node.properties) {
-        newProps[prop] = simplifyCore(node.properties[prop], options);
+        newProps[prop] = _simplifyCore(node.properties[prop], options);
       }
 
       return new ObjectNode(newProps);
-    } else {// cannot simplify
-    }
+    } // cannot simplify
+
 
     return node;
   }
 
-  return simplifyCore;
+  return typed(name, {
+    Node: _simplifyCore,
+    'Node,Object': _simplifyCore
+  });
 });

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

@@ -49,32 +49,15 @@ export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref
    *     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, {
-    'string, string': function stringString(s1, s2) {
-      return this(parse(s1), parse(s2), {});
-    },
-    'string, string, Object': function stringStringObject(s1, s2, options) {
-      return this(parse(s1), parse(s2), options);
-    },
-    'Node, string': function NodeString(e1, s2) {
-      return this(e1, parse(s2), {});
-    },
-    'Node, string, Object': function NodeStringObject(e1, s2, options) {
-      return this(e1, parse(s2), options);
-    },
-    'string, Node': function stringNode(s1, e2) {
-      return this(parse(s1), e2, {});
-    },
-    'string, Node, Object': function stringNodeObject(s1, e2, options) {
-      return this(parse(s1), e2, options);
-    },
-    'Node, Node': function NodeNode(e1, e2) {
-      return this(e1, e2, {});
-    },
-    'Node, Node, Object': function NodeNodeObject(e1, e2, options) {
-      var diff = new OperatorNode('-', 'subtract', [e1, e2]);
-      var simplified = simplify(diff, {}, options);
-      return isConstantNode(simplified) && !simplified.value;
-    }
+    'Node, Node': _symbolicEqual,
+    'Node, Node, Object': _symbolicEqual
   });
 });

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

@@ -34,21 +34,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,10 +1,8 @@
 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 => {
@@ -16,22 +14,20 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
     DenseMatrix,
     SparseMatrix
   } = _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
   });
   /**
    * Add two or more values, `x + y`.
@@ -68,61 +64,21 @@ export var createAdd = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @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();
-    },
+  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

@@ -30,14 +30,20 @@ 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,6 +1,5 @@
 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'];
@@ -19,7 +18,9 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _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 +33,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,13 +47,13 @@ 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, {
@@ -64,11 +65,7 @@ export var createCbrt = /* #__PURE__ */factory(name, dependencies, _ref => {
     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