trying to update to 9, but there are a lot of complications

README.md

@@ -126,6 +126,7 @@ npm test
 ## TODOs
 - Fix usage of factoring for simplification
 - Throw error instead of returning empty array?
+- update to latest mathjs
 
 ### Done (compared to https://github.com/google/mathsteps)
 - Port to TypeScript!

example-consumer/index.ts

@@ -1,3 +1,10 @@
 import {solveEquation} from '@taskbase/mathsteps';
+import {simplifyExpression} from '@taskbase/mathsteps';
+
 const solved = solveEquation('2x + 2x = 2');
+console.log('solved:');
 console.log(solved);
+
+const simplified = simplifyExpression('2x + 2x');
+console.log('simplided:');
+console.log(simplified);

lib/package.json

@@ -27,6 +27,6 @@
   },
   "homepage": "https://github.com/taskbase/mathsteps#readme",
   "dependencies": {
-    "mathjs": "3.11.2"
+    "mathjs": "^9.2.0"
   }
 }

lib/src/equation/Equation.ts

@@ -14,8 +14,14 @@ export class Equation {
 
   // Prints an Equation properly using the print module
   ascii(showPlusMinus = false) {
+    console.log(`============`);
+    console.log(JSON.stringify(this.leftNode));
+    console.log(JSON.stringify(this.rightNode));
+    console.log(`============`);
+
     const leftSide = printAscii(this.leftNode, showPlusMinus);
     const rightSide = printAscii(this.rightNode, showPlusMinus);
+
     const comparator = this.comparator;
 
     return `${leftSide} ${comparator} ${rightSide}`;
@@ -45,6 +51,7 @@ export class Equation {
         "Expected two sides of an equation using comparator: " + comparator
       );
     }
+
     const leftNode = math.parse(sides[0]);
     const rightNode = math.parse(sides[1]);
 

lib/src/node/Creator.ts

@@ -11,28 +11,15 @@ class NodeCreatorClass {
   operator(op, args, implicit = false) {
     switch (op) {
       case "+":
-        return new (math.expression as any).node.OperatorNode("+", "add", args);
+        return new (math as any).OperatorNode("+", "add", args);
       case "-":
-        return new (math.expression as any).node.OperatorNode(
-          "-",
-          "subtract",
-          args
-        );
+        return new (math as any).OperatorNode("-", "subtract", args);
       case "/":
-        return new (math.expression as any).node.OperatorNode(
-          "/",
-          "divide",
-          args
-        );
+        return new (math as any).OperatorNode("/", "divide", args);
       case "*":
-        return new (math.expression as any).node.OperatorNode(
-          "*",
-          "multiply",
-          args,
-          implicit
-        );
+        return new (math as any).OperatorNode("*", "multiply", args, implicit);
       case "^":
-        return new (math.expression as any).node.OperatorNode("^", "pow", args);
+        return new (math as any).OperatorNode("^", "pow", args);
       default:
         throw Error("Unsupported operation: " + op);
     }
@@ -41,25 +28,23 @@ class NodeCreatorClass {
   // In almost all cases, use Negative.negate (with naive = true) to add a
   // unary minus to your node, rather than calling this constructor directly
   unaryMinus(content) {
-    return new (math.expression as any).node.OperatorNode("-", "unaryMinus", [
-      content,
-    ]);
+    return new (math as any).OperatorNode("-", "unaryMinus", [content]);
   }
 
   constant(val) {
-    return new (math.expression as any).node.ConstantNode(val);
+    return new (math as any).ConstantNode(val);
   }
 
   symbol(name) {
-    return new (math.expression as any).node.SymbolNode(name);
+    return new (math as any).SymbolNode(name);
   }
 
   parenthesis(content) {
-    return new (math.expression as any).node.ParenthesisNode(content);
+    return new (math as any).ParenthesisNode(content);
   }
 
   list(content) {
-    return new (math.expression as any).node.ArrayNode(content);
+    return new (math as any).ArrayNode(content);
   }
 
   // exponent might be null, which means there's no exponent node.
@@ -92,10 +77,7 @@ class NodeCreatorClass {
   // Given a root value and a radicand (what is under the radical)
   nthRoot(radicandNode, rootNode) {
     const symbol = NodeCreator.symbol("nthRoot");
-    return new (math.expression as any).node.FunctionNode(symbol, [
-      radicandNode,
-      rootNode,
-    ]);
+    return new (math as any).FunctionNode(symbol, [radicandNode, rootNode]);
   }
 }
 

lib/src/util/evaluate.ts

@@ -5,5 +5,5 @@
  * */
 export function evaluate(node) {
   // TODO: once we swap in math-parser, call its evaluate function instead
-  return node.eval();
+  return node.evaluate();
 }

lib/src/util/print.ts

@@ -46,6 +46,10 @@ export function printTreeTraversal(node, parentNode = undefined) {
   }
 
   if (NodeType.isOperator(node)) {
+    if (node.op === "*" && node.args[0].value === 0) {
+      return `0`;
+    }
+
     if (node.op === "/" && NodeType.isOperator(node.args[1])) {
       return `${printTreeTraversal(node.args[0])} / (${printTreeTraversal(
         node.args[1]

lib/tsconfig.json

@@ -3,7 +3,8 @@
     "module": "commonjs",
     "target": "es2015",
     "declaration": true,
-    "outDir": "../dist"
+    "outDir": "../dist",
+    "sourceMap": true
   },
   "include": [
     "./**/*.ts"