mathjs 10.1.1 → 10.2.0

package/lib/cjs/expression/node/FunctionNode.js

@@ -152,7 +152,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
               var values = evalArgs.map(function (evalArg) {
                 return evalArg(scope, args, context);
               });
-              return fn.apply(void 0, (0, _toConsumableArray2["default"])(values));
+              return fn.apply(void 0, (0, _toConsumableArray2.default)(values));
             };
         }
       }
@@ -270,7 +270,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     var customString;
     var name = this.fn.toString(options);
 
-    if (options && (0, _typeof2["default"])(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, name)) {
+    if (options && (0, _typeof2.default)(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, name)) {
       // callback is a map of callback functions
       customString = options.handler[name](this, options);
     }
@@ -376,7 +376,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
         if (match[2] === undefined) {
           // no square brackets
-          switch ((0, _typeof2["default"])(property)) {
+          switch ((0, _typeof2.default)(property)) {
             case 'string':
               latex += property;
               break;
@@ -436,7 +436,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
   FunctionNode.prototype.toTex = function (options) {
     var customTex;
 
-    if (options && (0, _typeof2["default"])(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, this.name)) {
+    if (options && (0, _typeof2.default)(options.handler) === 'object' && (0, _object.hasOwnProperty)(options.handler, this.name)) {
       // callback is a map of callback functions
       customTex = options.handler[this.name](this, options);
     }
@@ -467,14 +467,14 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     } // toTex property on the function itself
 
 
-    if (math[this.name] && (typeof math[this.name].toTex === 'function' || (0, _typeof2["default"])(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) {
+    if (math[this.name] && (typeof math[this.name].toTex === 'function' || (0, _typeof2.default)(math[this.name].toTex) === 'object' || typeof math[this.name].toTex === 'string')) {
       // .toTex is a callback function
       latexConverter = math[this.name].toTex;
     }
 
     var customToTex;
 
-    switch ((0, _typeof2["default"])(latexConverter)) {
+    switch ((0, _typeof2.default)(latexConverter)) {
       case 'function':
         // a callback function
         customToTex = latexConverter(this, options);
@@ -487,7 +487,7 @@ var createFunctionNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
       case 'object':
         // an object with different "converters" for different numbers of arguments
-        switch ((0, _typeof2["default"])(latexConverter[args.length])) {
+        switch ((0, _typeof2.default)(latexConverter[args.length])) {
           case 'function':
             customToTex = latexConverter[args.length](this, options);
             break;

package/lib/cjs/expression/node/IndexNode.js

@@ -143,7 +143,7 @@ var createIndexNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       var dimensions = (0, _array.map)(evalDimensions, function (evalDimension) {
         return evalDimension(scope, args, context);
       });
-      return index.apply(void 0, (0, _toConsumableArray2["default"])(dimensions));
+      return index.apply(void 0, (0, _toConsumableArray2.default)(dimensions));
     };
   };
   /**

package/lib/cjs/expression/node/Node.js

@@ -367,8 +367,8 @@ var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
 
   Node.prototype._getCustomString = function (options) {
-    if (options && (0, _typeof2["default"])(options) === 'object') {
-      switch ((0, _typeof2["default"])(options.handler)) {
+    if (options && (0, _typeof2.default)(options) === 'object') {
+      switch ((0, _typeof2.default)(options.handler)) {
         case 'object':
         case 'undefined':
           return;
@@ -407,7 +407,7 @@ var createNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
 
   function _validateScope(scope) {
-    for (var _i = 0, _arr = (0, _toConsumableArray2["default"])(_keywords.keywords); _i < _arr.length; _i++) {
+    for (var _i = 0, _arr = (0, _toConsumableArray2.default)(_keywords.keywords); _i < _arr.length; _i++) {
       var symbol = _arr[_i];
 
       if (scope.has(symbol)) {

package/lib/cjs/expression/node/ObjectNode.js

@@ -38,7 +38,7 @@ var createObjectNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     this.properties = properties || {}; // validate input
 
     if (properties) {
-      if (!((0, _typeof2["default"])(properties) === 'object') || !Object.keys(properties).every(function (key) {
+      if (!((0, _typeof2.default)(properties) === 'object') || !Object.keys(properties).every(function (key) {
         return (0, _is.isNode)(properties[key]);
       })) {
         throw new TypeError('Object containing Nodes expected');

package/lib/cjs/expression/node/utils/access.js

@@ -37,7 +37,7 @@ function accessFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move getStringSubset into a separate util file, use that
         return subset(object, index);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if ((0, _typeof2.default)(object) === 'object') {
         if (!index.isObjectProperty()) {
           throw new TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/node/utils/assign.js

@@ -42,7 +42,7 @@ function assignFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move setStringSubset into a separate util file, use that
         return subset(object, index, value);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if ((0, _typeof2.default)(object) === 'object') {
         if (!index.isObjectProperty()) {
           throw TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/parse.js

@@ -153,16 +153,16 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   var NAMED_DELIMITERS = {
     mod: true,
     to: true,
-    "in": true,
+    in: true,
     and: true,
     xor: true,
     or: true,
     not: true
   };
   var CONSTANTS = {
-    "true": true,
-    "false": false,
-    "null": null,
+    true: true,
+    false: false,
+    null: null,
     undefined: undefined
   };
   var NUMERIC_CONSTANTS = ['NaN', 'Infinity'];
@@ -584,7 +584,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
   function parseStart(expression, extraNodes) {
     var state = initialState();
-    (0, _extends2["default"])(state, {
+    (0, _extends2.default)(state, {
       expression: expression,
       extraNodes: extraNodes
     });
@@ -930,7 +930,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     node = parseRange(state);
     var operators = {
       to: 'to',
-      "in": 'to' // alias of 'to'
+      in: 'to' // alias of 'to'
 
     };
 
@@ -1112,30 +1112,30 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       // Match the "number /" part of the pattern "number / number symbol"
       if (state.token === '/' && (0, _is.isConstantNode)(last)) {
         // Look ahead to see if the next token is a number
-        tokenStates.push((0, _extends2["default"])({}, state));
+        tokenStates.push((0, _extends2.default)({}, state));
         getTokenSkipNewline(state); // Match the "number / number" part of the pattern
 
         if (state.tokenType === TOKENTYPE.NUMBER) {
           // Look ahead again
-          tokenStates.push((0, _extends2["default"])({}, state));
+          tokenStates.push((0, _extends2.default)({}, state));
           getTokenSkipNewline(state); // Match the "symbol" part of the pattern, or a left parenthesis
 
           if (state.tokenType === TOKENTYPE.SYMBOL || state.token === '(') {
             // We've matched the pattern "number / number symbol".
             // Rewind once and build the "number / number" node; the symbol will be consumed later
-            (0, _extends2["default"])(state, tokenStates.pop());
+            (0, _extends2.default)(state, tokenStates.pop());
             tokenStates.pop();
             last = parsePercentage(state);
             node = new OperatorNode('/', 'divide', [node, last]);
           } else {
             // Not a match, so rewind
             tokenStates.pop();
-            (0, _extends2["default"])(state, tokenStates.pop());
+            (0, _extends2.default)(state, tokenStates.pop());
             break;
           }
         } else {
           // Not a match, so rewind
-          (0, _extends2["default"])(state, tokenStates.pop());
+          (0, _extends2.default)(state, tokenStates.pop());
           break;
         }
       } else {
@@ -1783,7 +1783,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createSyntaxError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error["char"] = c;
+    error.char = c;
     return error;
   }
   /**
@@ -1798,7 +1798,7 @@ var createParse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
   function createError(state, message) {
     var c = col(state);
     var error = new SyntaxError(message + ' (char ' + c + ')');
-    error["char"] = c;
+    error.char = c;
     return error;
   }
 

package/lib/cjs/factoriesAny.js

@@ -987,6 +987,12 @@ Object.defineProperty(exports, "createLcm", {
     return _lcm.createLcm;
   }
 });
+Object.defineProperty(exports, "createLeafCount", {
+  enumerable: true,
+  get: function get() {
+    return _leafCount.createLeafCount;
+  }
+});
 Object.defineProperty(exports, "createLeftShift", {
   enumerable: true,
   get: function get() {
@@ -1509,6 +1515,12 @@ Object.defineProperty(exports, "createResize", {
     return _resize.createResize;
   }
 });
+Object.defineProperty(exports, "createResolve", {
+  enumerable: true,
+  get: function get() {
+    return _resolve.createResolve;
+  }
+});
 Object.defineProperty(exports, "createResultSet", {
   enumerable: true,
   get: function get() {
@@ -1677,6 +1689,12 @@ Object.defineProperty(exports, "createSimplify", {
     return _simplify.createSimplify;
   }
 });
+Object.defineProperty(exports, "createSimplifyCore", {
+  enumerable: true,
+  get: function get() {
+    return _simplifyCore.createSimplifyCore;
+  }
+});
 Object.defineProperty(exports, "createSin", {
   enumerable: true,
   get: function get() {
@@ -2494,8 +2512,14 @@ var _catalan = require("./function/combinatorics/catalan.js");
 
 var _composition = require("./function/combinatorics/composition.js");
 
+var _leafCount = require("./function/algebra/leafCount.js");
+
 var _simplify = require("./function/algebra/simplify.js");
 
+var _simplifyCore = require("./function/algebra/simplifyCore.js");
+
+var _resolve = require("./function/algebra/resolve.js");
+
 var _derivative = require("./function/algebra/derivative.js");
 
 var _rationalize = require("./function/algebra/rationalize.js");

package/lib/cjs/factoriesNumber.js

@@ -579,6 +579,12 @@ Object.defineProperty(exports, "createReplacer", {
     return _replacer.createReplacer;
   }
 });
+Object.defineProperty(exports, "createResolve", {
+  enumerable: true,
+  get: function get() {
+    return _resolve.createResolve;
+  }
+});
 Object.defineProperty(exports, "createResultSet", {
   enumerable: true,
   get: function get() {
@@ -617,6 +623,12 @@ Object.defineProperty(exports, "createSimplify", {
     return _simplify.createSimplify;
   }
 });
+Object.defineProperty(exports, "createSimplifyCore", {
+  enumerable: true,
+  get: function get() {
+    return _simplifyCore.createSimplifyCore;
+  }
+});
 exports.createSinh = exports.createSin = void 0;
 Object.defineProperty(exports, "createSize", {
   enumerable: true,
@@ -764,8 +776,12 @@ var _help = require("./expression/function/help.js");
 
 var _chain = require("./type/chain/function/chain.js");
 
+var _resolve = require("./function/algebra/resolve.js");
+
 var _simplify = require("./function/algebra/simplify.js");
 
+var _simplifyCore = require("./function/algebra/simplifyCore.js");
+
 var _derivative = require("./function/algebra/derivative.js");
 
 var _rationalize = require("./function/algebra/rationalize.js");

package/lib/cjs/function/algebra/decomposition/qr.js

@@ -73,7 +73,7 @@ var createQr = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function
    * @return {{Q: Array | Matrix, R: Array | Matrix}} Q: the orthogonal
    * matrix and R: the upper triangular matrix
    */
-  return (0, _extends2["default"])(typed(name, {
+  return (0, _extends2.default)(typed(name, {
     DenseMatrix: function DenseMatrix(m) {
       return _denseQR(m);
     },

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

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLeafCount = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'leafCount';
+var dependencies = ['parse', 'typed'];
+var createLeafCount = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      typed = _ref.typed;
+
+  // This does the real work, but we don't have to recurse through
+  // a typed call if we separate it out
+  function countLeaves(node) {
+    var count = 0;
+    node.forEach(function (n) {
+      count += countLeaves(n);
+    });
+    return count || 1;
+  }
+  /**
+   * Gives the number of "leaf nodes" in the parse tree of the given expression
+   * A leaf node is one that has no subexpressions, essentially either a
+   * symbol or a constant. Note that `5!` has just one leaf, the '5'; the
+   * unary factorial operator does not add a leaf. On the other hand,
+   * function symbols do add leaves, so `sin(x)/cos(x)` has four leaves.
+   *
+   * The `simplify()` function should generally not increase the `leafCount()`
+   * of an expression, although currently there is no guarantee that it never
+   * does so. In many cases, `simplify()` reduces the leaf count.
+   *
+   * Syntax:
+   *
+   *     leafCount(expr)
+   *
+   * Examples:
+   *
+   *     math.leafCount('x') // 1
+   *     math.leafCount(math.parse('a*d-b*c')) // 4
+   *     math.leafCount('[a,b;c,d][0,1]') // 6
+   *
+   * See also:
+   *
+   *     simplify
+   *
+   * @param {Node|string} expr    The expression to count the leaves of
+   *
+   * @return {number}  The number of leaves of `expr`
+   *
+   */
+
+
+  return typed(name, {
+    string: function string(expr) {
+      return this(parse(expr));
+    },
+    Node: function Node(expr) {
+      return countLeaves(expr);
+    }
+  });
+});
+exports.createLeafCount = createLeafCount;

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

@@ -11,10 +11,8 @@ var _factory = require("../../utils/factory.js");
 
 var _simplifyConstant = require("./simplify/simplifyConstant.js");
 
-var _simplifyCore = require("./simplify/simplifyCore.js");
-
 var name = 'rationalize';
-var dependencies = ['config', 'typed', 'equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'parse', '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', '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,
@@ -26,6 +24,7 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       divide = _ref.divide,
       pow = _ref.pow,
       parse = _ref.parse,
+      simplifyCore = _ref.simplifyCore,
       simplify = _ref.simplify,
       fraction = _ref.fraction,
       bignumber = _ref.bignumber,
@@ -56,23 +55,6 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     OperatorNode: OperatorNode,
     SymbolNode: SymbolNode
   });
-  var simplifyCore = (0, _simplifyCore.createSimplifyCore)({
-    equal: equal,
-    isZero: isZero,
-    add: add,
-    subtract: subtract,
-    multiply: multiply,
-    divide: divide,
-    pow: pow,
-    AccessorNode: AccessorNode,
-    ArrayNode: ArrayNode,
-    ConstantNode: ConstantNode,
-    FunctionNode: FunctionNode,
-    IndexNode: IndexNode,
-    ObjectNode: ObjectNode,
-    OperatorNode: OperatorNode,
-    ParenthesisNode: ParenthesisNode
-  });
   /**
    * Transform a rationalizable expression in a rational fraction.
    * If rational fraction is one variable polynomial then converts
@@ -116,13 +98,13 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @param  {Object|boolean}      optional scope of expression or true for already evaluated rational expression at input
    * @param  {Boolean}  detailed   optional True if return an object, false if return expression node (default)
    *
-   * @return {Object | Node}    The rational polynomial of `expr` or na object
-   *            {Object}
-   *              {Expression Node} expression: node simplified expression
-   *              {Expression Node} numerator: simplified numerator of expression
-   *              {Expression Node | boolean} denominator: simplified denominator or false (if there is no denominator)
-   *              {Array}           variables:  variable names
-   *              {Array}           coefficients: coefficients of numerator sorted by increased exponent
+   * @return {Object | Node}    The rational polynomial of `expr` or an object
+   *            `{expression, numerator, denominator, variables, coefficients}`, where
+   *              `expression` is a `Node` with the node simplified expression,
+   *              `numerator` is a `Node` with the simplified numerator of expression,
+   *              `denominator` is a `Node` or `boolean` with the simplified denominator or `false` (if there is no denominator),
+   *              `variables` is an array with variable names,
+   *              and `coefficients` is an array with coefficients of numerator sorted by increased exponent
    *           {Expression Node}  node simplified expression
    *
    */
@@ -155,6 +137,12 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       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) {
@@ -165,18 +153,16 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 
         var rules;
         var eDistrDiv = true;
-        var redoInic = false;
-        expr = simplify(expr, setRules.firstRules, {}, {
-          exactFractions: false
-        }); // Apply the initial rules, including succ div rules
+        var redoInic = false; // Apply the initial rules, including succ div rules:
 
+        expr = simplify(expr, setRules.firstRules, {}, noExactFractions);
         var s;
 
         while (true) {
-          // Apply alternately  successive division rules and distr.div.rules
+          // 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); // until no more changes
-
+          expr = simplify(expr, rules, {}, withExactFractions);
           eDistrDiv = !eDistrDiv; // Swap between Distr.Div and Succ. Div. Rules
 
           s = expr.toString();
@@ -191,14 +177,11 @@ var createRationalize = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 
         if (redoInic) {
           // Apply first rules again without succ div rules (if there are changes)
-          expr = simplify(expr, setRules.firstRulesAgain, {}, {
-            exactFractions: false
-          });
-        }
+          expr = simplify(expr, setRules.firstRulesAgain, {}, noExactFractions);
+        } // Apply final rules:
+
 
-        expr = simplify(expr, setRules.finalRules, {}, {
-          exactFractions: false
-        }); // Apply final rules
+        expr = simplify(expr, setRules.finalRules, {}, noExactFractions);
       } // NVars >= 1
 
 

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

@@ -0,0 +1,106 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createResolve = void 0;
+
+var _map = require("../../utils/map.js");
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'resolve';
+var dependencies = ['parse', 'ConstantNode', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
+var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      ConstantNode = _ref.ConstantNode,
+      FunctionNode = _ref.FunctionNode,
+      OperatorNode = _ref.OperatorNode,
+      ParenthesisNode = _ref.ParenthesisNode;
+
+  /**
+   * 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 (!(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(', ');
+        throw new ReferenceError("recursive loop of variable definitions among {".concat(variables, "}"));
+      }
+
+      var value = scope.get(node.name);
+
+      if ((0, _is.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 ((0, _is.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 ((0, _is.isParenthesisNode)(node)) {
+      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 new FunctionNode(node.name, _args);
+    } // Otherwise just recursively resolve any children (might also work
+    // for some of the above special cases)
+
+
+    return node.map(function (child) {
+      return resolve(child, scope, within);
+    });
+  }
+
+  return resolve;
+});
+exports.createResolve = createResolve;

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

@@ -17,7 +17,7 @@ var _util = require("./util.js");
 
 var _noop = require("../../../utils/noop.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -348,7 +348,7 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
         return node;
 
       case 'ConstantNode':
-        switch ((0, _typeof2["default"])(node.value)) {
+        switch ((0, _typeof2.default)(node.value)) {
           case 'number':
             return _toNumber(node.value, options);
 
@@ -419,13 +419,13 @@ var createSimplifyConstant = /* #__PURE__ */(0, _factory.factory)(name, dependen
             } 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(function (arg) {
               return foldFraction(arg, options);
             });
 
-            if (isCommutative(fn)) {
+            if (isCommutative(fn, options.context)) {
               // commutative binary operator
               var consts = [];
               var vars = [];