math-exercises 1.3.31 → 1.3.33

package/lib/tree/nodes/operators/operatorNode.js

@@ -1,35 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorNode = exports.OperatorIds = void 0;
-const coinFlip_1 = require("../../../utils/coinFlip");
-const node_1 = require("../node");
-var OperatorIds;
-(function (OperatorIds) {
-    OperatorIds[OperatorIds["add"] = 0] = "add";
-    OperatorIds[OperatorIds["substract"] = 1] = "substract";
-    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
-    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
-    OperatorIds[OperatorIds["divide"] = 4] = "divide";
-    OperatorIds[OperatorIds["power"] = 5] = "power";
-    OperatorIds[OperatorIds["equal"] = 6] = "equal";
-})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
-class OperatorNode {
-    constructor(id, leftChild, rightChild, isCommutative, tex) {
-        this.type = node_1.NodeType.operator;
-        this.id = id;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.isCommutative = isCommutative;
-        this.tex = tex;
-    }
-    /**shuffles in place */
-    shuffle() {
-        if (!this.isCommutative)
-            return;
-        if ((0, coinFlip_1.coinFlip)())
-            return;
-        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
-        return;
-    }
-}
-exports.OperatorNode = OperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorNode = exports.OperatorIds = void 0;
+const coinFlip_1 = require("../../../utils/coinFlip");
+const node_1 = require("../node");
+var OperatorIds;
+(function (OperatorIds) {
+    OperatorIds[OperatorIds["add"] = 0] = "add";
+    OperatorIds[OperatorIds["substract"] = 1] = "substract";
+    OperatorIds[OperatorIds["multiply"] = 2] = "multiply";
+    OperatorIds[OperatorIds["fraction"] = 3] = "fraction";
+    OperatorIds[OperatorIds["divide"] = 4] = "divide";
+    OperatorIds[OperatorIds["power"] = 5] = "power";
+    OperatorIds[OperatorIds["equal"] = 6] = "equal";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+class OperatorNode {
+    constructor(id, leftChild, rightChild, isCommutative, tex) {
+        this.type = node_1.NodeType.operator;
+        this.id = id;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.isCommutative = isCommutative;
+        this.tex = tex;
+    }
+    /**shuffles in place */
+    shuffle() {
+        if (!this.isCommutative)
+            return;
+        if ((0, coinFlip_1.coinFlip)())
+            return;
+        [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+        return;
+    }
+}
+exports.OperatorNode = OperatorNode;

package/lib/tree/nodes/operators/powerNode.d.ts

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class PowerNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class PowerNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=powerNode.d.ts.map

package/lib/tree/nodes/operators/powerNode.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerNode = void 0;
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class PowerNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        let needBrackets = leftTex[0] === '-';
-        if (this.leftChild.type === node_1.NodeType.operator) {
-            const childOperator = this.leftChild;
-            needBrackets || (needBrackets = [
-                operatorNode_1.OperatorIds.add,
-                operatorNode_1.OperatorIds.substract,
-                operatorNode_1.OperatorIds.multiply,
-                operatorNode_1.OperatorIds.divide,
-                operatorNode_1.OperatorIds.fraction,
-                operatorNode_1.OperatorIds.power,
-            ].includes(childOperator.id));
-        }
-        if (needBrackets)
-            leftTex = `(${leftTex})`;
-        return `${leftTex}^{${rightTex}}`;
-    }
-}
-exports.PowerNode = PowerNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PowerNode = void 0;
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class PowerNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        let needBrackets = leftTex[0] === '-';
+        if (this.leftChild.type === node_1.NodeType.operator) {
+            const childOperator = this.leftChild;
+            needBrackets || (needBrackets = [
+                operatorNode_1.OperatorIds.add,
+                operatorNode_1.OperatorIds.substract,
+                operatorNode_1.OperatorIds.multiply,
+                operatorNode_1.OperatorIds.divide,
+                operatorNode_1.OperatorIds.fraction,
+                operatorNode_1.OperatorIds.power,
+            ].includes(childOperator.id));
+        }
+        if (needBrackets)
+            leftTex = `(${leftTex})`;
+        return `${leftTex}^{${rightTex}}`;
+    }
+}
+exports.PowerNode = PowerNode;

package/lib/tree/nodes/operators/substractNode.d.ts

@@ -1,8 +1,8 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class SubstractNode extends OperatorNode implements Node {
-    constructor(leftChild: Node, rightChild: Node);
-    toMathString(): string;
-    toTex(): string;
-}
+import { Node } from '../node';
+import { OperatorNode } from './operatorNode';
+export declare class SubstractNode extends OperatorNode implements Node {
+    constructor(leftChild: Node, rightChild: Node);
+    toMathString(): string;
+    toTex(): string;
+}
 //# sourceMappingURL=substractNode.d.ts.map

package/lib/tree/nodes/operators/substractNode.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = void 0;
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class SubstractNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
-            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === '-';
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex} - ${rightTex}`;
-    }
-}
-exports.SubstractNode = SubstractNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = void 0;
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class SubstractNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
+            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
+            rightTex[0] === '-';
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex} - ${rightTex}`;
+    }
+}
+exports.SubstractNode = SubstractNode;

package/lib/tree/nodes/variables/variableNode.d.ts

@@ -1,9 +1,9 @@
-import { Node, NodeType } from '../node';
-export declare class VariableNode implements Node {
-    name: string;
-    type: NodeType;
-    constructor(name: string);
-    toTex(): string;
-    toMathString(): string;
-}
+import { Node, NodeType } from '../node';
+export declare class VariableNode implements Node {
+    name: string;
+    type: NodeType;
+    constructor(name: string);
+    toTex(): string;
+    toMathString(): string;
+}
 //# sourceMappingURL=variableNode.d.ts.map

package/lib/tree/nodes/variables/variableNode.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariableNode = void 0;
-const node_1 = require("../node");
-class VariableNode {
-    constructor(name) {
-        this.type = node_1.NodeType.variable;
-        if (name.length !== 1 || !name.match('[a-zA-Z]'))
-            throw Error('variable must be a letter');
-        this.name = name;
-    }
-    toTex() {
-        return `${this.name}`;
-    }
-    toMathString() {
-        return `${this.name}`;
-    }
-}
-exports.VariableNode = VariableNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableNode = void 0;
+const node_1 = require("../node");
+class VariableNode {
+    constructor(name) {
+        this.type = node_1.NodeType.variable;
+        if (name.length !== 1 || !name.match('[a-zA-Z]'))
+            throw Error('variable must be a letter');
+        this.name = name;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toMathString() {
+        return `${this.name}`;
+    }
+}
+exports.VariableNode = VariableNode;

package/lib/tree/parsers/derivateParser.js

@@ -1,62 +1,62 @@
-"use strict";
-// import { Node, NodeType } from "../nodes/node";
-// import { NumberNode } from "../nodes/numbers/numberNode";
-// import { PowerNode } from "../nodes/operators/powerNode";
-// import { AddNode } from "../nodes/operators/addNode";
-// import { FractionNode } from "../nodes/operators/fractionNode";
-// import { MultiplyNode } from "../nodes/operators/multiplyNode";
-// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
-// import { SubstractNode } from "../nodes/operators/substractNode";
-// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
-// import { SqrtNode } from "../nodes/functions/sqrtNode";
-// import { OppositeNode } from "../nodes/functions/oppositeNode";
-// export function derivateParser(node: Node): Node {
-//   if (!node) throw Error("encountered a null node ??");
-//   switch (node.type) {
-//     case NodeType.variable:
-//       return new NumberNode(1);
-//     case NodeType.number:
-//       return new NumberNode(0);
-//     case NodeType.operator:
-//       const operatorNode = node as OperatorNode;
-//       const u = operatorNode.leftChild;
-//       const v = operatorNode.rightChild;
-//       switch (operatorNode.id) {
-//         case OperatorIds.add:
-//           return new AddNode(derivateParser(u), derivateParser(v));
-//         case OperatorIds.substract: {
-//           return new SubstractNode(derivateParser(u), derivateParser(v));
-//         }
-//         case OperatorIds.multiply: {
-//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
-//         }
-//         case OperatorIds.divide:
-//         case OperatorIds.fraction:
-//           return new FractionNode(
-//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
-//             new PowerNode(v, new NumberNode(2))
-//           );
-//         case OperatorIds.power: {
-//           const operatorNode = node as OperatorNode;
-//           const n = operatorNode.rightChild as NumberNode;
-//           const u = operatorNode.leftChild;
-//           return new MultiplyNode(
-//             n,
-//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
-//           );
-//         }
-//       }
-//     case NodeType.function: {
-//       const functionNode = node as FunctionNode;
-//       const child = functionNode.child;
-//       switch (functionNode.id) {
-//         case FunctionsIds.sqrt: {
-//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
-//         }
-//         case FunctionsIds.opposite: {
-//           return new OppositeNode(derivateParser(child));
-//         }
-//       }
-//     }
-//   }
-// }
+"use strict";
+// import { Node, NodeType } from "../nodes/node";
+// import { NumberNode } from "../nodes/numbers/numberNode";
+// import { PowerNode } from "../nodes/operators/powerNode";
+// import { AddNode } from "../nodes/operators/addNode";
+// import { FractionNode } from "../nodes/operators/fractionNode";
+// import { MultiplyNode } from "../nodes/operators/multiplyNode";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// import { SubstractNode } from "../nodes/operators/substractNode";
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { SqrtNode } from "../nodes/functions/sqrtNode";
+// import { OppositeNode } from "../nodes/functions/oppositeNode";
+// export function derivateParser(node: Node): Node {
+//   if (!node) throw Error("encountered a null node ??");
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return new NumberNode(1);
+//     case NodeType.number:
+//       return new NumberNode(0);
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       const u = operatorNode.leftChild;
+//       const v = operatorNode.rightChild;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return new AddNode(derivateParser(u), derivateParser(v));
+//         case OperatorIds.substract: {
+//           return new SubstractNode(derivateParser(u), derivateParser(v));
+//         }
+//         case OperatorIds.multiply: {
+//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
+//         }
+//         case OperatorIds.divide:
+//         case OperatorIds.fraction:
+//           return new FractionNode(
+//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
+//             new PowerNode(v, new NumberNode(2))
+//           );
+//         case OperatorIds.power: {
+//           const operatorNode = node as OperatorNode;
+//           const n = operatorNode.rightChild as NumberNode;
+//           const u = operatorNode.leftChild;
+//           return new MultiplyNode(
+//             n,
+//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
+//           );
+//         }
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
+//         }
+//         case FunctionsIds.opposite: {
+//           return new OppositeNode(derivateParser(child));
+//         }
+//       }
+//     }
+//   }
+// }

package/lib/tree/parsers/latexParser.js

@@ -0,0 +1,110 @@
+"use strict";
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { Node, NodeType } from "../nodes/node";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// export function latexParser(node: Node): string {
+//   if (!node) {
+//     console.log("parsing a null node ???");
+//     return "";
+//   }
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return node.tex;
+//     case NodeType.number:
+//       return node.tex;
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       let rightTex = latexParser(operatorNode.rightChild);
+//       let leftTex = latexParser(operatorNode.leftChild);
+//       const { leftChild, rightChild } = operatorNode;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+//         case OperatorIds.substract: {
+//           const needBrackets =
+//             (rightChild.type === NodeType.operator &&
+//               [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
+//             rightTex[0] === "-";
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} - ${rightTex}`;
+//         }
+//         case OperatorIds.multiply: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           //  permet de gérer le cas 3*2^x
+//           let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+//           }
+//           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+//         }
+//         case OperatorIds.divide: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} \\div ${rightTex}`;
+//         }
+//         case OperatorIds.fraction: {
+//           return `\\frac{${leftTex}}{${rightTex}}`;
+//         }
+//         case OperatorIds.power: {
+//           let needBrackets = leftTex[0] === "-";
+//           if (leftChild.type === NodeType.operator) {
+//             const childOperator = leftChild as OperatorNode;
+//             needBrackets ||= [
+//               OperatorIds.add,
+//               OperatorIds.substract,
+//               OperatorIds.multiply,
+//               OperatorIds.divide,
+//               OperatorIds.fraction,
+//               OperatorIds.power,
+//             ].includes(childOperator.id);
+//           }
+//           if (needBrackets) leftTex = `(${leftTex})`;
+//           return `${leftTex}^{${rightTex}}`;
+//         }
+//         case OperatorIds.equal: {
+//           return `${leftTex} = ${rightTex}`;
+//         }
+//         default:
+//           return node.tex;
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       let childTex = latexParser(functionNode.child);
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return `\\sqrt{${childTex}}`;
+//         }
+//         case FunctionsIds.opposite: {
+//           let needBrackets = childTex[0] === "-";
+//           if (child.type === NodeType.operator) {
+//             const operatorChild = child as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
+//           }
+//           if (needBrackets) childTex = `(${childTex})`;
+//           return `-${childTex}`;
+//         }
+//       }
+//     }
+//     default:
+//       return "";
+//   }
+// }

package/lib/tree/parsers/simplify.d.ts

@@ -1,3 +1,3 @@
-import { Node } from '../nodes/node';
-export declare const simplifyNode: (node: Node) => Node;
+import { Node } from '../nodes/node';
+export declare const simplifyNode: (node: Node) => Node;
 //# sourceMappingURL=simplify.d.ts.map

package/lib/tree/parsers/simplify.js

@@ -1,52 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simplifyNode = void 0;
-const mathjs_1 = require("mathjs");
-const oppositeNode_1 = require("../nodes/functions/oppositeNode");
-const sqrtNode_1 = require("../nodes/functions/sqrtNode");
-const numberNode_1 = require("../nodes/numbers/numberNode");
-const piNode_1 = require("../nodes/numbers/piNode");
-const addNode_1 = require("../nodes/operators/addNode");
-const fractionNode_1 = require("../nodes/operators/fractionNode");
-const multiplyNode_1 = require("../nodes/operators/multiplyNode");
-const powerNode_1 = require("../nodes/operators/powerNode");
-const substractNode_1 = require("../nodes/operators/substractNode");
-const variableNode_1 = require("../nodes/variables/variableNode");
-const simplifyNode = (node) => {
-    return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
-};
-exports.simplifyNode = simplifyNode;
-const mathjsNodeToNode = (mathjsNode) => {
-    if (mathjsNode.isSymbolNode) {
-        if (mathjsNode.name === 'pi')
-            return piNode_1.PiNode;
-        return new variableNode_1.VariableNode(mathjsNode.name);
-    }
-    else if (mathjsNode.isConstantNode) {
-        return new numberNode_1.NumberNode(mathjsNode.value);
-    }
-    else if (mathjsNode.isOperatorNode) {
-        switch (mathjsNode.fn) {
-            case 'add':
-                return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'subtract':
-                return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'unaryMinus':
-                return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'divide':
-                return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'multiply':
-                return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'pow':
-                return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-        }
-    }
-    else if (mathjsNode.isFunctionNode) {
-        const fn = mathjsNode.fn;
-        switch (fn.name) {
-            case 'sqrt':
-                return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
-        }
-    }
-    throw Error('unrecognized mathjs node');
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyNode = void 0;
+const mathjs_1 = require("mathjs");
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const piNode_1 = require("../nodes/numbers/piNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+const simplifyNode = (node) => {
+    return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
+};
+exports.simplifyNode = simplifyNode;
+const mathjsNodeToNode = (mathjsNode) => {
+    if (mathjsNode.isSymbolNode) {
+        if (mathjsNode.name === 'pi')
+            return piNode_1.PiNode;
+        return new variableNode_1.VariableNode(mathjsNode.name);
+    }
+    else if (mathjsNode.isConstantNode) {
+        return new numberNode_1.NumberNode(mathjsNode.value);
+    }
+    else if (mathjsNode.isOperatorNode) {
+        switch (mathjsNode.fn) {
+            case 'add':
+                return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'subtract':
+                return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'unaryMinus':
+                return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'divide':
+                return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'multiply':
+                return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'pow':
+                return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+        }
+    }
+    else if (mathjsNode.isFunctionNode) {
+        const fn = mathjsNode.fn;
+        switch (fn.name) {
+            case 'sqrt':
+                return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
+        }
+    }
+    throw Error('unrecognized mathjs node');
+};

package/lib/utils/arrayEqual.d.ts

@@ -1,2 +1,2 @@
-export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
+export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
 //# sourceMappingURL=arrayEqual.d.ts.map