mathjs 11.2.1 → 11.3.0

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

@@ -1,70 +1,62 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSimplify = void 0;
-
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 var _is = require("../../utils/is.js");
-
 var _factory = require("../../utils/factory.js");
-
 var _util = require("./simplify/util.js");
-
 var _object = require("../../utils/object.js");
-
 var _map = require("../../utils/map.js");
-
 var name = 'simplify';
 var dependencies = ['config', 'typed', 'parse', 'add', 'subtract', 'multiply', 'divide', 'pow', 'isZero', 'equal', 'resolve', 'simplifyConstant', 'simplifyCore', '?fraction', '?bignumber', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
-      typed = _ref.typed,
-      parse = _ref.parse,
-      add = _ref.add,
-      subtract = _ref.subtract,
-      multiply = _ref.multiply,
-      divide = _ref.divide,
-      pow = _ref.pow,
-      isZero = _ref.isZero,
-      equal = _ref.equal,
-      resolve = _ref.resolve,
-      simplifyConstant = _ref.simplifyConstant,
-      simplifyCore = _ref.simplifyCore,
-      fraction = _ref.fraction,
-      bignumber = _ref.bignumber,
-      mathWithTransform = _ref.mathWithTransform,
-      matrix = _ref.matrix,
-      AccessorNode = _ref.AccessorNode,
-      ArrayNode = _ref.ArrayNode,
-      ConstantNode = _ref.ConstantNode,
-      FunctionNode = _ref.FunctionNode,
-      IndexNode = _ref.IndexNode,
-      ObjectNode = _ref.ObjectNode,
-      OperatorNode = _ref.OperatorNode,
-      ParenthesisNode = _ref.ParenthesisNode,
-      SymbolNode = _ref.SymbolNode;
-
+    typed = _ref.typed,
+    parse = _ref.parse,
+    add = _ref.add,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply,
+    divide = _ref.divide,
+    pow = _ref.pow,
+    isZero = _ref.isZero,
+    equal = _ref.equal,
+    resolve = _ref.resolve,
+    simplifyConstant = _ref.simplifyConstant,
+    simplifyCore = _ref.simplifyCore,
+    fraction = _ref.fraction,
+    bignumber = _ref.bignumber,
+    mathWithTransform = _ref.mathWithTransform,
+    matrix = _ref.matrix,
+    AccessorNode = _ref.AccessorNode,
+    ArrayNode = _ref.ArrayNode,
+    ConstantNode = _ref.ConstantNode,
+    FunctionNode = _ref.FunctionNode,
+    IndexNode = _ref.IndexNode,
+    ObjectNode = _ref.ObjectNode,
+    OperatorNode = _ref.OperatorNode,
+    ParenthesisNode = _ref.ParenthesisNode,
+    SymbolNode = _ref.SymbolNode;
   var _createUtil = (0, _util.createUtil)({
-    FunctionNode: FunctionNode,
-    OperatorNode: OperatorNode,
-    SymbolNode: SymbolNode
-  }),
-      hasProperty = _createUtil.hasProperty,
-      isCommutative = _createUtil.isCommutative,
-      isAssociative = _createUtil.isAssociative,
-      mergeContext = _createUtil.mergeContext,
-      flatten = _createUtil.flatten,
-      unflattenr = _createUtil.unflattenr,
-      unflattenl = _createUtil.unflattenl,
-      createMakeNodeFunction = _createUtil.createMakeNodeFunction,
-      defaultContext = _createUtil.defaultContext,
-      realContext = _createUtil.realContext,
-      positiveContext = _createUtil.positiveContext;
+      FunctionNode: FunctionNode,
+      OperatorNode: OperatorNode,
+      SymbolNode: SymbolNode
+    }),
+    hasProperty = _createUtil.hasProperty,
+    isCommutative = _createUtil.isCommutative,
+    isAssociative = _createUtil.isAssociative,
+    mergeContext = _createUtil.mergeContext,
+    flatten = _createUtil.flatten,
+    unflattenr = _createUtil.unflattenr,
+    unflattenl = _createUtil.unflattenl,
+    createMakeNodeFunction = _createUtil.createMakeNodeFunction,
+    defaultContext = _createUtil.defaultContext,
+    realContext = _createUtil.realContext,
+    positiveContext = _createUtil.positiveContext;
+
   /**
    * Simplify an expression tree.
    *
@@ -173,8 +165,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @param {SimplifyOptions} [options] Optional configuration settings
    * @return {Node} Returns the simplified form of `expr`
    */
-
-
   typed.addConversion({
     from: 'Object',
     to: 'Map',
@@ -200,14 +190,13 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   simplify.defaultContext = defaultContext;
   simplify.realContext = realContext;
   simplify.positiveContext = positiveContext;
-
   function removeParens(node) {
     return node.transform(function (node, path, parent) {
       return (0, _is.isParenthesisNode)(node) ? removeParens(node.content) : node;
     });
-  } // All constants that are allowed in rules
-
+  }
 
+  // All constants that are allowed in rules
   var SUPPORTED_CONSTANTS = {
     "true": true,
     "false": true,
@@ -223,11 +212,13 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     pi: true,
     SQRT1_2: true,
     SQRT2: true,
-    tau: true // null: false,
+    tau: true
+    // null: false,
     // undefined: false,
     // version: false,
+  };
 
-  }; // Array of strings, used to build the ruleSet.
+  // Array of strings, used to build the ruleSet.
   // Each l (left side) and r (right side) are parsed by
   // the expression parser into a node tree.
   // Left hand sides are matched to subtrees within the
@@ -236,8 +227,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   // TODO: Add support for constraints on constants (either in the form of a '=' expression or a callback [callback allows things like comparing symbols alphabetically])
   // To evaluate lhs constants for rhs constants, use: { l: 'c1+c2', r: 'c3', evaluate: 'c3 = c1 + c2' }. Multiple assignments are separated by ';' in block format.
   // It is possible to get into an infinite loop with conflicting rules
-
-  simplify.rules = [simplifyCore, // { l: 'n+0', r: 'n' },     // simplifyCore
+  simplify.rules = [simplifyCore,
+  // { l: 'n+0', r: 'n' },     // simplifyCore
   // { l: 'n^0', r: '1' },     // simplifyCore
   // { l: '0*n', r: '0' },     // simplifyCore
   // { l: 'n/n', r: '1'},      // simplifyCore
@@ -247,7 +238,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   {
     l: 'log(e)',
     r: '1'
-  }, // temporary rules
+  },
+  // temporary rules
   // Note initially we tend constants to the right because like-term
   // collection prefers the left, and we would rather collect nonconstants
   {
@@ -305,16 +297,19 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
   }, {
     l: '-v',
     r: 'v * (-1)'
-  }, // finish making non-constant terms positive
+  },
+  // finish making non-constant terms positive
   {
     l: '(n1 + n2)*(-1)',
     r: 'n1*(-1) + n2*(-1)',
     repeat: true
-  }, // expand negations to achieve as much sign cancellation as possible
+  },
+  // expand negations to achieve as much sign cancellation as possible
   {
     l: 'n/n1^n2',
     r: 'n*n1^-n2'
-  }, // temporarily replace 'divide' so we can further flatten the 'multiply' operator
+  },
+  // temporarily replace 'divide' so we can further flatten the 'multiply' operator
   {
     l: 'n/n1',
     r: 'n*n1^-1'
@@ -332,7 +327,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: false
       }
     }
-  }, // expand nested exponentiation
+  },
+  // expand nested exponentiation
   {
     s: '(n ^ n1) ^ n2 -> n ^ (n1 * n2)',
     assuming: {
@@ -340,8 +336,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     } // 1/(1/n) = n needs 1/n to exist
-
-  }, // collect like factors; into a sum, only do this for nonconstants
+  },
+  // collect like factors; into a sum, only do this for nonconstants
   {
     l: ' v   * ( v   * n1 + n2)',
     r: 'v^2       * n1 +  v   * n2'
@@ -352,7 +348,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     } // v*1/v = v^(1+-1) needs 1/v
-
   }, {
     s: 'v^n3 * ( v   * n1 + n2)   ->  v^(n3+1)  * n1 + v^n3 * n2',
     assuming: {
@@ -377,7 +372,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     } // n*1/n = n^(-1+1) needs 1/n
-
   }, {
     s: 'n^n1 * n^n2 -> n^(n1+n2)',
     assuming: {
@@ -385,12 +379,14 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     } // ditto for n^2*1/n^2
-
-  }, // Unfortunately, to deal with more complicated cancellations, it
+  },
+  // Unfortunately, to deal with more complicated cancellations, it
   // becomes necessary to simplify constants twice per pass. It's not
   // terribly expensive compared to matching rules, so this should not
   // pose a performance problem.
-  simplifyConstant, // First: before collecting like terms
+  simplifyConstant,
+  // First: before collecting like terms
+
   // collect like terms
   {
     s: 'n+n -> 2*n',
@@ -399,18 +395,19 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         total: true
       }
     } // 2 = 1 + 1 needs to exist
-
   }, {
     l: 'n+-n',
     r: '0'
   }, {
     l: 'v*n + v',
     r: 'v*(n+1)'
-  }, // NOTE: leftmost position is special:
+  },
+  // NOTE: leftmost position is special:
   {
     l: 'n3*n1 + n3*n2',
     r: 'n3*(n1+n2)'
-  }, // All sub-monomials tried there.
+  },
+  // All sub-monomials tried there.
   {
     l: 'n3^(-n4)*n1 +   n3  * n2',
     r: 'n3^(-n4)*(n1 + n3^(n4+1) *n2)'
@@ -456,7 +453,9 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: false
       }
     }
-  }, simplifyConstant, // Second: before returning expressions to "standard form"
+  }, simplifyConstant,
+  // Second: before returning expressions to "standard form"
+
   // make factors positive (and undo 'make non-constant terms positive')
   {
     s: '(-n)*n1 -> -(n*n1)',
@@ -476,7 +475,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: false
       }
     }
-  }, // final ordering of constants
+  },
+  // final ordering of constants
   {
     s: 'c+v -> v+c',
     assuming: {
@@ -501,12 +501,14 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: false
       }
     }
-  }, // undo temporary rules
+  },
+  // undo temporary rules
   // { l: '(-1) * n', r: '-n' }, // #811 added test which proved this is redundant
   {
     l: 'n+-n1',
     r: 'n-n1'
-  }, // undo replace 'subtract'
+  },
+  // undo replace 'subtract'
   {
     s: 'n*(n1^-1) -> n/n1',
     // undo replace 'divide'; for * commutative
@@ -515,7 +517,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: true
       }
     } // o.w. / not conventional
-
   }, {
     s: 'n*n1^-n2 -> n/n1^n2',
     assuming: {
@@ -523,7 +524,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: true
       }
     } // o.w. / not conventional
-
   }, {
     s: 'n^-1 -> 1/n',
     assuming: {
@@ -531,11 +531,11 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: true
       }
     } // o.w. / not conventional
-
   }, {
     l: 'n^1',
     r: 'n'
-  }, // can be produced by power cancellation
+  },
+  // can be produced by power cancellation
   {
     s: 'n*(n1/n2) -> (n*n1)/n2',
     // '*' before '/'
@@ -553,8 +553,10 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         commutative: true
       }
     }
-  }, // { l: '(n1/n2)/n3', r: 'n1/(n2*n3)' },
+  },
+  // { l: '(n1/n2)/n3', r: 'n1/(n2*n3)' },
   // { l: '(n*n1)/(n*n2)', r: 'n1/n2' },
+
   // simplifyConstant can leave an extra factor of 1, which can always
   // be eliminated, since the identity always commutes
   {
@@ -576,17 +578,15 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     l: 'n1/(-n2)',
     r: '-n1/n2'
   }];
+
   /**
    * Takes any rule object as allowed by the specification in simplify
    * and puts it in a standard form used by applyRule
    */
-
   function _canonicalizeRule(ruleObject, context) {
     var newRule = {};
-
     if (ruleObject.s) {
       var lr = ruleObject.s.split('->');
-
       if (lr.length === 2) {
         newRule.l = lr[0];
         newRule.r = lr[1];
@@ -597,38 +597,31 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       newRule.l = ruleObject.l;
       newRule.r = ruleObject.r;
     }
-
     newRule.l = removeParens(parse(newRule.l));
     newRule.r = removeParens(parse(newRule.r));
-
     for (var _i = 0, _arr = ['imposeContext', 'repeat', 'assuming']; _i < _arr.length; _i++) {
       var prop = _arr[_i];
-
       if (prop in ruleObject) {
         newRule[prop] = ruleObject[prop];
       }
     }
-
     if (ruleObject.evaluate) {
       newRule.evaluate = parse(ruleObject.evaluate);
     }
-
     if (isAssociative(newRule.l, context)) {
       var makeNode = createMakeNodeFunction(newRule.l);
-
       var expandsym = _getExpandPlaceholderSymbol();
-
       newRule.expanded = {};
-      newRule.expanded.l = makeNode([newRule.l.clone(), expandsym]); // Push the expandsym into the deepest possible branch.
+      newRule.expanded.l = makeNode([newRule.l.clone(), expandsym]);
+      // Push the expandsym into the deepest possible branch.
       // This helps to match the newRule against nodes returned from getSplits() later on.
-
       flatten(newRule.expanded.l, context);
       unflattenr(newRule.expanded.l, context);
       newRule.expanded.r = makeNode([newRule.r, expandsym]);
     }
-
     return newRule;
   }
+
   /**
    * Parse the string array of rules into nodes
    *
@@ -645,51 +638,38 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * Short hand notation:
    * 'n1 * c1 -> c1 * n1'
    */
-
-
   function _buildRules(rules, context) {
     // Array of rules to be used to simplify expressions
     var ruleSet = [];
-
     for (var i = 0; i < rules.length; i++) {
       var rule = rules[i];
       var newRule = void 0;
       var ruleType = (0, _typeof2["default"])(rule);
-
       switch (ruleType) {
         case 'string':
           rule = {
             s: rule
           };
-
         /* falls through */
-
         case 'object':
           newRule = _canonicalizeRule(rule, context);
           break;
-
         case 'function':
           newRule = rule;
           break;
-
         default:
           throw TypeError('Unsupported type of rule: ' + ruleType);
-      } // console.log('Adding rule: ' + rules[i])
+      }
+      // console.log('Adding rule: ' + rules[i])
       // console.log(newRule)
-
-
       ruleSet.push(newRule);
     }
-
     return ruleSet;
   }
-
   var _lastsym = 0;
-
   function _getExpandPlaceholderSymbol() {
     return new SymbolNode('_p' + _lastsym++);
   }
-
   function _simplify(expr, rules) {
     var scope = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (0, _map.createEmptyMap)();
     var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
@@ -701,34 +681,27 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     var str = res.toString({
       parenthesis: 'all'
     });
-
     while (!visited[str]) {
       visited[str] = true;
       _lastsym = 0; // counter for placeholder symbols
-
       var laststr = str;
       if (debug) console.log('Working on: ', str);
-
       for (var i = 0; i < rules.length; i++) {
         var rulestr = '';
-
         if (typeof rules[i] === 'function') {
           res = rules[i](res, options);
           if (debug) rulestr = rules[i].name;
         } else {
           flatten(res, options.context);
           res = applyRule(res, rules[i], options.context);
-
           if (debug) {
             rulestr = "".concat(rules[i].l.toString(), " -> ").concat(rules[i].r.toString());
           }
         }
-
         if (debug) {
           var newstr = res.toString({
             parenthesis: 'all'
           });
-
           if (newstr !== laststr) {
             console.log('Applying', rulestr, 'produced', newstr);
             laststr = newstr;
@@ -737,38 +710,30 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         /* Use left-heavy binary tree internally,
          * since custom rule functions may expect it
          */
-
-
         unflattenl(res, options.context);
       }
-
       str = res.toString({
         parenthesis: 'all'
       });
     }
-
     return res;
   }
-
   function mapRule(nodes, rule, context) {
     var resNodes = nodes;
-
     if (nodes) {
       for (var i = 0; i < nodes.length; ++i) {
         var newNode = applyRule(nodes[i], rule, context);
-
         if (newNode !== nodes[i]) {
           if (resNodes === nodes) {
             resNodes = nodes.slice();
           }
-
           resNodes[i] = newNode;
         }
       }
     }
-
     return resNodes;
   }
+
   /**
    * Returns a simplfied form of node, or the original node if no simplification was possible.
    *
@@ -777,10 +742,9 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @param  {Object} context -- information about assumed properties of operators
    * @return {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} The simplified form of `expr`, or the original node if no simplification was possible.
    */
-
-
   function applyRule(node, rule, context) {
     //    console.log('Entering applyRule("', rule.l.toString({parenthesis:'all'}), '->', rule.r.toString({parenthesis:'all'}), '",', node.toString({parenthesis:'all'}),')')
+
     // check that the assumptions for this rule are satisfied by the current
     // context:
     if (rule.assuming) {
@@ -792,16 +756,16 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         }
       }
     }
+    var mergedContext = mergeContext(rule.imposeContext, context);
 
-    var mergedContext = mergeContext(rule.imposeContext, context); // Do not clone node unless we find a match
+    // Do not clone node unless we find a match
+    var res = node;
 
-    var res = node; // First replace our child nodes with their simplified versions
+    // First replace our child nodes with their simplified versions
     // If a child could not be simplified, applying the rule to it
     // will have no effect since the node is returned unchanged
-
     if (res instanceof OperatorNode || res instanceof FunctionNode) {
       var newArgs = mapRule(res.args, rule, context);
-
       if (newArgs !== res.args) {
         res = res.clone();
         res.args = newArgs;
@@ -809,96 +773,86 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     } else if (res instanceof ParenthesisNode) {
       if (res.content) {
         var newContent = applyRule(res.content, rule, context);
-
         if (newContent !== res.content) {
           res = new ParenthesisNode(newContent);
         }
       }
     } else if (res instanceof ArrayNode) {
       var newItems = mapRule(res.items, rule, context);
-
       if (newItems !== res.items) {
         res = new ArrayNode(newItems);
       }
     } else if (res instanceof AccessorNode) {
       var newObj = res.object;
-
       if (res.object) {
         newObj = applyRule(res.object, rule, context);
       }
-
       var newIndex = res.index;
-
       if (res.index) {
         newIndex = applyRule(res.index, rule, context);
       }
-
       if (newObj !== res.object || newIndex !== res.index) {
         res = new AccessorNode(newObj, newIndex);
       }
     } else if (res instanceof IndexNode) {
       var newDims = mapRule(res.dimensions, rule, context);
-
       if (newDims !== res.dimensions) {
         res = new IndexNode(newDims);
       }
     } else if (res instanceof ObjectNode) {
       var changed = false;
       var newProps = {};
-
       for (var prop in res.properties) {
         newProps[prop] = applyRule(res.properties[prop], rule, context);
-
         if (newProps[prop] !== res.properties[prop]) {
           changed = true;
         }
       }
-
       if (changed) {
         res = new ObjectNode(newProps);
       }
-    } // Try to match a rule against this node
-
+    }
 
+    // Try to match a rule against this node
     var repl = rule.r;
+    var matches = _ruleMatch(rule.l, res, mergedContext)[0];
 
-    var matches = _ruleMatch(rule.l, res, mergedContext)[0]; // If the rule is associative operator, we can try matching it while allowing additional terms.
+    // If the rule is associative operator, we can try matching it while allowing additional terms.
     // This allows us to match rules like 'n+n' to the expression '(1+x)+x' or even 'x+1+x' if the operator is commutative.
-
-
     if (!matches && rule.expanded) {
       repl = rule.expanded.r;
       matches = _ruleMatch(rule.expanded.l, res, mergedContext)[0];
     }
-
     if (matches) {
       // const before = res.toString({parenthesis: 'all'})
+
       // Create a new node by cloning the rhs of the matched rule
       // we keep any implicit multiplication state if relevant
       var implicit = res.implicit;
       res = repl.clone();
-
       if (implicit && 'implicit' in repl) {
         res.implicit = true;
-      } // Replace placeholders with their respective nodes without traversing deeper into the replaced nodes
-
+      }
 
+      // Replace placeholders with their respective nodes without traversing deeper into the replaced nodes
       res = res.transform(function (node) {
         if (node.isSymbolNode && (0, _object.hasOwnProperty)(matches.placeholders, node.name)) {
           return matches.placeholders[node.name].clone();
         } else {
           return node;
         }
-      }); // const after = res.toString({parenthesis: 'all'})
+      });
+
+      // const after = res.toString({parenthesis: 'all'})
       // console.log('Simplified ' + before + ' to ' + after)
     }
 
     if (rule.repeat && res !== node) {
       res = applyRule(res, rule, context);
     }
-
     return res;
   }
+
   /**
    * Get (binary) combinations of a flattened binary node
    * e.g. +(node1, node2, node3) -> [
@@ -907,13 +861,10 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *        +(node3,  +(node1, node2))]
    *
    */
-
-
   function getSplits(node, context) {
     var res = [];
     var right, rightArgs;
     var makeNode = createMakeNodeFunction(node);
-
     if (isCommutative(node, context)) {
       for (var i = 0; i < node.args.length; i++) {
         rightArgs = node.args.slice(0);
@@ -925,42 +876,38 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       // Keep order, but try all parenthesizations
       for (var _i2 = 1; _i2 < node.args.length; _i2++) {
         var left = node.args[0];
-
         if (_i2 > 1) {
           left = makeNode(node.args.slice(0, _i2));
         }
-
         rightArgs = node.args.slice(_i2);
         right = rightArgs.length === 1 ? rightArgs[0] : makeNode(rightArgs);
         res.push(makeNode([left, right]));
       }
     }
-
     return res;
   }
+
   /**
    * Returns the set union of two match-placeholders or null if there is a conflict.
    */
-
-
   function mergeMatch(match1, match2) {
     var res = {
       placeholders: {}
-    }; // Some matches may not have placeholders; this is OK
+    };
 
+    // Some matches may not have placeholders; this is OK
     if (!match1.placeholders && !match2.placeholders) {
       return res;
     } else if (!match1.placeholders) {
       return match2;
     } else if (!match2.placeholders) {
       return match1;
-    } // Placeholders with the same key must match exactly
-
+    }
 
+    // Placeholders with the same key must match exactly
     for (var key in match1.placeholders) {
       if ((0, _object.hasOwnProperty)(match1.placeholders, key)) {
         res.placeholders[key] = match1.placeholders[key];
-
         if ((0, _object.hasOwnProperty)(match2.placeholders, key)) {
           if (!_exactMatch(match1.placeholders[key], match2.placeholders[key])) {
             return null;
@@ -968,69 +915,57 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         }
       }
     }
-
     for (var _key in match2.placeholders) {
       if ((0, _object.hasOwnProperty)(match2.placeholders, _key)) {
         res.placeholders[_key] = match2.placeholders[_key];
       }
     }
-
     return res;
   }
+
   /**
    * Combine two lists of matches by applying mergeMatch to the cartesian product of two lists of matches.
    * Each list represents matches found in one child of a node.
    */
-
-
   function combineChildMatches(list1, list2) {
     var res = [];
-
     if (list1.length === 0 || list2.length === 0) {
       return res;
     }
-
     var merged;
-
     for (var i1 = 0; i1 < list1.length; i1++) {
       for (var i2 = 0; i2 < list2.length; i2++) {
         merged = mergeMatch(list1[i1], list2[i2]);
-
         if (merged) {
           res.push(merged);
         }
       }
     }
-
     return res;
   }
+
   /**
    * Combine multiple lists of matches by applying mergeMatch to the cartesian product of two lists of matches.
    * Each list represents matches found in one child of a node.
    * Returns a list of unique matches.
    */
-
-
   function mergeChildMatches(childMatches) {
     if (childMatches.length === 0) {
       return childMatches;
     }
-
     var sets = childMatches.reduce(combineChildMatches);
     var uniqueSets = [];
     var unique = {};
-
     for (var i = 0; i < sets.length; i++) {
       var s = JSON.stringify(sets[i]);
-
       if (!unique[s]) {
         unique[s] = true;
         uniqueSets.push(sets[i]);
       }
     }
-
     return uniqueSets;
   }
+
   /**
    * Determines whether node matches rule.
    *
@@ -1042,17 +977,15 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *                    Defaults to false.
    * @return {Object} Information about the match, if it exists.
    */
-
-
   function _ruleMatch(rule, node, context, isSplit) {
     //    console.log('Entering _ruleMatch(' + JSON.stringify(rule) + ', ' + JSON.stringify(node) + ')')
     //    console.log('rule = ' + rule)
     //    console.log('node = ' + node)
+
     //    console.log('Entering _ruleMatch(', rule.toString({parenthesis:'all'}), ', ', node.toString({parenthesis:'all'}), ', ', context, ')')
     var res = [{
       placeholders: {}
     }];
-
     if (rule instanceof OperatorNode && node instanceof OperatorNode || rule instanceof FunctionNode && node instanceof FunctionNode) {
       // If the rule is an OperatorNode or a FunctionNode, then node must match exactly
       if (rule instanceof OperatorNode) {
@@ -1063,33 +996,29 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         if (rule.name !== node.name) {
           return [];
         }
-      } // rule and node match. Search the children of rule and node.
-
+      }
 
+      // rule and node match. Search the children of rule and node.
       if (node.args.length === 1 && rule.args.length === 1 || !isAssociative(node, context) && node.args.length === rule.args.length || isSplit) {
         // Expect non-associative operators to match exactly,
         // except in any order if operator is commutative
         var childMatches = [];
-
         for (var i = 0; i < rule.args.length; i++) {
           var childMatch = _ruleMatch(rule.args[i], node.args[i], context);
-
           if (childMatch.length === 0) {
             // Child did not match, so stop searching immediately
             break;
-          } // The child matched, so add the information returned from the child to our result
-
-
+          }
+          // The child matched, so add the information returned from the child to our result
           childMatches.push(childMatch);
         }
-
         if (childMatches.length !== rule.args.length) {
-          if (!isCommutative(node, context) || // exact match in order needed
+          if (!isCommutative(node, context) ||
+          // exact match in order needed
           rule.args.length === 1) {
             // nothing to commute
             return [];
           }
-
           if (rule.args.length > 2) {
             /* Need to generate all permutations and try them.
              * It's a bit complicated, and unlikely to come up since there
@@ -1098,23 +1027,16 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
             throw new Error('permuting >2 commutative non-associative rule arguments not yet implemented');
           }
           /* Exactly two arguments, try them reversed */
-
-
           var leftMatch = _ruleMatch(rule.args[0], node.args[1], context);
-
           if (leftMatch.length === 0) {
             return [];
           }
-
           var rightMatch = _ruleMatch(rule.args[1], node.args[0], context);
-
           if (rightMatch.length === 0) {
             return [];
           }
-
           childMatches = [leftMatch, rightMatch];
         }
-
         res = mergeChildMatches(childMatches);
       } else if (node.args.length >= 2 && rule.args.length === 2) {
         // node is flattened, rule is not
@@ -1122,14 +1044,10 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
         // them and return their union.
         var splits = getSplits(node, context);
         var splitMatches = [];
-
         for (var _i3 = 0; _i3 < splits.length; _i3++) {
           var matchSet = _ruleMatch(rule, splits[_i3], context, true); // recursing at the same tree depth here
-
-
           splitMatches = splitMatches.concat(matchSet);
         }
-
         return splitMatches;
       } else if (rule.args.length > 2) {
         throw Error('Unexpected non-binary associative function: ' + rule.toString());
@@ -1145,7 +1063,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       if (rule.name.length === 0) {
         throw new Error('Symbol in rule has 0 length...!?');
       }
-
       if (SUPPORTED_CONSTANTS[rule.name]) {
         // built-in constant must match exactly
         if (rule.name !== node.name) {
@@ -1183,12 +1100,14 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     } else {
       // Some other node was encountered which we aren't prepared for, so no match
       return [];
-    } // It's a match!
-    // console.log('_ruleMatch(' + rule.toString() + ', ' + node.toString() + ') found a match')
+    }
 
+    // It's a match!
 
+    // console.log('_ruleMatch(' + rule.toString() + ', ' + node.toString() + ') found a match')
     return res;
   }
+
   /**
    * Determines whether p and q (and all their children nodes) are identical.
    *
@@ -1196,8 +1115,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @param {ConstantNode | SymbolNode | ParenthesisNode | FunctionNode | OperatorNode} q
    * @return {Object} Information about the match, if it exists.
    */
-
-
   function _exactMatch(p, q) {
     if (p instanceof ConstantNode && q instanceof ConstantNode) {
       if (!equal(p.value, q.value)) {
@@ -1217,11 +1134,9 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
           return false;
         }
       }
-
       if (p.args.length !== q.args.length) {
         return false;
       }
-
       for (var i = 0; i < p.args.length; i++) {
         if (!_exactMatch(p.args[i], q.args[i])) {
           return false;
@@ -1230,10 +1145,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     } else {
       return false;
     }
-
     return true;
   }
-
   return simplify;
 });
 exports.createSimplify = createSimplify;