mathjs 10.6.4 → 11.1.0

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

@@ -9,10 +9,8 @@ var _number = require("../../utils/number.js");
 
 var _factory = require("../../utils/factory.js");
 
-var _simplifyConstant = require("./simplify/simplifyConstant.js");
-
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
+var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', 'simplifyConstant', 'simplifyCore', 'simplify', '?bignumber', '?fraction', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'SymbolNode', 'ParenthesisNode'];
 var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
       typed = _ref.typed,
@@ -24,6 +22,7 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       divide = _ref.divide,
       pow = _ref.pow,
       parse = _ref.parse,
+      simplifyConstant = _ref.simplifyConstant,
       simplifyCore = _ref.simplifyCore,
       simplify = _ref.simplify,
       fraction = _ref.fraction,
@@ -39,22 +38,7 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       OperatorNode = _ref.OperatorNode,
       SymbolNode = _ref.SymbolNode,
       ParenthesisNode = _ref.ParenthesisNode;
-  var simplifyConstant = (0, _simplifyConstant.createSimplifyConstant)({
-    typed: typed,
-    config: config,
-    mathWithTransform: mathWithTransform,
-    matrix: matrix,
-    fraction: fraction,
-    bignumber: bignumber,
-    AccessorNode: AccessorNode,
-    ArrayNode: ArrayNode,
-    ConstantNode: ConstantNode,
-    FunctionNode: FunctionNode,
-    IndexNode: IndexNode,
-    ObjectNode: ObjectNode,
-    OperatorNode: OperatorNode,
-    SymbolNode: SymbolNode
-  });
+
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -108,116 +92,102 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *           {Expression Node}  node simplified expression
    *
    */
+  function _rationalize(expr) {
+    var scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var detailed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
 
-  return typed(name, {
-    string: function string(expr) {
-      return this(parse(expr), {}, false);
-    },
-    'string, boolean': function stringBoolean(expr, detailed) {
-      return this(parse(expr), {}, detailed);
-    },
-    'string, Object': function stringObject(expr, scope) {
-      return this(parse(expr), scope, false);
-    },
-    'string, Object, boolean': function stringObjectBoolean(expr, scope, detailed) {
-      return this(parse(expr), scope, detailed);
-    },
-    Node: function Node(expr) {
-      return this(expr, {}, false);
-    },
-    'Node, boolean': function NodeBoolean(expr, detailed) {
-      return this(expr, {}, detailed);
-    },
-    'Node, Object': function NodeObject(expr, scope) {
-      return this(expr, scope, false);
-    },
-    'Node, Object, boolean': function NodeObjectBoolean(expr, scope, detailed) {
-      var setRules = rulesRationalize(); // Rules for change polynomial in near canonical form
-
-      var polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
+    var polyRet = polynomial(expr, scope, true, setRules.firstRules); // Check if expression is a rationalizable polynomial
 
-      var nVars = polyRet.variables.length;
-      var noExactFractions = {
-        exactFractions: false
-      };
-      var withExactFractions = {
-        exactFractions: true
-      };
-      expr = polyRet.expression;
-
-      if (nVars >= 1) {
-        // If expression in not a constant
-        expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
+    var nVars = polyRet.variables.length;
+    var noExactFractions = {
+      exactFractions: false
+    };
+    var withExactFractions = {
+      exactFractions: true
+    };
+    expr = polyRet.expression;
 
-        var sBefore; // Previous expression
+    if (nVars >= 1) {
+      // If expression in not a constant
+      expr = expandPower(expr); // First expand power of polynomials (cannot be made from rules!)
 
-        var rules;
-        var eDistrDiv = true;
-        var redoInic = false; // Apply the initial rules, including succ div rules:
+      var sBefore; // Previous expression
 
-        expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
-        var s;
+      var rules;
+      var eDistrDiv = true;
+      var redoInic = false; // Apply the initial rules, including succ div rules:
 
-        while (true) {
-          // Alternate applying successive division rules and distr.div.rules
-          // until there are no more changes:
-          rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
-          expr = simplify(expr, rules, {}, withExactFractions);
-          eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
+      expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
+      var s;
 
-          s = expr.toString();
+      while (true) {
+        // Alternate applying successive division rules and distr.div.rules
+        // until there are no more changes:
+        rules = eDistrDiv ? setRules.distrDivRules : setRules.sucDivRules;
+        expr = simplify(expr, rules, {}, withExactFractions);
+        eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
-          if (s === sBefore) {
-            break; // No changes : end of the loop
-          }
+        s = expr.toString();
 
-          redoInic = true;
-          sBefore = s;
+        if (s === sBefore) {
+          break; // No changes : end of the loop
         }
 
-        if (redoInic) {
-          // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
-        } // Apply final rules:
+        redoInic = true;
+        sBefore = s;
+      }
 
+      if (redoInic) {
+        // Apply first rules again without succ div rules (if there are changes)
+        expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
+      } // Apply final rules:
 
-        expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
-      } // NVars >= 1
 
+      expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
+    } // NVars >= 1
 
-      var coefficients = [];
-      var retRationalize = {};
 
-      if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
-        // Separate numerator from denominator
-        if (nVars === 1) {
-          expr.args[0] = polyToCanonical(expr.args[0], coefficients);
-          expr.args[1] = polyToCanonical(expr.args[1]);
-        }
+    var coefficients = [];
+    var retRationalize = {};
 
-        if (detailed) {
-          retRationalize.numerator = expr.args[0];
-          retRationalize.denominator = expr.args[1];
-        }
-      } else {
-        if (nVars === 1) {
-          expr = polyToCanonical(expr, coefficients);
-        }
+    if (expr.type === 'OperatorNode' && expr.isBinary() && expr.op === '/') {
+      // Separate numerator from denominator
+      if (nVars === 1) {
+        expr.args[0] = polyToCanonical(expr.args[0], coefficients);
+        expr.args[1] = polyToCanonical(expr.args[1]);
+      }
 
-        if (detailed) {
-          retRationalize.numerator = expr;
-          retRationalize.denominator = null;
-        }
-      } // nVars
+      if (detailed) {
+        retRationalize.numerator = expr.args[0];
+        retRationalize.denominator = expr.args[1];
+      }
+    } else {
+      if (nVars === 1) {
+        expr = polyToCanonical(expr, coefficients);
+      }
+
+      if (detailed) {
+        retRationalize.numerator = expr;
+        retRationalize.denominator = null;
+      }
+    } // nVars
 
 
-      if (!detailed) return expr;
-      retRationalize.coefficients = coefficients;
-      retRationalize.variables = polyRet.variables;
-      retRationalize.expression = expr;
-      return retRationalize;
-    } // ^^^^^^^ end of rationalize ^^^^^^^^
+    if (!detailed) return expr;
+    retRationalize.coefficients = coefficients;
+    retRationalize.variables = polyRet.variables;
+    retRationalize.expression = expr;
+    return retRationalize;
+  }
 
+  return typed(name, {
+    Node: _rationalize,
+    'Node, boolean': function NodeBoolean(expr, detailed) {
+      return _rationalize(expr, {}, detailed);
+    },
+    'Node, Object': _rationalize,
+    'Node, Object, boolean': _rationalize
   }); // end of typed rationalize
 
   /**

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

@@ -12,9 +12,10 @@ var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
 
 var name = 'resolve';
-var dependencies = ['parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+var dependencies = ['typed', 'parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
 var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var parse = _ref.parse,
+  var typed = _ref.typed,
+      parse = _ref.parse,
       ConstantNode = _ref.ConstantNode,
       FunctionNode = _ref.FunctionNode,
       OperatorNode = _ref.OperatorNode,
@@ -29,9 +30,9 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *
    * Examples:
    *
-   *     math.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
+   *     math.resolve('x + y', {x:1, y:2})           // Node '1 + 2'
+   *     math.resolve(math.parse('x+y'), {x:1, y:2}) // Node '1 + 2'
+   *     math.simplify('x+y', {x:2, y: math.parse('x+x')}).toString() // "6"
    *
    * See also:
    *
@@ -46,7 +47,7 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *     If there is a cyclic dependency among the variables in `scope`,
    *     resolution is impossible and a ReferenceError is thrown.
    */
-  function resolve(node, scope) {
+  function _resolve(node, scope) {
     var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
 
     // note `within`:
@@ -56,10 +57,6 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
       return node;
     }
 
-    if (!(0, _map.isMap)(scope)) {
-      scope = (0, _map.createMap)(scope);
-    }
-
     if ((0, _is.isSymbolNode)(node)) {
       if (within.has(node.name)) {
         var variables = Array.from(within).join(', ');
@@ -71,7 +68,7 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
       if ((0, _is.isNode)(value)) {
         var nextWithin = new Set(within);
         nextWithin.add(node.name);
-        return resolve(value, scope, nextWithin);
+        return _resolve(value, scope, nextWithin);
       } else if (typeof value === 'number') {
         return parse(String(value));
       } else if (value !== undefined) {
@@ -81,14 +78,14 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
       }
     } else if ((0, _is.isOperatorNode)(node)) {
       var args = node.args.map(function (arg) {
-        return resolve(arg, scope, within);
+        return _resolve(arg, scope, within);
       });
       return new OperatorNode(node.op, node.fn, args, node.implicit);
     } else if ((0, _is.isParenthesisNode)(node)) {
-      return new ParenthesisNode(resolve(node.content, scope, within));
+      return new ParenthesisNode(_resolve(node.content, scope, within));
     } else if ((0, _is.isFunctionNode)(node)) {
       var _args = node.args.map(function (arg) {
-        return resolve(arg, scope, within);
+        return _resolve(arg, scope, within);
       });
 
       return new FunctionNode(node.name, _args);
@@ -97,10 +94,50 @@ var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
 
     return node.map(function (child) {
-      return resolve(child, scope, within);
+      return _resolve(child, scope, within);
     });
   }
 
-  return resolve;
+  return typed('resolve', {
+    Node: _resolve,
+    'Node, Map | null | undefined': _resolve,
+    'Node, Object': function NodeObject(n, scope) {
+      return _resolve(n, (0, _map.createMap)(scope));
+    },
+    // For arrays and matrices, we map `self` rather than `_resolve`
+    // because resolve is fairly expensive anyway, and this way
+    // we get nice error messages if one entry in the array has wrong type.
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (A) {
+        return A.map(function (n) {
+          return self(n);
+        });
+      };
+    }),
+    'Array | Matrix, null | undefined': typed.referToSelf(function (self) {
+      return function (A) {
+        return A.map(function (n) {
+          return self(n);
+        });
+      };
+    }),
+    'Array, Object': typed.referTo('Array,Map', function (selfAM) {
+      return function (A, scope) {
+        return selfAM(A, (0, _map.createMap)(scope));
+      };
+    }),
+    'Matrix, Object': typed.referTo('Matrix,Map', function (selfMM) {
+      return function (A, scope) {
+        return selfMM(A, (0, _map.createMap)(scope));
+      };
+    }),
+    'Array | Matrix, Map': typed.referToSelf(function (self) {
+      return function (A, scope) {
+        return A.map(function (n) {
+          return self(n, scope);
+        });
+      };
+    })
+  });
 });
 exports.createResolve = createResolve;

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

@@ -17,7 +17,7 @@ var _object = require("../../../utils/object.js");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 var name = 'simplifyUtil';
 var dependencies = ['FunctionNode', 'OperatorNode', 'SymbolNode'];

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

@@ -15,14 +15,12 @@ var _factory = require("../../utils/factory.js");
 
 var _util = require("./simplify/util.js");
 
-var _simplifyConstant = require("./simplify/simplifyConstant.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', 'simplifyCore', '?fraction', '?bignumber', 'mathWithTransform', 'matrix', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
+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,
@@ -35,6 +33,7 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       isZero = _ref.isZero,
       equal = _ref.equal,
       resolve = _ref.resolve,
+      simplifyConstant = _ref.simplifyConstant,
       simplifyCore = _ref.simplifyCore,
       fraction = _ref.fraction,
       bignumber = _ref.bignumber,
@@ -49,22 +48,6 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       OperatorNode = _ref.OperatorNode,
       ParenthesisNode = _ref.ParenthesisNode,
       SymbolNode = _ref.SymbolNode;
-  var simplifyConstant = (0, _simplifyConstant.createSimplifyConstant)({
-    typed: typed,
-    config: config,
-    mathWithTransform: mathWithTransform,
-    matrix: matrix,
-    fraction: fraction,
-    bignumber: bignumber,
-    AccessorNode: AccessorNode,
-    ArrayNode: ArrayNode,
-    ConstantNode: ConstantNode,
-    FunctionNode: FunctionNode,
-    IndexNode: IndexNode,
-    ObjectNode: ObjectNode,
-    OperatorNode: OperatorNode,
-    SymbolNode: SymbolNode
-  });
 
   var _createUtil = (0, _util.createUtil)({
     FunctionNode: FunctionNode,
@@ -110,7 +93,10 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * - 'v' - matches any Node that is not a ConstantNode
    *
    * The default list of rules is exposed on the function as `simplify.rules`
-   * and can be used as a basis to built a set of custom rules.
+   * and can be used as a basis to built a set of custom rules. Note that since
+   * the `simplifyCore` function is in the default list of rules, by default
+   * simplify will convert any function calls in the expression that have
+   * operator equivalents to their operator forms.
    *
    * To specify a rule as a string, separate the left and right pattern by '->'
    * When specifying a rule as an object, the following keys are meaningful:
@@ -181,106 +167,35 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    *
    * @param {Node | string} expr
    *            The expression to be simplified
-   * @param {Array<{l:string, r: string} | string | function>} [rules]
+   * @param {SimplifyRule[]} [rules]
    *            Optional list with custom rules
+   * @param {Object} [scope] Optional scope with variables
+   * @param {SimplifyOptions} [options] Optional configuration settings
    * @return {Node} Returns the simplified form of `expr`
    */
 
 
+  typed.addConversion({
+    from: 'Object',
+    to: 'Map',
+    convert: _map.createMap
+  });
   var simplify = typed('simplify', {
-    string: function string(expr) {
-      return this(parse(expr), this.rules, (0, _map.createEmptyMap)(), {});
-    },
-    'string, Map | Object': function stringMapObject(expr, scope) {
-      return this(parse(expr), this.rules, scope, {});
-    },
-    'string, Map | Object, Object': function stringMapObjectObject(expr, scope, options) {
-      return this(parse(expr), this.rules, scope, options);
-    },
-    'string, Array': function stringArray(expr, rules) {
-      return this(parse(expr), rules, (0, _map.createEmptyMap)(), {});
-    },
-    'string, Array, Map | Object': function stringArrayMapObject(expr, rules, scope) {
-      return this(parse(expr), rules, scope, {});
-    },
-    'string, Array, Map | Object, Object': function stringArrayMapObjectObject(expr, rules, scope, options) {
-      return this(parse(expr), rules, scope, options);
-    },
-    'Node, Map | Object': function NodeMapObject(expr, scope) {
-      return this(expr, this.rules, scope, {});
-    },
-    'Node, Map | Object, Object': function NodeMapObjectObject(expr, scope, options) {
-      return this(expr, this.rules, scope, options);
-    },
-    Node: function Node(expr) {
-      return this(expr, this.rules, (0, _map.createEmptyMap)(), {});
-    },
-    'Node, Array': function NodeArray(expr, rules) {
-      return this(expr, rules, (0, _map.createEmptyMap)(), {});
-    },
-    'Node, Array, Map | Object': function NodeArrayMapObject(expr, rules, scope) {
-      return this(expr, rules, scope, {});
+    Node: _simplify,
+    'Node, Map': function NodeMap(expr, scope) {
+      return _simplify(expr, false, scope);
     },
-    'Node, Array, Object, Object': function NodeArrayObjectObject(expr, rules, scope, options) {
-      return this(expr, rules, (0, _map.createMap)(scope), options);
+    'Node, Map, Object': function NodeMapObject(expr, scope, options) {
+      return _simplify(expr, false, scope, options);
     },
-    'Node, Array, Map, Object': function NodeArrayMapObject(expr, rules, scope, options) {
-      var debug = options.consoleDebug;
-      rules = _buildRules(rules, options.context);
-      var res = resolve(expr, scope);
-      res = removeParens(res);
-      var visited = {};
-      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;
-            }
-          }
-          /* Use left-heavy binary tree internally,
-           * since custom rule functions may expect it
-           */
-
-
-          unflattenl(res, options.context);
-        }
-
-        str = res.toString({
-          parenthesis: 'all'
-        });
-      }
-
-      return res;
-    }
+    'Node, Array': _simplify,
+    'Node, Array, Map': _simplify,
+    'Node, Array, Map, Object': _simplify
+  });
+  typed.removeConversion({
+    from: 'Object',
+    to: 'Map',
+    convert: _map.createMap
   });
   simplify.defaultContext = defaultContext;
   simplify.realContext = realContext;
@@ -294,8 +209,8 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
 
 
   var SUPPORTED_CONSTANTS = {
-    true: true,
-    false: true,
+    "true": true,
+    "false": true,
     e: true,
     i: true,
     Infinity: true,
@@ -739,7 +654,7 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     for (var i = 0; i < rules.length; i++) {
       var rule = rules[i];
       var newRule = void 0;
-      var ruleType = (0, _typeof2.default)(rule);
+      var ruleType = (0, _typeof2["default"])(rule);
 
       switch (ruleType) {
         case 'string':
@@ -775,6 +690,66 @@ var createSimplify = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     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;
+    rules = _buildRules(rules || simplify.rules, options.context);
+    var res = resolve(expr, scope);
+    res = removeParens(res);
+    var visited = {};
+    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;
+          }
+        }
+        /* 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;