math-exercises 2.0.7 → 2.0.9

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

@@ -7,6 +7,9 @@ const operatorNode_1 = require("./operatorNode");
 const numberNode_1 = require("../numbers/numberNode");
 const round_1 = require("../../../math/utils/round");
 const oppositeNode_1 = require("../functions/oppositeNode");
+const multiplyNode_1 = require("./multiplyNode");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
 function isFractionNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
 }
@@ -18,6 +21,7 @@ class FractionNode {
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
         this.opts = opts;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
@@ -66,5 +70,87 @@ class FractionNode {
     evaluate(vars) {
         return this.leftChild.evaluate(vars) / this.rightChild.evaluate(vars);
     }
+    // toMathjs() {
+    //   return fraction(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() {
+        const simplifiedNum = this.leftChild.simplify();
+        const simplifiedDenum = this.rightChild.simplify();
+        const copy = new FractionNode(simplifiedNum, simplifiedDenum, this.opts);
+        const externalsNums = [];
+        const externalsDenums = [];
+        const recursiveNums = (node) => {
+            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+                recursiveNums(node.leftChild);
+                recursiveNums(node.rightChild);
+            }
+            else {
+                externalsNums.push(node);
+            }
+        };
+        const recursiveDenums = (node) => {
+            if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+                recursiveDenums(node.leftChild);
+                recursiveDenums(node.rightChild);
+            }
+            else {
+                externalsDenums.push(node);
+            }
+        };
+        recursiveNums(copy.leftChild);
+        recursiveDenums(copy.rightChild);
+        const simplifyExternalNodes = (num, denum) => {
+            if ((0, numberNode_1.isNumberNode)(num) && (0, numberNode_1.isNumberNode)(denum)) {
+                const frac = new rational_1.Rational(num.value, denum.value);
+                console.log(frac.isIrreductible());
+                if (frac.isIrreductible())
+                    return null;
+                return frac.simplify().toTree();
+            }
+            //!ya mieux à faire pour gérer tous les cas d'un coup
+            //! s'insiprer de multiply
+            if (num.equals(denum))
+                return new numberNode_1.NumberNode(1);
+            return null;
+        };
+        console.log(externalsNums, externalsDenums);
+        const simplifyIteration = () => {
+            for (let i = 0; i < externalsNums.length; i++) {
+                const num = externalsNums[i];
+                for (let j = 0; j < externalsDenums.length; j++) {
+                    const denum = externalsDenums[j];
+                    const simplified = simplifyExternalNodes(num, denum);
+                    if (simplified) {
+                        if (isFractionNode(simplified)) {
+                            externalsNums[i] = simplified.leftChild;
+                            externalsDenums[j] = simplified.rightChild;
+                        }
+                        else {
+                            externalsNums[i] = simplified;
+                            externalsDenums.splice(j, 1);
+                        }
+                        simplifyIteration();
+                        return;
+                    }
+                }
+            }
+        };
+        simplifyIteration();
+        const nums = externalsNums.length === 1
+            ? externalsNums[0]
+            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsNums).simplify();
+        if (externalsDenums.length === 0) {
+            return nums;
+        }
+        const denums = externalsDenums.length === 1
+            ? externalsDenums[0]
+            : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, externalsDenums);
+        return new FractionNode(nums, denums);
+    }
+    equals(node) {
+        return (isFractionNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
 }
 exports.FractionNode = FractionNode;

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

@@ -2,12 +2,14 @@ import { Node, NodeOptions, NodeType } from "../node";
 import { CommutativeOperatorNode, OperatorIds } from "./operatorNode";
 import { AlgebraicNode } from "../algebraicNode";
 export declare function isMultiplyNode(a: Node): a is MultiplyNode;
+export declare const sortMultiplyNodes: (arr: AlgebraicNode[]) => void;
 export declare class MultiplyNode implements CommutativeOperatorNode {
     opts?: NodeOptions;
     id: OperatorIds;
     leftChild: AlgebraicNode;
     rightChild: AlgebraicNode;
     type: NodeType;
+    isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     shuffle: () => void;
     toMathString(): string;
@@ -16,5 +18,8 @@ export declare class MultiplyNode implements CommutativeOperatorNode {
     toEquivalentNodes(opts?: NodeOptions): MultiplyNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
+    copy(): MultiplyNode;
+    simplify(): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=multiplyNode.d.ts.map

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;gBAEb,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAkBpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAkDf,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGtC"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,IAAI,MAAM;IAkDf,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAwFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAIrC,IAAI;IAGJ,QAAQ,IAAI,aAAa;IAqGzB,MAAM,CAAC,IAAI,EAAE,aAAa;CAU3B"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = exports.isMultiplyNode = void 0;
+exports.MultiplyNode = exports.sortMultiplyNodes = exports.isMultiplyNode = void 0;
 // import { multiply } from "mathjs";
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
@@ -12,30 +12,37 @@ const powerNode_1 = require("./powerNode");
 const numberNode_1 = require("../numbers/numberNode");
 const isInt_1 = require("../../../utils/isInt");
 const variableNode_1 = require("../variables/variableNode");
+const sqrtNode_1 = require("../functions/sqrtNode");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const fractionNode_1 = require("./fractionNode");
+const functionNode_1 = require("../functions/functionNode");
 function isMultiplyNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
 }
 exports.isMultiplyNode = isMultiplyNode;
+const sortMultiplyNodes = (arr) => {
+    arr.sort((a, b) => {
+        return (Number(b.isNumeric) - Number(a.isNumeric) ||
+            Number((0, numberNode_1.isNumberNode)(b) && b.value === -1) -
+                Number((0, numberNode_1.isNumberNode)(a) && a.value === -1) ||
+            Number((0, numberNode_1.isNumberNode)(b)) - Number((0, numberNode_1.isNumberNode)(a)) ||
+            Number((0, functionNode_1.isFunctionNode)(b)) - Number((0, functionNode_1.isFunctionNode)(a)) ||
+            Number((0, operatorNode_1.isOperatorNode)(b)) - Number((0, operatorNode_1.isOperatorNode)(a)));
+    });
+};
+exports.sortMultiplyNodes = sortMultiplyNodes;
 class MultiplyNode {
     constructor(leftChild, rightChild, opts) {
         this.shuffle = () => {
             if ((0, coinFlip_1.coinFlip)())
                 [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
         };
-        // let [left, right] = [leftChild, rightChild];
-        // const shouldSwitch =
-        //   (rightChild.type === NodeType.function &&
-        //     (rightChild as FunctionNode).id === FunctionsIds.opposite) ||
-        //   (leftChild.type === NodeType.constant &&
-        //     rightChild.type === NodeType.number);
-        // if (shouldSwitch) {
-        //   [left, right] = [rightChild, leftChild];
-        // }
         this.id = operatorNode_1.OperatorIds.multiply;
         this.leftChild = leftChild;
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
         this.opts = opts;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
@@ -191,5 +198,115 @@ class MultiplyNode {
     evaluate(vars) {
         return this.leftChild.evaluate(vars) * this.rightChild.evaluate(vars);
     }
+    copy() {
+        return new MultiplyNode(this.leftChild, this.rightChild, this.opts);
+    }
+    simplify() {
+        const leftSimplified = this.leftChild.simplify();
+        const rightSimplified = this.rightChild.simplify();
+        const copy = new MultiplyNode(leftSimplified, rightSimplified, this.opts);
+        /**get externals nodes
+         * les opposites sont supprimés et on ajoute *-1 à la fin si leur nb est impair
+         */
+        let externals = [];
+        let oppositesCount = 0;
+        //TODO Fractions
+        const recursive = (node) => {
+            if (isMultiplyNode(node)) {
+                recursive(node.leftChild);
+                recursive(node.rightChild);
+            }
+            else if ((0, oppositeNode_1.isOppositeNode)(node)) {
+                oppositesCount++;
+                recursive(node.child);
+            }
+            else {
+                externals.push(node);
+            }
+        };
+        recursive(copy);
+        //si 0 on s'arrete
+        if (externals.some((node) => (0, numberNode_1.isNumberNode)(node) && node.value === 0)) {
+            return new numberNode_1.NumberNode(0);
+        }
+        if (oppositesCount % 2 === 1) {
+            externals.unshift(new numberNode_1.NumberNode(-1));
+        }
+        //suppression des 1
+        externals = externals.filter((node) => !(0, numberNode_1.isNumberNode)(node) || node.value !== 1);
+        if (!externals.length)
+            return new numberNode_1.NumberNode(1);
+        if (externals.length === 1)
+            return externals[0];
+        //s'il y a une fraction on transforme en fracNode
+        if (externals.some((node) => (0, fractionNode_1.isFractionNode)(node))) {
+            const nums = [];
+            const denums = [];
+            externals.forEach((node) => {
+                if ((0, fractionNode_1.isFractionNode)(node)) {
+                    nums.push(node.leftChild);
+                    denums.push(node.rightChild);
+                }
+                else
+                    nums.push(node);
+            });
+            if (nums.some((node) => (0, numberNode_1.isNumberNode)(node) && node.value === 0)) {
+                return new numberNode_1.NumberNode(0);
+            }
+            (0, exports.sortMultiplyNodes)(nums);
+            (0, exports.sortMultiplyNodes)(denums);
+            const numNode = (0, operatorComposition_1.operatorComposition)(MultiplyNode, nums);
+            const denumNode = denums.length === 1
+                ? denums[0]
+                : (0, operatorComposition_1.operatorComposition)(MultiplyNode, denums);
+            return new fractionNode_1.FractionNode(numNode, denumNode).simplify();
+        }
+        (0, exports.sortMultiplyNodes)(externals);
+        console.log(externals.map((n) => n.toTex()));
+        const simplifyExternalNodes = (a, b) => {
+            if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
+                return new numberNode_1.NumberNode(a.value * b.value);
+            }
+            if ((0, sqrtNode_1.isSqrtNode)(a) && (0, sqrtNode_1.isSqrtNode)(b)) {
+                return new sqrtNode_1.SqrtNode(new MultiplyNode(a.child, b.child)).simplify();
+            }
+            //TODo continue
+            return null;
+        };
+        //pour chaque paire on essaye de simplifier,
+        //chaque simplification déclenche le reboot du process
+        const simplifyIteration = () => {
+            for (let i = 0; i < externals.length - 1; i++) {
+                const left = externals[i];
+                for (let j = i + 1; j < externals.length; j++) {
+                    const right = externals[j];
+                    const simplified = simplifyExternalNodes(left, right);
+                    if (simplified) {
+                        externals[i] = simplified;
+                        externals.splice(j, 1);
+                        if ((0, numberNode_1.isNumberNode)(simplified) && simplified.value === 1) {
+                            externals.splice(i, 1);
+                        }
+                        simplifyIteration();
+                        return;
+                    }
+                }
+            }
+        };
+        simplifyIteration();
+        if (!externals.length)
+            return new numberNode_1.NumberNode(1);
+        if (externals.length === 1)
+            return externals[0];
+        return (0, operatorComposition_1.operatorComposition)(MultiplyNode, externals);
+    }
+    equals(node) {
+        //!incorrect, il faut plutot vérifier qu'ils ont les meme externals
+        return (isMultiplyNode(node) &&
+            ((node.leftChild.equals(this.leftChild) &&
+                node.rightChild.equals(this.rightChild)) ||
+                (node.leftChild.equals(this.rightChild) &&
+                    node.rightChild.equals(this.leftChild))));
+    }
 }
 exports.MultiplyNode = MultiplyNode;

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

@@ -8,12 +8,15 @@ export declare class PowerNode implements OperatorNode {
     leftChild: AlgebraicNode;
     rightChild: AlgebraicNode;
     type: NodeType;
+    isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 export declare class SquareNode extends PowerNode {
     constructor(child: AlgebraicNode, opts?: NodeOptions);

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

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;gBAEb,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CA4CtC;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IA6CrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAO3B;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAGrD"}

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

@@ -17,6 +17,7 @@ class PowerNode {
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
         this.opts = opts;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `(${this.leftChild.toMathString()})^(${this.rightChild.toMathString()})`;
@@ -73,6 +74,51 @@ class PowerNode {
     evaluate(vars) {
         return Math.pow(this.leftChild.evaluate(vars), this.rightChild.evaluate(vars));
     }
+    // simplify(): AlgebraicNode {
+    //   const leftSimplified = this.leftChild.simplify();
+    //   const rightSimplified = this.rightChild.simplify();
+    //   if (isNumberNode(rightSimplified)) {
+    //     const value = rightSimplified.value;
+    //     if (value === 0) return new NumberNode(1);
+    //     if (value === 1) return leftSimplified;
+    //   }
+    //   if (isNumberNode(leftSimplified)) {
+    //     const value = leftSimplified.value;
+    //     if (value === 0) return leftSimplified;
+    //     if (value === 1) return leftSimplified;
+    //   }
+    //   if (isNumberNode(rightSimplified) && isNumberNode(leftSimplified)) {
+    //     const value = this.evaluate({});
+    //     // à partir de ^21 et de ^-7, javascript returns des écritures scientifiques
+    //     if (
+    //       Math.abs(value) < Math.pow(10, 21) ||
+    //       Math.abs(value) < Math.pow(10, -7)
+    //     ) {
+    //       return new NumberNode(value);
+    //     } else return this;
+    //   }
+    //   if (isExpNode(leftSimplified) && isLogNode(rightSimplified)) {
+    //     return rightSimplified.child;
+    //   }
+    //   if (isPowerNode(leftSimplified)) {
+    //     return new PowerNode(
+    //       leftSimplified.leftChild,
+    //       new MultiplyNode(leftSimplified.rightChild, rightSimplified),
+    //     ).simplify();
+    //   }
+    //   if (isSqrtNode(leftSimplified) && isNumberNode(rightSimplified)) {
+    //   }
+    //   //! simplifications possibles :
+    //   // puissances négatives ?
+    // }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return (isPowerNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
 }
 exports.PowerNode = PowerNode;
 class SquareNode extends PowerNode {

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

@@ -7,11 +7,14 @@ export declare class SubstractNode implements OperatorNode {
     leftChild: AlgebraicNode;
     rightChild: AlgebraicNode;
     type: NodeType;
+    isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode);
     toMathString(): string;
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
     toTex(): string;
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=substractNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAO/D,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAef,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAMtC"}
+{"version":3,"file":"substractNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/substractNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBACP,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,aAAa,EAAE;IAapC,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAef,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAO3B"}

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

@@ -16,6 +16,7 @@ class SubstractNode {
         this.leftChild = leftChild;
         this.rightChild = rightChild;
         this.type = node_1.NodeType.operator;
+        this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
     toMathString() {
         return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
@@ -48,5 +49,16 @@ class SubstractNode {
     evaluate(vars) {
         return this.leftChild.evaluate(vars) - this.rightChild.evaluate(vars);
     }
+    // toMathjs() {
+    //   return subtract(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return (isSubstractNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
 }
 exports.SubstractNode = SubstractNode;

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

@@ -4,6 +4,7 @@ export declare function isVariableNode(a: Node): a is VariableNode;
 export declare class VariableNode implements AlgebraicNode {
     name: string;
     type: NodeType;
+    isNumeric: boolean;
     constructor(name: string);
     toTex(): string;
     toMathString(): string;
@@ -11,5 +12,7 @@ export declare class VariableNode implements AlgebraicNode {
     toAllValidTexs(): string[];
     toEquivalentNodes(): this[];
     evaluate(vars: Record<string, number>): number;
+    simplify(): this;
+    equals(node: AlgebraicNode): boolean;
 }
 //# sourceMappingURL=variableNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;gBAEb,IAAI,EAAE,MAAM;IAIxB,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAStC"}
+{"version":3,"file":"variableNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/variables/variableNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AACD,qBAAa,YAAa,YAAW,aAAa;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,WAAqB;IACzB,SAAS,EAAE,OAAO,CAAC;gBACP,IAAI,EAAE,MAAM;IAKxB,KAAK,IAAI,MAAM;IAGf,YAAY,IAAI,MAAM;IAGtB,QAAQ;IAGR,cAAc;IAGd,iBAAiB;IAIjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IASrC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;CAG3B"}

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

@@ -10,6 +10,7 @@ class VariableNode {
     constructor(name) {
         this.type = node_1.NodeType.variable;
         this.name = name;
+        this.isNumeric = false;
     }
     toTex() {
         return `${this.name}`;
@@ -32,5 +33,14 @@ class VariableNode {
             throw Error(`Can't evaluate variable ${this.name}`);
         return value;
     }
+    // simplify(): Node {
+    //   return this;
+    // }
+    simplify() {
+        return this;
+    }
+    equals(node) {
+        return isVariableNode(node) && node.name === this.name;
+    }
 }
 exports.VariableNode = VariableNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [