Merge remote-tracking branch 'socraticorg/mathsteps/master' into 'nitin42/mathsteps/build-configuration' (PR: google#175)

Author: jcward

.eslintrc.js

@@ -66,6 +66,20 @@ module.exports = {
         ],
         "strict": [
             "error"
+        ],
+        "eol-last": [
+            "error",
+            "always"
+        ],
+        "no-multiple-empty-lines": [
+            "error", 
+            {
+                "max": 2,
+                "maxEOF": 1
+            }
+        ],
+        "no-trailing-spaces": [
+            "error"
         ]
     }
 };

CONTRIBUTING.md

@@ -93,7 +93,7 @@ We're excited to see your [pull request](https://help.github.com/articles/about-
   before you get started, so others are aware that you're working on it. If
   there's no existing issue for the change you'd like to make, you can
   [create a new issue](https://github.com/socraticorg/mathsteps/issues/new).
-  
+
 - The best issues to work on are [these issues that are not assigned or long term goals](https://github.com/socraticorg/mathsteps/issues?utf8=%E2%9C%93&q=is%3Aissue%20is%3Aopen%20-label%3Aassigned%20%20-label%3Aquestion%20%20-label%3A%22longer%20term%20goals%22%20%20-label%3A%22needs%20further%20discussion%22%20)
 
 - Make sure all the unit tests pass (with `npm test`) before creating the pull
@@ -110,7 +110,7 @@ We're excited to see your [pull request](https://help.github.com/articles/about-
   which makes sure tests are passing and the code is eslint-compliant.
 - If you want to see what the expression tree looks like at any point in the
   code (for debugging), you can log a `node` as an expression string (e.g.
-  '2x + 5') with `console.log(print(node))`, and you can log the full tree
+  '2x + 5') with `console.log(print.ascii(node))`, and you can log the full tree
   structure with `console.log(JSON.stringify(node, null, 2))`
 
 

HISTORY.md

@@ -1,5 +1,36 @@
 # History
 
+
+## 2017-10-26, version 0.1.7
+
+There's been a lot of great changes since the last release, here are the main updates
+
+Functionality and Teaching Enhancements:
+
+- new pedagogy for multiply powers integers #153
+- exposing the factoring module and adding more coverage #148
+- simplify roots of any degree #183
+- more cases for cancelling terms #182
+- greatest common denominator substep #188
+- multiply nthRoots #189
+- multiply fractions with parenthesis #185
+- remove unnecessary parens before solving equations #205
+- multiply denominators with terms #88
+- Better sum-product factoring steps #210
+
+
+Bug Fixes
+
+- fix the check for perfect roots of a constant when there's roundoff error #224
+- large negtive number rounding #216
+
+Other:
+
+- (code structure) generalizing polynomial terms #190
+- latex printing for equations
+- added linting rules #222
+
+
 ## 2017-04-03, version 0.1.6
 
 updated mathjs to incorporate vulnerability patch #149

README.md

@@ -33,13 +33,15 @@ To solve an equation:
 const steps = mathsteps.solveEquation('2x + 3x = 35');
 
 steps.forEach(step => {
-    console.log("before change: " + step.oldEquation.print());  // e.g. before change: 2x + 3x = 35
+    console.log("before change: " + step.oldEquation.ascii());  // e.g. before change: 2x + 3x = 35
     console.log("change: " + step.changeType);                  // e.g. change: SIMPLIFY_LEFT_SIDE
-    console.log("after change: " + step.newEquation.print());   // e.g. after change: 5x = 35
+    console.log("after change: " + step.newEquation.ascii());   // e.g. after change: 5x = 35
     console.log("# of substeps: " + step.substeps.length);      // e.g. # of substeps: 2
 });
 ```
 
+(if you're using mathsteps v0.1.6 or lower, use `.print()` instead of `.ascii()`)
+
 To see all the change types:
 ```js
 const changes = mathsteps.ChangeTypes;

lib/ChangeTypes.js

@@ -35,7 +35,7 @@ module.exports = {
   // e.g. 2 - - 3 -> 2 + 3
   RESOLVE_DOUBLE_MINUS: 'RESOLVE_DOUBLE_MINUS',
 
-  // COLLECT AND COMBINE
+  // COLLECT AND COMBINE AND BREAK UP
 
   // e.g. 2 + x + 3 + x -> 5 + 2x
   COLLECT_AND_COMBINE_LIKE_TERMS: 'COLLECT_AND_COMBINE_LIKE_TERMS',
@@ -80,6 +80,14 @@ module.exports = {
   SIMPLIFY_FRACTION: 'SIMPLIFY_FRACTION',
   // e.g. 2/-3 -> -2/3
   SIMPLIFY_SIGNS: 'SIMPLIFY_SIGNS',
+  // e.g. 15/6 -> (5*3)/(2*3)
+  FIND_GCD: 'FIND_GCD',
+  // e.g. (5*3)/(2*3) -> 5/2
+  CANCEL_GCD: 'CANCEL_GCD',
+  // e.g. 1 2/3 -> 5/3
+  CONVERT_MIXED_NUMBER_TO_IMPROPER_FRACTION: 'CONVERT_MIXED_NUMBER_TO_IMPROPER_FRACTION',
+  // e.g. 1 2/3 -> ((1 * 3) + 2) / 3
+  IMPROPER_FRACTION_NUMERATOR: 'IMPROPER_FRACTION_NUMERATOR',
 
   // ADDING FRACTIONS
 
@@ -120,6 +128,9 @@ module.exports = {
   DISTRIBUTE_NEGATIVE_ONE: 'DISTRIBUTE_NEGATIVE_ONE',
   // e.g. 2 * 4x + 2*5 --> 8x + 10 (as part of distribution)
   SIMPLIFY_TERMS: 'SIMPLIFY_TERMS',
+  // e.g. (nthRoot(x, 2))^2 -> nthRoot(x, 2) * nthRoot(x, 2)
+  // e.g. (2x + 3)^2 -> (2x + 3) (2x + 3)
+  EXPAND_EXPONENT: 'EXPAND_EXPONENT',
 
   // ABSOLUTE
   // e.g. |-3| -> 3
@@ -146,6 +157,10 @@ module.exports = {
   GROUP_TERMS_BY_ROOT: 'GROUP_TERMS_BY_ROOT',
   // e.g. nthRoot(4) -> 2
   NTH_ROOT_VALUE: 'NTH_ROOT_VALUE',
+  // e.g. nthRoot(4) + nthRoot(4) = 2*nthRoot(4)
+  ADD_NTH_ROOTS: 'ADD_NTH_ROOTS',
+  // e.g. nthRoot(x, 2) * nthRoot(x, 2) -> nthRoot(x^2, 2)
+  MULTIPLY_NTH_ROOTS: 'MULTIPLY_NTH_ROOTS',
 
   // SOLVING FOR A VARIABLE
 
@@ -167,6 +182,8 @@ module.exports = {
   SUBTRACT_FROM_BOTH_SIDES: 'SUBTRACT_FROM_BOTH_SIDES',
   // e.g. 2 = x -> x = 2
   SWAP_SIDES: 'SWAP_SIDES',
+  // e.g. (x - 2) (x + 2) = 0 => x = [-2, 2]
+  FIND_ROOTS: 'FIND_ROOTS',
 
   // CONSTANT EQUATION
 
@@ -185,4 +202,6 @@ module.exports = {
   FACTOR_PERFECT_SQUARE: 'FACTOR_PERFECT_SQUARE',
   // e.g. x^2 + 3x + 2 -> (x + 1)(x + 2)
   FACTOR_SUM_PRODUCT_RULE: 'FACTOR_SUM_PRODUCT_RULE',
+  // e.g. 2x^2 + 4x + 2 -> 2x^2 + 2x + 2x + 2
+  BREAK_UP_TERM: 'BREAK_UP_TERM',
 };

lib/Negative.js

@@ -1,26 +1,28 @@
-const Node = require('./node');
+const NodeCreator = require('./node/Creator');
+const NodeType = require('./node/Type');
+const PolynomialTerm = require('./node/PolynomialTerm');
 
 const Negative = {};
 
 // Returns if the given node is negative. Treats a unary minus as a negative,
 // as well as a negative constant value or a constant fraction that would
 // evaluate to a negative number
 Negative.isNegative = function(node) {
-  if (Node.Type.isUnaryMinus(node)) {
+  if (NodeType.isUnaryMinus(node)) {
     return !Negative.isNegative(node.args[0]);
   }
-  else if (Node.Type.isConstant(node)) {
+  else if (NodeType.isConstant(node)) {
     return parseFloat(node.value) < 0;
   }
-  else if (Node.Type.isConstantFraction(node)) {
+  else if (NodeType.isConstantFraction(node)) {
     const numeratorValue = parseFloat(node.args[0].value);
     const denominatorValue = parseFloat(node.args[1].value);
     if (numeratorValue < 0 || denominatorValue < 0) {
       return !(numeratorValue < 0 && denominatorValue < 0);
     }
   }
-  else if (Node.PolynomialTerm.isPolynomialTerm(node)) {
-    const polyNode = new Node.PolynomialTerm(node);
+  else if (PolynomialTerm.isPolynomialTerm(node)) {
+    const polyNode = new PolynomialTerm(node);
     return Negative.isNegative(polyNode.getCoeffNode(true));
   }
 
@@ -34,22 +36,22 @@ Negative.isNegative = function(node) {
 //    not naive: -3 -> 3, x -> -x
 //    naive: -3 -> --3, x -> -x
 Negative.negate = function(node, naive=false) {
-  if (Node.Type.isConstantFraction(node)) {
+  if (NodeType.isConstantFraction(node)) {
     node.args[0] = Negative.negate(node.args[0], naive);
     return node;
   }
-  else if (Node.PolynomialTerm.isPolynomialTerm(node)) {
+  else if (PolynomialTerm.isPolynomialTerm(node)) {
     return Negative.negatePolynomialTerm(node, naive);
   }
   else if (!naive) {
-    if (Node.Type.isUnaryMinus(node)) {
+    if (NodeType.isUnaryMinus(node)) {
       return node.args[0];
     }
-    else if (Node.Type.isConstant(node)) {
-      return Node.Creator.constant(0 - parseFloat(node.value));
+    else if (NodeType.isConstant(node)) {
+      return NodeCreator.constant(0 - parseFloat(node.value));
     }
   }
-  return Node.Creator.unaryMinus(node);
+  return NodeCreator.unaryMinus(node);
 };
 
 // Multiplies a polynomial term by -1 and returns the new node
@@ -59,14 +61,14 @@ Negative.negate = function(node, naive=false) {
 //    not naive: -3x -> 3x, x -> -x
 //    naive: -3x -> --3x, x -> -x
 Negative.negatePolynomialTerm = function(node, naive=false) {
-  if (!Node.PolynomialTerm.isPolynomialTerm(node)) {
+  if (!PolynomialTerm.isPolynomialTerm(node)) {
     throw Error('node is not a polynomial term');
   }
-  const polyNode = new Node.PolynomialTerm(node);
+  const polyNode = new PolynomialTerm(node);
 
   let newCoeff;
   if (!polyNode.hasCoeff()) {
-    newCoeff = Node.Creator.constant(-1);
+    newCoeff = NodeCreator.constant(-1);
   }
   else {
     const oldCoeff = polyNode.getCoeffNode();
@@ -78,7 +80,7 @@ Negative.negatePolynomialTerm = function(node, naive=false) {
       numerator = Negative.negate(numerator, naive);
 
       const denominator = oldCoeff.args[1];
-      newCoeff = Node.Creator.operator('/', [numerator, denominator]);
+      newCoeff = NodeCreator.operator('/', [numerator, denominator]);
     }
     else {
       newCoeff = Negative.negate(oldCoeff, naive);
@@ -87,7 +89,7 @@ Negative.negatePolynomialTerm = function(node, naive=false) {
       }
     }
   }
-  return Node.Creator.polynomialTerm(
+  return NodeCreator.polynomialTerm(
     polyNode.getSymbolNode(), polyNode.getExponentNode(), newCoeff);
 };
 

lib/Symbols.js

@@ -18,20 +18,23 @@ Symbols.getSymbolsInExpression = function(expression) {
   return symbolSet;
 };
 
-// Iterates through a node and returns the polynomial term with the symbol name
+// Iterates through a node and returns the last term with the symbol name
 // Returns null if no terms with the symbol name are in the node.
 // e.g. 4x^2 + 2x + y + 2 with `symbolName=x` would return 2x
 Symbols.getLastSymbolTerm = function(node, symbolName) {
   // First check if the node itself is a polyomial term with symbolName
   if (isSymbolTerm(node, symbolName)) {
     return node;
   }
-  // Otherwise, it's a sum of terms. Look through the operands for a term
+  // If it's a sum of terms, look through the operands for a term
   // with `symbolName`
   else if (Node.Type.isOperator(node, '+')) {
     for (let i = node.args.length - 1; i >= 0 ; i--) {
       const child = node.args[i];
-      if (isSymbolTerm(child, symbolName)) {
+      if (Node.Type.isOperator(child, '+')) {
+        return Symbols.getLastSymbolTerm(child, symbolName);
+      }
+      else if (isSymbolTerm(child, symbolName)) {
         return child;
       }
     }
@@ -46,13 +49,19 @@ Symbols.getLastSymbolTerm = function(node, symbolName) {
 // e.g. 4x^2 + 2x + 2/4 with `symbolName=x` would return 2/4
 // e.g. 4x^2 + 2x + y with `symbolName=x` would return y
 Symbols.getLastNonSymbolTerm = function(node, symbolName) {
-  if (isSymbolTerm(node, symbolName)) {
+  if (isPolynomialTermWithSymbol(node, symbolName)) {
     return new Node.PolynomialTerm(node).getCoeffNode();
   }
+  else if (hasDenominatorSymbol(node, symbolName)) {
+    return null;
+  }
   else if (Node.Type.isOperator(node)) {
     for (let i = node.args.length - 1; i >= 0 ; i--) {
       const child = node.args[i];
-      if (!isSymbolTerm(child, symbolName)) {
+      if (Node.Type.isOperator(child, '+')) {
+        return Symbols.getLastNonSymbolTerm(child, symbolName);
+      }
+      else if (!isSymbolTerm(child, symbolName)) {
         return child;
       }
     }
@@ -61,14 +70,59 @@ Symbols.getLastNonSymbolTerm = function(node, symbolName) {
   return null;
 };
 
-// Returns if `node` is a polynomial term with symbol `symbolName`
+// Iterates through a node and returns the denominator if it has a
+// symbolName in its denominator
+// e.g. 1/(2x) with `symbolName=x` would return 2x
+// e.g. 1/(x+2) with `symbolName=x` would return x+2
+// e.g. 1/(x+2) + (x+1)/(2x+3) with `symbolName=x` would return (2x+3)
+Symbols.getLastDenominatorWithSymbolTerm = function(node, symbolName) {
+  // First check if the node itself has a symbol in the denominator
+  if (hasDenominatorSymbol(node, symbolName)) {
+    return node.args[1];
+  }
+  // Otherwise, it's a sum of terms. e.g. 1/x + 1(2+x)
+  // Look through the operands for a
+  // denominator term with `symbolName`
+  else if (Node.Type.isOperator(node, '+')) {
+    for (let i = node.args.length - 1; i >= 0 ; i--) {
+      const child = node.args[i];
+      if (Node.Type.isOperator(child, '+')) {
+        return Symbols.getLastDenominatorWithSymbolTerm(child, symbolName);
+      }
+      else if (hasDenominatorSymbol(child, symbolName)) {
+        return child.args[1];
+      }
+    }
+  }
+  return null;
+};
+
+// Returns if `node` is a term with symbol `symbolName`
 function isSymbolTerm(node, symbolName) {
+  return isPolynomialTermWithSymbol(node, symbolName) ||
+    hasDenominatorSymbol(node, symbolName);
+}
+
+function isPolynomialTermWithSymbol(node, symbolName) {
   if (Node.PolynomialTerm.isPolynomialTerm(node)) {
     const polyTerm = new Node.PolynomialTerm(node);
     if (polyTerm.getSymbolName() === symbolName) {
       return true;
     }
   }
+
+  return false;
+}
+
+// Return if `node` has a symbol in its denominator
+// e.g. true for 1/(2x)
+// e.g. false for 5x
+function hasDenominatorSymbol(node, symbolName) {
+  if (Node.Type.isOperator(node) && node.op === '/') {
+    const allSymbols = Symbols.getSymbolsInExpression(node.args[1]);
+    return allSymbols.has(symbolName);
+  }
+
   return false;
 }
 

lib/TreeSearch.js

@@ -66,5 +66,4 @@ function search(simplificationFunction, node, preOrder) {
 }
 
 
-
 module.exports = TreeSearch;