mathjs 10.1.1 → 10.2.0

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

@@ -0,0 +1,95 @@
+import { createMap, isMap } from '../../utils/map.js';
+import { isFunctionNode, isNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'resolve';
+var dependencies = ['parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    ConstantNode,
+    FunctionNode,
+    OperatorNode,
+    ParenthesisNode
+  } = _ref;
+
+  /**
+   * resolve(expr, scope) replaces variable nodes with their scoped values
+   *
+   * Syntax:
+   *
+   *     resolve(expr, scope)
+   *
+   * 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"
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node} node
+   *     The expression tree to be simplified
+   * @param {Object} scope
+   *     Scope specifying variables to be resolved
+   * @return {Node} Returns `node` with variables recursively substituted.
+   * @throws {ReferenceError}
+   *     If there is a cyclic dependency among the variables in `scope`,
+   *     resolution is impossible and a ReferenceError is thrown.
+   */
+  function resolve(node, scope) {
+    var within = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+
+    // note `within`:
+    // `within` is not documented, since it is for internal cycle
+    // detection only
+    if (!scope) {
+      return node;
+    }
+
+    if (!isMap(scope)) {
+      scope = createMap(scope);
+    }
+
+    if (isSymbolNode(node)) {
+      if (within.has(node.name)) {
+        var variables = Array.from(within).join(', ');
+        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+      }
+
+      var value = scope.get(node.name);
+
+      if (isNode(value)) {
+        var nextWithin = new Set(within);
+        nextWithin.add(node.name);
+        return resolve(value, scope, nextWithin);
+      } else if (typeof value === 'number') {
+        return parse(String(value));
+      } else if (value !== undefined) {
+        return new ConstantNode(value);
+      } else {
+        return node;
+      }
+    } else if (isOperatorNode(node)) {
+      var args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+      return new OperatorNode(node.op, node.fn, args, node.implicit);
+    } else if (isParenthesisNode(node)) {
+      return new ParenthesisNode(resolve(node.content, scope, within));
+    } else if (isFunctionNode(node)) {
+      var _args = node.args.map(function (arg) {
+        return resolve(arg, scope, within);
+      });
+
+      return new FunctionNode(node.name, _args);
+    } // Otherwise just recursively resolve any children (might also work
+    // for some of the above special cases)
+
+
+    return node.map(child => resolve(child, scope, within));
+  }
+
+  return resolve;
+});

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

@@ -386,11 +386,11 @@ export var createSimplifyConstant = /* #__PURE__ */factory(name, dependencies, _
             } else {
               res = makeNode(_args);
             }
-          } else if (isAssociative(node)) {
-            _args = allChildren(node);
+          } else if (isAssociative(node, options.context)) {
+            _args = allChildren(node, options.context);
             _args = _args.map(arg => foldFraction(arg, options));
 
-            if (isCommutative(fn)) {
+            if (isCommutative(fn, options.context)) {
               // commutative binary operator
               var consts = [];
               var vars = [];

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

@@ -1,4 +1,10 @@
-import { isOperatorNode } from '../../../utils/is.js';
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+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) { _defineProperty(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; }
+
+import { isFunctionNode, isOperatorNode, isParenthesisNode } from '../../../utils/is.js';
 import { factory } from '../../../utils/factory.js';
 import { hasOwnProperty } from '../../../utils/object.js';
 var name = 'simplifyUtil';
@@ -13,41 +19,166 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
   // e.g. multiply is not commutative for matrices
   // The properties should be calculated from an argument to simplify, or possibly something in math.config
   // the other option is for typed() to specify a return type so that we can evaluate the type of arguments
-  var commutative = {
-    add: true,
-    multiply: true
+
+  /* So that properties of an operator fit on one line: */
+  var T = true;
+  var F = false;
+  var defaultName = 'defaultF';
+  var defaultContext = {
+    /*      */
+    add: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /**/
+    unaryPlus: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /* */
+    subtract: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    },
+
+    /* */
+    multiply: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: T
+    },
+
+    /*   */
+    divide: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    },
+
+    /*    */
+    paren: {
+      trivial: T,
+      total: T,
+      commutative: T,
+      associative: F
+    },
+
+    /* */
+    defaultF: {
+      trivial: F,
+      total: T,
+      commutative: F,
+      associative: F
+    }
+  };
+  var realContext = {
+    divide: {
+      total: F
+    },
+    log: {
+      total: F
+    }
   };
-  var associative = {
-    add: true,
-    multiply: true
+  var positiveContext = {
+    subtract: {
+      total: F
+    },
+    abs: {
+      trivial: T
+    },
+    log: {
+      total: T
+    }
   };
 
-  function isCommutative(node, context) {
-    if (!isOperatorNode(node)) {
-      return true;
+  function hasProperty(nodeOrName, property) {
+    var context = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultContext;
+    var name = defaultName;
+
+    if (typeof nodeOrName === 'string') {
+      name = nodeOrName;
+    } else if (isOperatorNode(nodeOrName)) {
+      name = nodeOrName.fn.toString();
+    } else if (isFunctionNode(nodeOrName)) {
+      name = nodeOrName.name;
+    } else if (isParenthesisNode(nodeOrName)) {
+      name = 'paren';
     }
 
-    var name = node.fn.toString();
+    if (hasOwnProperty(context, name)) {
+      var properties = context[name];
 
-    if (context && hasOwnProperty(context, name) && hasOwnProperty(context[name], 'commutative')) {
-      return context[name].commutative;
+      if (hasOwnProperty(properties, property)) {
+        return properties[property];
+      }
+
+      if (hasOwnProperty(defaultContext, name)) {
+        return defaultContext[name][property];
+      }
     }
 
-    return commutative[name] || false;
-  }
+    if (hasOwnProperty(context, defaultName)) {
+      var _properties = context[defaultName];
+
+      if (hasOwnProperty(_properties, property)) {
+        return _properties[property];
+      }
+
+      return defaultContext[defaultName][property];
+    }
+    /* name not found in context and context has no global default */
+
+    /* So use default context. */
+
+
+    if (hasOwnProperty(defaultContext, name)) {
+      var _properties2 = defaultContext[name];
 
-  function isAssociative(node, context) {
-    if (!isOperatorNode(node)) {
-      return false;
+      if (hasOwnProperty(_properties2, property)) {
+        return _properties2[property];
+      }
     }
 
-    var name = node.fn.toString();
+    return defaultContext[defaultName][property];
+  }
+
+  function isCommutative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'commutative', context);
+  }
 
-    if (context && hasOwnProperty(context, name) && hasOwnProperty(context[name], 'associative')) {
-      return context[name].associative;
+  function isAssociative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'associative', context);
+  }
+  /**
+   * Merge the given contexts, with primary overriding secondary
+   * wherever they might conflict
+   */
+
+
+  function mergeContext(primary, secondary) {
+    var merged = _objectSpread({}, primary);
+
+    for (var prop in secondary) {
+      if (hasOwnProperty(primary, prop)) {
+        merged[prop] = _objectSpread(_objectSpread({}, secondary[prop]), primary[prop]);
+      } else {
+        merged[prop] = secondary[prop];
+      }
     }
 
-    return associative[name] || false;
+    return merged;
   }
   /**
    * Flatten all associative operators in an expression tree.
@@ -55,15 +186,15 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function flatten(node) {
+  function flatten(node, context) {
     if (!node.args || node.args.length === 0) {
       return node;
     }
 
-    node.args = allChildren(node);
+    node.args = allChildren(node, context);
 
     for (var i = 0; i < node.args.length; i++) {
-      flatten(node.args[i]);
+      flatten(node.args[i], context);
     }
   }
   /**
@@ -72,7 +203,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function allChildren(node) {
+  function allChildren(node, context) {
     var op;
     var children = [];
 
@@ -88,7 +219,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     };
 
-    if (isAssociative(node)) {
+    if (isAssociative(node, context)) {
       op = node.op;
       findChildren(node);
       return children;
@@ -101,7 +232,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function unflattenr(node) {
+  function unflattenr(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -110,10 +241,10 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
     var l = node.args.length;
 
     for (var i = 0; i < l; i++) {
-      unflattenr(node.args[i]);
+      unflattenr(node.args[i], context);
     }
 
-    if (l > 2 && isAssociative(node)) {
+    if (l > 2 && isAssociative(node, context)) {
       var curnode = node.args.pop();
 
       while (node.args.length > 0) {
@@ -128,7 +259,7 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
 
-  function unflattenl(node) {
+  function unflattenl(node, context) {
     if (!node.args || node.args.length === 0) {
       return;
     }
@@ -137,10 +268,10 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
     var l = node.args.length;
 
     for (var i = 0; i < l; i++) {
-      unflattenl(node.args[i]);
+      unflattenl(node.args[i], context);
     }
 
-    if (l > 2 && isAssociative(node)) {
+    if (l > 2 && isAssociative(node, context)) {
       var curnode = node.args.shift();
 
       while (node.args.length > 0) {
@@ -170,11 +301,16 @@ export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   return {
     createMakeNodeFunction,
+    hasProperty,
     isCommutative,
     isAssociative,
+    mergeContext,
     flatten,
     allChildren,
     unflattenr,
-    unflattenl
+    unflattenl,
+    defaultContext,
+    realContext,
+    positiveContext
   };
 });