mathjs 12.4.3 → 13.0.0

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

@@ -1,62 +1,63 @@
 "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 _wildcards = require("./simplify/wildcards.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 = exports.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;
-  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;
+const name = 'simplify';
+const 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'];
+const createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    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
+  } = _ref;
+  const {
+    hasProperty,
+    isCommutative,
+    isAssociative,
+    mergeContext,
+    flatten,
+    unflattenr,
+    unflattenl,
+    createMakeNodeFunction,
+    defaultContext,
+    realContext,
+    positiveContext
+  } = (0, _util.createUtil)({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
 
   /**
    * Simplify an expression tree.
@@ -177,14 +178,10 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     to: 'Map',
     convert: _map.createMap
   });
-  var simplify = typed('simplify', {
+  const simplify = typed('simplify', {
     Node: _simplify,
-    'Node, Map': function NodeMap(expr, scope) {
-      return _simplify(expr, false, scope);
-    },
-    'Node, Map, Object': function NodeMapObject(expr, scope, options) {
-      return _simplify(expr, false, scope, options);
-    },
+    'Node, Map': (expr, scope) => _simplify(expr, false, scope),
+    'Node, Map, Object': (expr, scope, options) => _simplify(expr, false, scope, options),
     'Node, Array': _simplify,
     'Node, Array, Map': _simplify,
     'Node, Array, Map, Object': _simplify
@@ -204,9 +201,9 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
   }
 
   // All constants that are allowed in rules
-  var SUPPORTED_CONSTANTS = {
-    "true": true,
-    "false": true,
+  const SUPPORTED_CONSTANTS = {
+    true: true,
+    false: true,
     e: true,
     i: true,
     Infinity: true,
@@ -619,9 +616,9 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
    * and puts it in a standard form used by applyRule
    */
   function _canonicalizeRule(ruleObject, context) {
-    var newRule = {};
+    const newRule = {};
     if (ruleObject.s) {
-      var lr = ruleObject.s.split('->');
+      const lr = ruleObject.s.split('->');
       if (lr.length === 2) {
         newRule.l = lr[0];
         newRule.r = lr[1];
@@ -634,8 +631,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     }
     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];
+    for (const prop of ['imposeContext', 'repeat', 'assuming']) {
       if (prop in ruleObject) {
         newRule[prop] = ruleObject[prop];
       }
@@ -644,12 +640,12 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
       newRule.evaluate = parse(ruleObject.evaluate);
     }
     if (isAssociative(newRule.l, context)) {
-      var nonCommutative = !isCommutative(newRule.l, context);
-      var leftExpandsym;
+      const nonCommutative = !isCommutative(newRule.l, context);
+      let leftExpandsym;
       // Gen. the LHS placeholder used in this NC-context specific expansion rules
       if (nonCommutative) leftExpandsym = _getExpandPlaceholderSymbol();
-      var makeNode = createMakeNodeFunction(newRule.l);
-      var expandsym = _getExpandPlaceholderSymbol();
+      const makeNode = createMakeNodeFunction(newRule.l);
+      const expandsym = _getExpandPlaceholderSymbol();
       newRule.expanded = {};
       newRule.expanded.l = makeNode([newRule.l, expandsym]);
       // Push the expandsym into the deepest possible branch.
@@ -693,11 +689,11 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
    */
   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);
+    const ruleSet = [];
+    for (let i = 0; i < rules.length; i++) {
+      let rule = rules[i];
+      let newRule;
+      const ruleType = typeof rule;
       switch (ruleType) {
         case 'string':
           rule = {
@@ -719,28 +715,28 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     }
     return ruleSet;
   }
-  var _lastsym = 0;
+  let _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] : {};
-    var debug = options.consoleDebug;
+    let scope = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : (0, _map.createEmptyMap)();
+    let options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const debug = options.consoleDebug;
     rules = _buildRules(rules || simplify.rules, options.context);
-    var res = resolve(expr, scope);
+    let res = resolve(expr, scope);
     res = removeParens(res);
-    var visited = {};
-    var str = res.toString({
+    const visited = {};
+    let str = res.toString({
       parenthesis: 'all'
     });
     while (!visited[str]) {
       visited[str] = true;
       _lastsym = 0; // counter for placeholder symbols
-      var laststr = str;
+      let laststr = str;
       if (debug) console.log('Working on: ', str);
-      for (var i = 0; i < rules.length; i++) {
-        var rulestr = '';
+      for (let i = 0; i < rules.length; i++) {
+        let rulestr = '';
         if (typeof rules[i] === 'function') {
           res = rules[i](res, options);
           if (debug) rulestr = rules[i].name;
@@ -748,11 +744,11 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
           flatten(res, options.context);
           res = applyRule(res, rules[i], options.context);
           if (debug) {
-            rulestr = "".concat(rules[i].l.toString(), " -> ").concat(rules[i].r.toString());
+            rulestr = `${rules[i].l.toString()} -> ${rules[i].r.toString()}`;
           }
         }
         if (debug) {
-          var newstr = res.toString({
+          const newstr = res.toString({
             parenthesis: 'all'
           });
           if (newstr !== laststr) {
@@ -772,10 +768,10 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     return res;
   }
   function mapRule(nodes, rule, context) {
-    var resNodes = nodes;
+    let resNodes = nodes;
     if (nodes) {
-      for (var i = 0; i < nodes.length; ++i) {
-        var newNode = applyRule(nodes[i], rule, context);
+      for (let i = 0; i < nodes.length; ++i) {
+        const newNode = applyRule(nodes[i], rule, context);
         if (newNode !== nodes[i]) {
           if (resNodes === nodes) {
             resNodes = nodes.slice();
@@ -801,46 +797,46 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     // check that the assumptions for this rule are satisfied by the current
     // context:
     if (rule.assuming) {
-      for (var symbol in rule.assuming) {
-        for (var property in rule.assuming[symbol]) {
+      for (const symbol in rule.assuming) {
+        for (const property in rule.assuming[symbol]) {
           if (hasProperty(symbol, property, context) !== rule.assuming[symbol][property]) {
             return node;
           }
         }
       }
     }
-    var mergedContext = mergeContext(rule.imposeContext, context);
+    const mergedContext = mergeContext(rule.imposeContext, context);
 
     // Do not clone node unless we find a match
-    var res = node;
+    let res = node;
 
     // 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);
+      const newArgs = mapRule(res.args, rule, context);
       if (newArgs !== res.args) {
         res = res.clone();
         res.args = newArgs;
       }
     } else if (res instanceof ParenthesisNode) {
       if (res.content) {
-        var newContent = applyRule(res.content, rule, context);
+        const 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);
+      const newItems = mapRule(res.items, rule, context);
       if (newItems !== res.items) {
         res = new ArrayNode(newItems);
       }
     } else if (res instanceof AccessorNode) {
-      var newObj = res.object;
+      let newObj = res.object;
       if (res.object) {
         newObj = applyRule(res.object, rule, context);
       }
-      var newIndex = res.index;
+      let newIndex = res.index;
       if (res.index) {
         newIndex = applyRule(res.index, rule, context);
       }
@@ -848,14 +844,14 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
         res = new AccessorNode(newObj, newIndex);
       }
     } else if (res instanceof IndexNode) {
-      var newDims = mapRule(res.dimensions, rule, context);
+      const 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) {
+      let changed = false;
+      const newProps = {};
+      for (const prop in res.properties) {
         newProps[prop] = applyRule(res.properties[prop], rule, context);
         if (newProps[prop] !== res.properties[prop]) {
           changed = true;
@@ -867,8 +863,8 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     }
 
     // Try to match a rule against this node
-    var repl = rule.r;
-    var matches = _ruleMatch(rule.l, res, mergedContext)[0];
+    let repl = rule.r;
+    let matches = _ruleMatch(rule.l, res, mergedContext)[0];
 
     // 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.
@@ -891,7 +887,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
 
       // Create a new node by cloning the rhs of the matched rule
       // we keep any implicit multiplication state if relevant
-      var implicit = res.implicit;
+      const implicit = res.implicit;
       res = repl.clone();
       if (implicit && 'implicit' in repl) {
         res.implicit = true;
@@ -924,11 +920,11 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
    *
    */
   function getSplits(node, context) {
-    var res = [];
-    var right, rightArgs;
-    var makeNode = createMakeNodeFunction(node);
+    const res = [];
+    let right, rightArgs;
+    const makeNode = createMakeNodeFunction(node);
     if (isCommutative(node, context)) {
-      for (var i = 0; i < node.args.length; i++) {
+      for (let i = 0; i < node.args.length; i++) {
         rightArgs = node.args.slice(0);
         rightArgs.splice(i, 1);
         right = rightArgs.length === 1 ? rightArgs[0] : makeNode(rightArgs);
@@ -936,12 +932,12 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
       }
     } else {
       // 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));
+      for (let i = 1; i < node.args.length; i++) {
+        let left = node.args[0];
+        if (i > 1) {
+          left = makeNode(node.args.slice(0, i));
         }
-        rightArgs = node.args.slice(_i2);
+        rightArgs = node.args.slice(i);
         right = rightArgs.length === 1 ? rightArgs[0] : makeNode(rightArgs);
         res.push(makeNode([left, right]));
       }
@@ -953,7 +949,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
    * Returns the set union of two match-placeholders or null if there is a conflict.
    */
   function mergeMatch(match1, match2) {
-    var res = {
+    const res = {
       placeholders: {}
     };
 
@@ -967,7 +963,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     }
 
     // Placeholders with the same key must match exactly
-    for (var key in match1.placeholders) {
+    for (const key in match1.placeholders) {
       if ((0, _object.hasOwnProperty)(match1.placeholders, key)) {
         res.placeholders[key] = match1.placeholders[key];
         if ((0, _object.hasOwnProperty)(match2.placeholders, key)) {
@@ -977,9 +973,9 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
         }
       }
     }
-    for (var _key in match2.placeholders) {
-      if ((0, _object.hasOwnProperty)(match2.placeholders, _key)) {
-        res.placeholders[_key] = match2.placeholders[_key];
+    for (const key in match2.placeholders) {
+      if ((0, _object.hasOwnProperty)(match2.placeholders, key)) {
+        res.placeholders[key] = match2.placeholders[key];
       }
     }
     return res;
@@ -990,13 +986,13 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
    * Each list represents matches found in one child of a node.
    */
   function combineChildMatches(list1, list2) {
-    var res = [];
+    const 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++) {
+    let merged;
+    for (let i1 = 0; i1 < list1.length; i1++) {
+      for (let i2 = 0; i2 < list2.length; i2++) {
         merged = mergeMatch(list1[i1], list2[i2]);
         if (merged) {
           res.push(merged);
@@ -1015,11 +1011,11 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     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]);
+    const sets = childMatches.reduce(combineChildMatches);
+    const uniqueSets = [];
+    const unique = {};
+    for (let i = 0; i < sets.length; i++) {
+      const s = JSON.stringify(sets[i]);
       if (!unique[s]) {
         unique[s] = true;
         uniqueSets.push(sets[i]);
@@ -1045,7 +1041,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
     //    console.log('node = ' + node)
 
     //    console.log('Entering _ruleMatch(', rule.toString({parenthesis:'all'}), ', ', node.toString({parenthesis:'all'}), ', ', context, ')')
-    var res = [{
+    let res = [{
       placeholders: {}
     }];
     if (rule instanceof OperatorNode && node instanceof OperatorNode || rule instanceof FunctionNode && node instanceof FunctionNode) {
@@ -1064,9 +1060,9 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
       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);
+        let childMatches = [];
+        for (let i = 0; i < rule.args.length; i++) {
+          const childMatch = _ruleMatch(rule.args[i], node.args[i], context);
           if (childMatch.length === 0) {
             // Child did not match, so stop searching immediately
             break;
@@ -1089,11 +1085,11 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
             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);
+          const leftMatch = _ruleMatch(rule.args[0], node.args[1], context);
           if (leftMatch.length === 0) {
             return [];
           }
-          var rightMatch = _ruleMatch(rule.args[1], node.args[0], context);
+          const rightMatch = _ruleMatch(rule.args[1], node.args[0], context);
           if (rightMatch.length === 0) {
             return [];
           }
@@ -1104,10 +1100,10 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
         // node is flattened, rule is not
         // Associative operators/functions can be split in different ways so we check if the rule
         // matches for each of 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
+        const splits = getSplits(node, context);
+        let splitMatches = [];
+        for (let i = 0; i < splits.length; i++) {
+          const matchSet = _ruleMatch(rule, splits[i], context, true); // recursing at the same tree depth here
           splitMatches = splitMatches.concat(matchSet);
         }
         return splitMatches;
@@ -1252,7 +1248,7 @@ var createSimplify = exports.createSimplify = /* #__PURE__ */(0, _factory.factor
       if (p.args.length !== q.args.length) {
         return false;
       }
-      for (var i = 0; i < p.args.length; i++) {
+      for (let i = 0; i < p.args.length; i++) {
         if (!_exactMatch(p.args[i], q.args[i])) {
           return false;
         }