WIP: Substitute symbols for expressions from optional scope

.gitignore

@@ -2,4 +2,4 @@
 node_modules
 *.log
 .DS_Store
-.idea
+.idea

lib/TreeSearch.js

@@ -5,25 +5,25 @@ const TreeSearch = {};
 // Returns a function that performs a preorder search on the tree for the given
 // simplification function
 TreeSearch.preOrder = function(simplificationFunction) {
-  return function (node, scope={}) {
-    return search(simplificationFunction, node, true, scope);
+  return function (node, options={}) {
+    return search(simplificationFunction, node, true, options);
   };
 };
 
 // Returns a function that performs a postorder search on the tree for the given
 // simplification function
 TreeSearch.postOrder = function(simplificationFunction) {
-  return function (node, scope={}) {
-    return search(simplificationFunction, node, false, scope);
+  return function (node, options={}) {
+    return search(simplificationFunction, node, false, options);
   };
 };
 
 // A helper function for performing a tree search with a function
-function search(simplificationFunction, node, preOrder, scope={}) {
+function search(simplificationFunction, node, preOrder, options={}) {
   let status;
 
   if (preOrder) {
-    status = simplificationFunction(node, scope);
+    status = simplificationFunction(node, options);
     if (status.hasChanged()) {
       return status;
     }
@@ -32,28 +32,30 @@ function search(simplificationFunction, node, preOrder, scope={}) {
   if (Node.Type.isConstant(node)) {
     return Node.Status.noChange(node);
   }
-  // Moved isUnaryMinus check above Symbol check to address symbol nested inside unaryminus
+  // Check isUnaryMinus before Symbol because symbols nested inside unaryMinus
+  // (e.g., 2x - symbol) need to be subtracted from the expression. Checking
+  // symbol first causes the symbol to be added.
   else if (Node.Type.isUnaryMinus(node)) {
-    status = search(simplificationFunction, node.args[0], preOrder, scope);
+    status = search(simplificationFunction, node.args[0], preOrder, options);
     if (status.hasChanged()) {
       return Node.Status.childChanged(node, status);
     }
   }
-  // Break out isSymbol test and add a changeType for SUBSTITUTE_SYMBOL?
+  // symbols can be simplified through variable substitution
   else if (Node.Type.isSymbol(node)) {
-    return simplificationFunction(node, scope);
+    return simplificationFunction(node, options);
   }
   else if (Node.Type.isOperator(node) || Node.Type.isFunction(node)) {
     for (let i = 0; i < node.args.length; i++) {
       const child = node.args[i];
-      const childNodeStatus = search(simplificationFunction, child, preOrder, scope);
+      const childNodeStatus = search(simplificationFunction, child, preOrder, options);
       if (childNodeStatus.hasChanged()) {
         return  Node.Status.childChanged(node, childNodeStatus, i);
       }
     }
   }
   else if (Node.Type.isParenthesis(node)) {
-    status = search(simplificationFunction, node.content, preOrder, scope);
+    status = search(simplificationFunction, node.content, preOrder, options);
     if (status.hasChanged()) {
       return Node.Status.childChanged(node, status);
     }
@@ -63,7 +65,7 @@ function search(simplificationFunction, node, preOrder, scope={}) {
   }
 
   if (!preOrder) {
-    return simplificationFunction(node, scope);
+    return simplificationFunction(node, options);
   }
   else {
     return Node.Status.noChange(node);

lib/simplifyExpression/index.js

@@ -1,9 +1,12 @@
 const math = require('mathjs');
 const stepThrough = require('./stepThrough');
-const Substitute = require('../Substitute');
+const Substitute = require('../substituteScope');
+
+function simplifyExpressionString(expressionString, options={}, debug=false) {
+  const newOptions = Object.assign({}, options);
+  const newScope = Substitute(options.scope);
+  newOptions.scope = newScope;
 
-function simplifyExpressionString(expressionString, debug=false, scope={}) {
-  const newScope = Substitute(scope);
   let exprNode;
   try {
     exprNode = math.parse(expressionString);
@@ -12,7 +15,7 @@ function simplifyExpressionString(expressionString, debug=false, scope={}) {
     return [];
   }
   if (exprNode) {
-    return stepThrough(exprNode, debug, newScope);
+    return stepThrough(exprNode, newOptions, debug);
   }
   return [];
 }

lib/simplifyExpression/stepThrough.js

@@ -20,7 +20,7 @@ const removeUnnecessaryParens = require('../util/removeUnnecessaryParens');
 
 // Given a mathjs expression node, steps through simplifying the expression.
 // Returns a list of details about each step.
-function stepThrough(node, debug=false, scope={}) {
+function stepThrough(node, options={}, debug=false) {
   if (debug) {
     // eslint-disable-next-line
     console.log('\n\nSimplifying: ' + print.ascii(node, false, true));
@@ -38,15 +38,15 @@ function stepThrough(node, debug=false, scope={}) {
   let iters = 0;
 
   // Now, step through the math expression until nothing changes
-  nodeStatus = step(node, scope);
+  nodeStatus = step(node, options);
   while (nodeStatus.hasChanged()) {
     if (debug) {
       logSteps(nodeStatus);
     }
     steps.push(removeUnnecessaryParensInStep(nodeStatus));
 
     node = Status.resetChangeGroups(nodeStatus.newNode);
-    nodeStatus = step(node, scope);
+    nodeStatus = step(node, options);
 
     if (iters++ === MAX_STEP_COUNT) {
       // eslint-disable-next-line
@@ -61,7 +61,7 @@ function stepThrough(node, debug=false, scope={}) {
 
 // Given a mathjs expression node, performs a single step to simplify the
 // expression. Returns a Node.Status object.
-function step(node, scope={}) {
+function step(node, options={}) {
   let nodeStatus;
 
   node = flattenOperands(node);
@@ -72,6 +72,7 @@ function step(node, scope={}) {
     basicsSearch,
     // Substitute symbols present in the optional scope object with
     // their respective expressions.
+    // e.g., given options: { scope: { x: 10, y: 20 } }, x + y => 10 + 20
     substituteScopeSearch,
     // Simplify any division chains so there's at most one division operation.
     // e.g. 2/x/6 -> 2/(x*6)        e.g. 2/(x/6) => 2 * 6/x
@@ -95,7 +96,7 @@ function step(node, scope={}) {
   ];
 
   for (let i = 0; i < simplificationTreeSearches.length; i++) {
-    nodeStatus = simplificationTreeSearches[i](node, scope);
+    nodeStatus = simplificationTreeSearches[i](node, options);
     // Always update node, since there might be changes that didn't count as
     // a step. Remove unnecessary parens, in case one a step results in more
     // parens than needed.

lib/simplifyExpression/substituteScopeSearch/index.js

@@ -7,9 +7,9 @@ const TreeSearch = require('../../TreeSearch');
 // Returns a Node.Status object.
 const search = TreeSearch.postOrder(scopeSubstitution);
 
-function scopeSubstitution(node, scope) {
+function scopeSubstitution(node, options={}) {
   if (Node.Type.isSymbol(node)) {
-    return substituteAndSimplifySymbols(node, scope);
+    return substituteAndSimplifySymbols(node, options);
   }
   else {
     return Node.Status.noChange(node);
@@ -18,7 +18,11 @@ function scopeSubstitution(node, scope) {
 
 // SUBSTITUTES
 // Returns a Node.Status object with substeps
-function substituteAndSimplifySymbols(node, scope) {
+function substituteAndSimplifySymbols(node, options={}) {
+  if (!options.hasOwnProperty('scope')) {
+    return Node.Status.noChange(node);
+  }
+
   if (!Node.Type.isSymbol(node)) {
     return Node.Status.noChange(node);
   }
@@ -31,8 +35,10 @@ function substituteAndSimplifySymbols(node, scope) {
     symbolName = node.args[0].name;
   }
 
+  const scope = options.scope;
   if (scope.hasOwnProperty(symbolName)) {
-    // when declared at top, kept getting TypeError: ___ is not a function
+    // when declared at top, kept getting
+    // TypeError: <nameIGaveToFunction> is not a function
     const simplifyExpression = require('../../simplifyExpression');
     const substeps = simplifyExpression(scope[symbolName]);
     if (substeps.length === 0) {
@@ -51,4 +57,4 @@ function substituteAndSimplifySymbols(node, scope) {
   }
 }
 
-module.exports = search;
+module.exports = search;

lib/solveEquation/index.js

@@ -1,9 +1,12 @@
 const math = require('mathjs');
 const stepThrough = require('./stepThrough');
-const Substitute = require('../Substitute');
+const Substitute = require('../substituteScope');
+
+function solveEquationString(equationString, options={}, debug=false) {
+  const newOptions = Object.assign({}, options);
+  const newScope = Substitute(options.scope);
+  newOptions.scope = newScope;
 
-function solveEquationString(equationString, debug=false, scope={}) {
-  const newScope = Substitute(scope);
   const comparators = ['<=', '>=', '=', '<', '>'];
 
   for (let i = 0; i < comparators.length; i++) {
@@ -28,7 +31,8 @@ function solveEquationString(equationString, debug=false, scope={}) {
       return [];
     }
     if (leftNode && rightNode) {
-      return stepThrough(leftNode, rightNode, comparator, debug, newScope);
+      return stepThrough(leftNode, rightNode,
+        comparator, newOptions, debug);
     }
   }
 

lib/solveEquation/stepThrough.js

@@ -23,8 +23,8 @@ const COMPARATOR_TO_FUNCTION = {
 // the solution. Possible solutions include:
 // - solving for a variable (e.g. 'x=3' for '3x=4+5')
 // - the result of comparing values (e.g. 'true' for 3 = 3, 'false' for 3 < 2)
-function stepThrough(leftNode, rightNode, comparator, debug=false, scope={}) {
-  let equation = new Equation(leftNode, rightNode, comparator, scope);
+function stepThrough(leftNode, rightNode, comparator, options={}, debug=false) {
+  let equation = new Equation(leftNode, rightNode, comparator);
 
   if (debug) {
     // eslint-disable-next-line
@@ -40,7 +40,7 @@ function stepThrough(leftNode, rightNode, comparator, debug=false, scope={}) {
   const symbolSet = Symbols.getSymbolsInEquation(equation);
 
   if (symbolSet.size === 0) {
-    return solveConstantEquation(equation, debug, [], scope);
+    return solveConstantEquation(equation, debug, [], options);
   }
   const symbolName = symbolSet.values().next().value;
 
@@ -68,7 +68,7 @@ function stepThrough(leftNode, rightNode, comparator, debug=false, scope={}) {
 
   // Step through the math equation until nothing changes
   do {
-    steps = addSimplificationSteps(steps, equation, debug, scope);
+    steps = addSimplificationSteps(steps, equation, options, debug);
 
     if (steps.length > 0) {
       const lastStep = steps[steps.length - 1];
@@ -81,7 +81,7 @@ function stepThrough(leftNode, rightNode, comparator, debug=false, scope={}) {
 
     // at this point, the symbols might have cancelled out.
     if (Symbols.getSymbolsInEquation(equation).size === 0) {
-      return solveConstantEquation(equation, debug, steps, scope);
+      return solveConstantEquation(equation, debug, steps, options);
     }
 
     // The left side of the equation is either factored or simplified.
@@ -237,14 +237,14 @@ function getSolutionsAndSymbol (equation) {
 
 // Given an equation of constants, will simplify both sides, returning
 // the steps and the result of the equation e.g. 'True' or 'False'
-function solveConstantEquation(equation, debug, steps=[], scope={}) {
+function solveConstantEquation(equation, debug, steps=[], options={}) {
   const compareFunction = COMPARATOR_TO_FUNCTION[equation.comparator];
 
   if (!compareFunction) {
     throw Error('Unexpected comparator');
   }
 
-  steps = addSimplificationSteps(steps, equation, debug, scope);
+  steps = addSimplificationSteps(steps, equation, options, debug);
   if (steps.length > 0) {
     const lastStep = steps[steps.length - 1];
     equation = Equation.createEquationFromString(
@@ -307,7 +307,7 @@ function step(equation, symbolName) {
 }
 
 // Simplifies the equation and returns the simplification steps
-function addSimplificationSteps(steps, equation, debug=false, scope={}) {
+function addSimplificationSteps(steps, equation, options={}, debug=false) {
   let oldEquation = equation.clone();
 
   /*
@@ -321,7 +321,7 @@ function addSimplificationSteps(steps, equation, debug=false, scope={}) {
     e.g. x + 4 + 2 = 0 <- simplify the left side
     e.g. 0 = x^2 + 3x + 2 -> x^2 + 3x + 2 = 0 <- swap to the left side
   */
-  const leftSimplifySteps = simplifyExpressionNode(equation.leftNode, false, scope);
+  const leftSimplifySteps = simplifyExpressionNode(equation.leftNode, options, false);
   const simplifiedLeftNode = leftSimplifySteps.length !== 0
         ? leftSimplifySteps.slice(-1)[0].newNode
         : equation.leftNode;
@@ -369,7 +369,7 @@ function addSimplificationSteps(steps, equation, debug=false, scope={}) {
   // (ie the "before" of the before and after) for simplifying the right side.
   oldEquation = equation.clone();
 
-  const rightSteps = simplifyExpressionNode(equation.rightNode, false, scope);
+  const rightSteps = simplifyExpressionNode(equation.rightNode, options, false);
   const rightSubSteps = [];
 
   for (let i = 0; i < rightSteps.length; i++) {

lib/substituteScope.js

@@ -0,0 +1,24 @@
+function substituteScope(scope) {
+  // create a copy of the provided scope
+  const newScope = Object.assign({}, scope);
+
+  // iterate over symbols
+  for (var symbol in newScope) {
+    // store the symbol's current value in a variable
+    const targetVal = newScope[symbol].toString();
+    // iterate through scope (again)
+    for (var sym in newScope) {
+      // extract the value of a symbol as a string
+      const valStr = newScope[sym].toString();
+      // within the stored value, replace symbol (from the outer loop)
+      // with its respective value
+      const replaced = valStr.replace(symbol, targetVal);
+      // store the substituted value in the new scope under the same symbol
+      newScope[sym] = replaced;
+    }
+  }
+
+  return newScope;
+}
+
+module.exports = substituteScope;