mathjs-min 11.7.2

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

@@ -0,0 +1,97 @@
+import { createMap } 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 = ['typed', 'parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    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: math.parse('x+x')}).toString() // "6"
+   *
+   * See also:
+   *
+   *     simplify, evaluate
+   *
+   * @param {Node | Node[]} node
+   *     The expression tree (or trees) to be simplified
+   * @param {Object} scope
+   *     Scope specifying variables to be resolved
+   * @return {Node | 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 (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 typed('resolve', {
+    Node: _resolve,
+    'Node, Map | null | undefined': _resolve,
+    'Node, Object': (n, scope) => _resolve(n, 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(self => A => A.map(n => self(n))),
+    'Array | Matrix, null | undefined': typed.referToSelf(self => A => A.map(n => self(n))),
+    'Array, Object': typed.referTo('Array,Map', selfAM => (A, scope) => selfAM(A, createMap(scope))),
+    'Matrix, Object': typed.referTo('Matrix,Map', selfMM => (A, scope) => selfMM(A, createMap(scope))),
+    'Array | Matrix, Map': typed.referToSelf(self => (A, scope) => A.map(n => self(n, scope)))
+  });
+});

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

@@ -0,0 +1,261 @@
+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';
+var dependencies = ['FunctionNode', 'OperatorNode', 'SymbolNode'];
+export var createUtil = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  } = _ref;
+  // TODO commutative/associative properties rely on the arguments
+  // 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
+
+  /* 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 positiveContext = {
+    subtract: {
+      total: F
+    },
+    abs: {
+      trivial: T
+    },
+    log: {
+      total: T
+    }
+  };
+  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';
+    }
+    if (hasOwnProperty(context, name)) {
+      var properties = context[name];
+      if (hasOwnProperty(properties, property)) {
+        return properties[property];
+      }
+      if (hasOwnProperty(defaultContext, name)) {
+        return defaultContext[name][property];
+      }
+    }
+    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];
+      if (hasOwnProperty(_properties2, property)) {
+        return _properties2[property];
+      }
+    }
+    return defaultContext[defaultName][property];
+  }
+  function isCommutative(node) {
+    var context = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultContext;
+    return hasProperty(node, 'commutative', context);
+  }
+  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 merged;
+  }
+
+  /**
+   * Flatten all associative operators in an expression tree.
+   * Assumes parentheses have already been removed.
+   */
+  function flatten(node, context) {
+    if (!node.args || node.args.length === 0) {
+      return node;
+    }
+    node.args = allChildren(node, context);
+    for (var i = 0; i < node.args.length; i++) {
+      flatten(node.args[i], context);
+    }
+  }
+
+  /**
+   * Get the children of a node as if it has been flattened.
+   * TODO implement for FunctionNodes
+   */
+  function allChildren(node, context) {
+    var op;
+    var children = [];
+    var findChildren = function findChildren(node) {
+      for (var i = 0; i < node.args.length; i++) {
+        var child = node.args[i];
+        if (isOperatorNode(child) && op === child.op) {
+          findChildren(child);
+        } else {
+          children.push(child);
+        }
+      }
+    };
+    if (isAssociative(node, context)) {
+      op = node.op;
+      findChildren(node);
+      return children;
+    } else {
+      return node.args;
+    }
+  }
+
+  /**
+   *  Unflatten all flattened operators to a right-heavy binary tree.
+   */
+  function unflattenr(node, context) {
+    if (!node.args || node.args.length === 0) {
+      return;
+    }
+    var makeNode = createMakeNodeFunction(node);
+    var l = node.args.length;
+    for (var i = 0; i < l; i++) {
+      unflattenr(node.args[i], context);
+    }
+    if (l > 2 && isAssociative(node, context)) {
+      var curnode = node.args.pop();
+      while (node.args.length > 0) {
+        curnode = makeNode([node.args.pop(), curnode]);
+      }
+      node.args = curnode.args;
+    }
+  }
+
+  /**
+   *  Unflatten all flattened operators to a left-heavy binary tree.
+   */
+  function unflattenl(node, context) {
+    if (!node.args || node.args.length === 0) {
+      return;
+    }
+    var makeNode = createMakeNodeFunction(node);
+    var l = node.args.length;
+    for (var i = 0; i < l; i++) {
+      unflattenl(node.args[i], context);
+    }
+    if (l > 2 && isAssociative(node, context)) {
+      var curnode = node.args.shift();
+      while (node.args.length > 0) {
+        curnode = makeNode([curnode, node.args.shift()]);
+      }
+      node.args = curnode.args;
+    }
+  }
+  function createMakeNodeFunction(node) {
+    if (isOperatorNode(node)) {
+      return function (args) {
+        try {
+          return new OperatorNode(node.op, node.fn, args, node.implicit);
+        } catch (err) {
+          console.error(err);
+          return [];
+        }
+      };
+    } else {
+      return function (args) {
+        return new FunctionNode(new SymbolNode(node.name), args);
+      };
+    }
+  }
+  return {
+    createMakeNodeFunction,
+    hasProperty,
+    isCommutative,
+    isAssociative,
+    mergeContext,
+    flatten,
+    allChildren,
+    unflattenr,
+    unflattenl,
+    defaultContext,
+    realContext,
+    positiveContext
+  };
+});

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

@@ -0,0 +1,20 @@
+import { isConstantNode, isFunctionNode, isOperatorNode, isParenthesisNode } from '../../../utils/is.js';
+export { isConstantNode, isSymbolNode as isVariableNode } from '../../../utils/is.js';
+export function isNumericNode(x) {
+  return isConstantNode(x) || isOperatorNode(x) && x.isUnary() && isConstantNode(x.args[0]);
+}
+export function isConstantExpression(x) {
+  if (isConstantNode(x)) {
+    // Basic Constant types
+    return true;
+  }
+  if ((isFunctionNode(x) || isOperatorNode(x)) && x.args.every(isConstantExpression)) {
+    // Can be constant depending on arguments
+    return true;
+  }
+  if (isParenthesisNode(x) && isConstantExpression(x.content)) {
+    // Parenthesis are transparent
+    return true;
+  }
+  return false; // Probably missing some edge cases
+}