mathjs 10.6.2 → 11.0.0

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

@@ -1,11 +1,10 @@
 import { isConstantNode, isParenthesisNode } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 import { createUtil } from './simplify/util.js';
-import { createSimplifyConstant } from './simplify/simplifyConstant.js';
 import { hasOwnProperty } from '../../utils/object.js';
 import { createEmptyMap, createMap } from '../../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'];
 export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -19,6 +18,7 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     isZero,
     equal,
     resolve,
+    simplifyConstant,
     simplifyCore,
     fraction,
     bignumber,
@@ -34,22 +34,6 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     ParenthesisNode,
     SymbolNode
   } = _ref;
-  var simplifyConstant = createSimplifyConstant({
-    typed,
-    config,
-    mathWithTransform,
-    matrix,
-    fraction,
-    bignumber,
-    AccessorNode,
-    ArrayNode,
-    ConstantNode,
-    FunctionNode,
-    IndexNode,
-    ObjectNode,
-    OperatorNode,
-    SymbolNode
-  });
   var {
     hasProperty,
     isCommutative,
@@ -95,7 +79,10 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
    * - '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:
@@ -171,100 +158,23 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Node} Returns the simplified form of `expr`
    */
 
+  typed.addConversion({
+    from: 'Object',
+    to: 'Map',
+    convert: createMap
+  });
   var simplify = typed('simplify', {
-    string: function string(expr) {
-      return this(parse(expr), this.rules, 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, 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, createEmptyMap(), {});
-    },
-    'Node, Array': function NodeArray(expr, rules) {
-      return this(expr, rules, createEmptyMap(), {});
-    },
-    'Node, Array, Map | Object': function NodeArrayMapObject(expr, rules, scope) {
-      return this(expr, rules, scope, {});
-    },
-    'Node, Array, Object, Object': function NodeArrayObjectObject(expr, rules, scope, options) {
-      return this(expr, rules, createMap(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: _simplify,
+    '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
+  });
+  typed.removeConversion({
+    from: 'Object',
+    to: 'Map',
+    convert: createMap
   });
   simplify.defaultContext = defaultContext;
   simplify.realContext = realContext;
@@ -757,6 +667,66 @@ export var createSimplify = /* #__PURE__ */factory(name, dependencies, _ref => {
     return new SymbolNode('_p' + _lastsym++);
   }
 
+  function _simplify(expr, rules) {
+    var scope = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 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;
 

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

@@ -1,13 +1,13 @@
-// TODO this could be improved by simplifying seperated constants under associative and commutative operators
-import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
-import { createUtil } from './util.js';
-import { noBignumber, noFraction } from '../../../utils/noop.js';
+import { isFraction, isMatrix, isNode, isArrayNode, isConstantNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+import { createUtil } from './simplify/util.js';
+import { noBignumber, noFraction } from '../../utils/noop.js';
 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'];
 export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    parse,
     config,
     mathWithTransform,
     matrix,
@@ -32,10 +32,40 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
     OperatorNode,
     SymbolNode
   });
+  /**
+   * 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: node => _ensureNode(foldFraction(node, {})),
+    'Node, Object': function NodeObject(expr, options) {
+      return _ensureNode(foldFraction(expr, options));
+    }
+  });
 
   function _removeFractions(thing) {
     if (isFraction(thing)) {