mathjs 10.6.2 → 11.0.0

package/lib/cjs/function/algebra/{simplify/simplifyConstant.js → simplifyConstant.js}

@@ -9,24 +9,25 @@ exports.createSimplifyConstant = void 0;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-var _is = require("../../../utils/is.js");
+var _is = require("../../utils/is.js");
 
-var _factory = require("../../../utils/factory.js");
+var _factory = require("../../utils/factory.js");
 
-var _util = require("./util.js");
+var _util = require("./simplify/util.js");
 
-var _noop = require("../../../utils/noop.js");
+var _noop = require("../../utils/noop.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
 var name = 'simplifyConstant';
-var dependencies = ['typed', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
+var dependencies = ['typed', 'parse', 'config', 'mathWithTransform', 'matrix', '?fraction', '?bignumber', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode'];
 var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
+      parse = _ref.parse,
       config = _ref.config,
       mathWithTransform = _ref.mathWithTransform,
       matrix = _ref.matrix,
@@ -50,10 +51,43 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
       isAssociative = _createUtil.isAssociative,
       allChildren = _createUtil.allChildren,
       createMakeNodeFunction = _createUtil.createMakeNodeFunction;
+  /**
+   * simplifyConstant() takes a mathjs expression (either a Node representing
+   * a parse tree or a string which it parses to produce a node), and replaces
+   * any subexpression of it consisting entirely of constants with the computed
+   * value of that subexpression.
+   *
+   * Syntax:
+   *
+   *     simplifyConstant(expr)
+   *     simplifyConstant(expr, options)
+   *
+   * Examples:
+   *
+   *     math.simplifyConstant('x + 4*3/6')  // Node "x + 2"
+   *     math.simplifyConstant('z cos(0)')   // Node "z 1"
+   *     math.simplifyConstant('(5.2 + 1.08)t', {exactFractions: false})  // Node "6.28 t"
+   *
+   * See also:
+   *
+   *     simplify, simplifyCore, resolve, derivative
+   *
+   * @param {Node | string} node
+   *     The expression to be simplified
+   * @param {Object} options
+   *     Simplification options, as per simplify()
+   * @return {Node} Returns expression with constant subexpressions evaluated
+   */
 
-  function simplifyConstant(expr, options) {
-    return _ensureNode(foldFraction(expr, options));
-  }
+
+  var simplifyConstant = typed('simplifyConstant', {
+    Node: function Node(node) {
+      return _ensureNode(foldFraction(node, {}));
+    },
+    'Node, Object': function NodeObject(expr, options) {
+      return _ensureNode(foldFraction(expr, options));
+    }
+  });
 
   function _removeFractions(thing) {
     if ((0, _is.isFraction)(thing)) {
@@ -348,7 +382,7 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
         return node;
 
       case 'ConstantNode':
-        switch ((0, _typeof2.default)(node.value)) {
+        switch ((0, _typeof2["default"])(node.value)) {
           case 'number':
             return _toNumber(node.value, options);
 

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

@@ -7,14 +7,18 @@ exports.createSimplifyCore = void 0;
 
 var _is = require("../../utils/is.js");
 
+var _operators = require("../../expression/operators.js");
+
 var _util = require("./simplify/util.js");
 
 var _factory = require("../../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'];
 var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var equal = _ref.equal,
+  var typed = _ref.typed,
+      parse = _ref.parse,
+      equal = _ref.equal,
       isZero = _ref.isZero,
       add = _ref.add,
       subtract = _ref.subtract,
@@ -32,6 +36,13 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       SymbolNode = _ref.SymbolNode;
   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 (0, _is.isOperatorNode)(node) && ['and', 'not', 'or'].includes(node.op);
+  }
 
   var _createUtil = (0, _util.createUtil)({
     FunctionNode: FunctionNode,
@@ -42,25 +53,43 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       isCommutative = _createUtil.isCommutative;
   /**
    * 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()
@@ -68,24 +97,25 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  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 ((0, _is.isFunctionNode)(node) && node.args.length === 1) {
-        return simplifyCore(node.args[0], options);
+      if ((0, _is.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(function (c) {
+      nodeToSimplify.forEach(function (c) {
         ++childCount;
 
         if (childCount === 1) {
-          simpChild = simplifyCore(c, options);
+          simpChild = _simplifyCore(c, options);
         }
       });
 
@@ -94,33 +124,79 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       }
     }
 
+    var node = nodeToSimplify;
+
+    if ((0, _is.isFunctionNode)(node)) {
+      var op = (0, _operators.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(function (n) {
+          return _simplifyCore(n, options);
+        }));
+      }
+    }
+
     if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0], options);
+      var a0 = _simplifyCore(node.args[0], options);
+
+      if (node.op === '~') {
+        // bitwise not
+        if ((0, _is.isOperatorNode)(a0) && a0.isUnary() && a0.op === '~') {
+          return a0.args[0];
+        }
+      }
+
+      if (node.op === 'not') {
+        // logical not
+        if ((0, _is.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 ((0, _is.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 ((0, _is.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 ((0, _is.isOperatorNode)(node) && node.isBinary()) {
+      var _a = _simplifyCore(node.args[0], options);
+
+      var a1 = _simplifyCore(node.args[1], options);
 
       if (node.op === '+') {
-        if ((0, _is.isConstantNode)(_a)) {
-          if (isZero(_a.value)) {
-            return a1;
-          } else if ((0, _is.isConstantNode)(a1)) {
-            return new ConstantNode(add(_a.value, a1.value));
-          }
+        if ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
+          return a1;
         }
 
         if ((0, _is.isConstantNode)(a1) && isZero(a1.value)) {
@@ -128,39 +204,33 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         }
 
         if ((0, _is.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 ((0, _is.isConstantNode)(_a) && a1) {
-          if ((0, _is.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 ((0, _is.isOperatorNode)(a1) && a1.isUnary() && a1.op === '-') {
+          return _simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
+        }
 
+        if ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
+          return _simplifyCore(new OperatorNode('-', 'unaryMinus', [a1]));
+        }
 
-        if (node.fn === 'subtract') {
-          if ((0, _is.isConstantNode)(a1) && isZero(a1.value)) {
-            return _a;
-          }
+        if ((0, _is.isConstantNode)(a1) && isZero(a1.value)) {
+          return _a;
+        }
 
-          if ((0, _is.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 ((0, _is.isConstantNode)(_a)) {
           if (isZero(_a.value)) {
             return node0;
           } else if (equal(_a.value, 1)) {
             return a1;
-          } else if ((0, _is.isConstantNode)(a1)) {
-            return new ConstantNode(multiply(_a.value, a1.value));
           }
         }
 
@@ -169,83 +239,116 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if ((0, _is.isOperatorNode)(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
-            var a00 = _a.args[0];
-
-            if ((0, _is.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 ((0, _is.isConstantNode)(_a)) {
-          if (isZero(_a.value)) {
-            return node0;
-          } else if ((0, _is.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 ((0, _is.isConstantNode)(_a) && isZero(_a.value)) {
+          return node0;
+        }
+
+        if ((0, _is.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 ((0, _is.isConstantNode)(a1)) {
           if (isZero(a1.value)) {
             return node1;
           } else if (equal(a1.value, 1)) {
             return _a;
+          }
+        }
+      }
+
+      if (node.op === 'and') {
+        if ((0, _is.isConstantNode)(_a)) {
+          if (_a.value) {
+            if (isAlwaysBoolean(a1)) return a1;
+          } else {
+            return nodeF;
+          }
+        }
+
+        if ((0, _is.isConstantNode)(a1)) {
+          if (a1.value) {
+            if (isAlwaysBoolean(_a)) return _a;
           } else {
-            if ((0, _is.isConstantNode)(_a)) {
-              // fold constant
-              return new ConstantNode(pow(_a.value, a1.value));
-            } else if ((0, _is.isOperatorNode)(_a) && _a.isBinary() && _a.op === '^') {
-              var a01 = _a.args[1];
-
-              if ((0, _is.isConstantNode)(a01)) {
-                return new OperatorNode(node.op, node.fn, [_a.args[0], new ConstantNode(multiply(a01.value, a1.value))]);
-              }
-            }
+            return nodeF;
+          }
+        }
+      }
+
+      if (node.op === 'or') {
+        if ((0, _is.isConstantNode)(_a)) {
+          if (_a.value) {
+            return nodeT;
+          } else {
+            if (isAlwaysBoolean(a1)) return a1;
+          }
+        }
+
+        if ((0, _is.isConstantNode)(a1)) {
+          if (a1.value) {
+            return nodeT;
+          } else {
+            if (isAlwaysBoolean(_a)) return _a;
           }
         }
       }
 
       return new OperatorNode(node.op, node.fn, [_a, a1]);
-    } else if ((0, _is.isFunctionNode)(node)) {
-      return new FunctionNode(simplifyCore(node.fn), node.args.map(function (n) {
-        return simplifyCore(n, options);
+    }
+
+    if ((0, _is.isOperatorNode)(node)) {
+      return new OperatorNode(node.op, node.fn, node.args.map(function (a) {
+        return _simplifyCore(a, options);
       }));
-    } else if ((0, _is.isArrayNode)(node)) {
+    }
+
+    if ((0, _is.isArrayNode)(node)) {
       return new ArrayNode(node.items.map(function (n) {
-        return simplifyCore(n, options);
+        return _simplifyCore(n, options);
       }));
-    } else if ((0, _is.isAccessorNode)(node)) {
-      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
-    } else if ((0, _is.isIndexNode)(node)) {
+    }
+
+    if ((0, _is.isAccessorNode)(node)) {
+      return new AccessorNode(_simplifyCore(node.object, options), _simplifyCore(node.index, options));
+    }
+
+    if ((0, _is.isIndexNode)(node)) {
       return new IndexNode(node.dimensions.map(function (n) {
-        return simplifyCore(n, options);
+        return _simplifyCore(n, options);
       }));
-    } else if ((0, _is.isObjectNode)(node)) {
+    }
+
+    if ((0, _is.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
+  });
 });
 exports.createSimplifyCore = createSimplifyCore;

package/lib/cjs/function/algebra/solver/lsolveAll.js

@@ -107,7 +107,7 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2.default)(b);
+          var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
 
           for (var _j = i + 1; _j < columns; _j++) {
@@ -187,7 +187,7 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2.default)(b);
+          var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
 
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {

package/lib/cjs/function/algebra/solver/usolveAll.js

@@ -107,7 +107,7 @@ var createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2.default)(b);
+          var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
 
           for (var _j = i - 1; _j >= 0; _j--) {
@@ -187,7 +187,7 @@ var createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2.default)(b);
+          var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1; // loop upper triangular
 
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {

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

@@ -56,33 +56,16 @@ var createSymbolicEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencie
    *     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 (0, _is.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 (0, _is.isConstantNode)(simplified) && !simplified.value;
-    }
+    'Node, Node': _symbolicEqual,
+    'Node, Node, Object': _symbolicEqual
   });
 });
 exports.createSymbolicEqual = createSymbolicEqual;

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

@@ -42,22 +42,15 @@ var createAbs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    */
   return typed(name, {
     number: _index.absNumber,
-    Complex: function Complex(x) {
+    'Complex | BigNumber | Fraction | Unit': function ComplexBigNumberFractionUnit(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 (0, _collection.deepMap)(x, this, true);
-    },
-    Unit: function Unit(x) {
-      return x.abs();
-    }
+    // deep map collection, skip zeros since abs(0) = 0
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    })
   });
 });
 exports.createAbs = createAbs;