math-exercises 2.0.12 → 2.0.13

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

@@ -1,22 +1,22 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node } from "../node";
-export declare enum OperatorIds {
-    add = 0,
-    substract = 1,
-    multiply = 2,
-    fraction = 3,
-    divide = 4,
-    power = 5,
-    limit = 6
-}
-export interface OperatorNode extends AlgebraicNode {
-    id: OperatorIds;
-    leftChild: AlgebraicNode;
-    rightChild: AlgebraicNode;
-}
-export declare function isOperatorNode(a: Node): a is OperatorNode;
-export interface CommutativeOperatorNode extends OperatorNode {
-    shuffle: () => void;
-    toAllTexs: () => string[];
-}
+import { AlgebraicNode } from "../algebraicNode";
+import { Node } from "../node";
+export declare enum OperatorIds {
+    add = 0,
+    substract = 1,
+    multiply = 2,
+    fraction = 3,
+    divide = 4,
+    power = 5,
+    limit = 6
+}
+export interface OperatorNode extends AlgebraicNode {
+    id: OperatorIds;
+    leftChild: AlgebraicNode;
+    rightChild: AlgebraicNode;
+}
+export declare function isOperatorNode(a: Node): a is OperatorNode;
+export interface CommutativeOperatorNode extends OperatorNode {
+    shuffle: () => void;
+    toAllTexs: () => string[];
+}
 //# sourceMappingURL=operatorNode.d.ts.map

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

@@ -1,18 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOperatorNode = exports.OperatorIds = void 0;
-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["limit"] = 6] = "limit";
-})(OperatorIds || (exports.OperatorIds = OperatorIds = {}));
-function isOperatorNode(a) {
-    return a.type === node_1.NodeType.operator;
-}
-exports.isOperatorNode = isOperatorNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOperatorNode = exports.OperatorIds = void 0;
+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["limit"] = 6] = "limit";
+})(OperatorIds = exports.OperatorIds || (exports.OperatorIds = {}));
+function isOperatorNode(a) {
+    return a.type === node_1.NodeType.operator;
+}
+exports.isOperatorNode = isOperatorNode;

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

@@ -1,24 +1,24 @@
-import { Node, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
-export declare function isPowerNode(a: Node): a is PowerNode;
-export declare class PowerNode implements OperatorNode {
-    opts?: NodeOptions;
-    id: OperatorIds;
-    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(opts?: SimplifyOptions): AlgebraicNode;
-    equals(node: AlgebraicNode): boolean;
-}
-export declare class SquareNode extends PowerNode {
-    constructor(child: AlgebraicNode, opts?: NodeOptions);
-}
+import { Node, NodeOptions, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+export declare function isPowerNode(a: Node): a is PowerNode;
+export declare class PowerNode implements OperatorNode {
+    opts?: NodeOptions;
+    id: OperatorIds;
+    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(opts?: SimplifyOptions): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
+}
+export declare class SquareNode extends PowerNode {
+    constructor(child: AlgebraicNode, opts?: NodeOptions);
+}
 //# sourceMappingURL=powerNode.d.ts.map

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

@@ -1,178 +1,178 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SquareNode = exports.PowerNode = exports.isPowerNode = void 0;
-// import { pow } from "mathjs";
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const numberNode_1 = require("../numbers/numberNode");
-const multiplyNode_1 = require("./multiplyNode");
-function isPowerNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.power;
-}
-exports.isPowerNode = isPowerNode;
-class PowerNode {
-    constructor(leftChild, rightChild, opts) {
-        this.id = operatorNode_1.OperatorIds.power;
-        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()})`;
-    }
-    toEquivalentNodes() {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new PowerNode(leftNode, rightNode));
-                if (!this.opts?.forbidPowerToProduct && (0, numberNode_1.isNumberNode)(this.rightChild)) {
-                    const power = this.rightChild.value;
-                    if (Math.floor(power) !== power || power < 2)
-                        return;
-                    let tree = new multiplyNode_1.MultiplyNode(leftNode, leftNode);
-                    for (let i = 2; i < power; i++) {
-                        tree = new multiplyNode_1.MultiplyNode(tree, leftNode);
-                    }
-                    res.push(tree);
-                }
-            });
-        });
-        return res;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        let needBrackets = leftTex[0] === "-";
-        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
-            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(this.leftChild.id);
-        }
-        if (needBrackets)
-            leftTex = `\\left(${leftTex}\\right)`;
-        const needBrace = rightTex.length > 1;
-        if (needBrace)
-            return `${leftTex}^{${rightTex}}`;
-        else
-            return `${leftTex}^${rightTex}`;
-    }
-    // toMathjs() {
-    //   return pow(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    // }
-    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();
-    //   const copy = new PowerNode(leftSimplified, rightSimplified, this.opts);
-    //   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;
-    //   }
-    //   let externals: AlgebraicNode[] = [];
-    //   //TODO Fractions
-    //   const recursive = (node: AlgebraicNode) => {
-    //     if (isMultiplyNode(node)) {
-    //       recursive(node.leftChild);
-    //       recursive(node.rightChild);
-    //     } else {
-    //       externals.push(node);
-    //     }
-    //   };
-    //   recursive(copy.leftChild)
-    //   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 (isNumberNode(simplified) && simplified.value === 1) {
-    //             externals.splice(i, 1);
-    //           }
-    //           simplifyIteration();
-    //           return;
-    //         }
-    //       }
-    //     }
-    //   };
-    //   simplifyIteration();
-    //   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)) {
-    //     const powerValue = rightSimplified.value;
-    //     const powerIsEven = powerValue % 2 === 0;
-    //     if (powerIsEven) {
-    //       return new PowerNode(
-    //         leftSimplified.child,
-    //         new NumberNode(powerValue / 2),
-    //       ).simplify();
-    //     } else {
-    //       const parityPower = Math.floor(powerValue / 2);
-    //       return new MultiplyNode(
-    //         new PowerNode(leftSimplified.child, new NumberNode(parityPower)),
-    //         leftSimplified,
-    //       ).simplify();
-    //     }
-    //   }
-    //   return this;
-    //   // puissances négatives ?
-    // }
-    simplify(opts) {
-        //! temporaire
-        if ((0, numberNode_1.isNumberNode)(this.rightChild) && this.rightChild.value === 2) {
-            return new multiplyNode_1.MultiplyNode(this.leftChild, this.leftChild).simplify(opts);
-        }
-        return this;
-    }
-    equals(node) {
-        return (isPowerNode(node) &&
-            node.leftChild.equals(this.leftChild) &&
-            node.rightChild.equals(this.rightChild));
-    }
-}
-exports.PowerNode = PowerNode;
-class SquareNode extends PowerNode {
-    constructor(child, opts) {
-        super(child, new numberNode_1.NumberNode(2), opts);
-    }
-}
-exports.SquareNode = SquareNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SquareNode = exports.PowerNode = exports.isPowerNode = void 0;
+// import { pow } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const numberNode_1 = require("../numbers/numberNode");
+const multiplyNode_1 = require("./multiplyNode");
+function isPowerNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.power;
+}
+exports.isPowerNode = isPowerNode;
+class PowerNode {
+    constructor(leftChild, rightChild, opts) {
+        this.id = operatorNode_1.OperatorIds.power;
+        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()})`;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new PowerNode(leftNode, rightNode));
+                if (!this.opts?.forbidPowerToProduct && (0, numberNode_1.isNumberNode)(this.rightChild)) {
+                    const power = this.rightChild.value;
+                    if (Math.floor(power) !== power || power < 2)
+                        return;
+                    let tree = new multiplyNode_1.MultiplyNode(leftNode, leftNode);
+                    for (let i = 2; i < power; i++) {
+                        tree = new multiplyNode_1.MultiplyNode(tree, leftNode);
+                    }
+                    res.push(tree);
+                }
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        let needBrackets = leftTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
+            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(this.leftChild.id);
+        }
+        if (needBrackets)
+            leftTex = `\\left(${leftTex}\\right)`;
+        const needBrace = rightTex.length > 1;
+        if (needBrace)
+            return `${leftTex}^{${rightTex}}`;
+        else
+            return `${leftTex}^${rightTex}`;
+    }
+    // toMathjs() {
+    //   return pow(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    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();
+    //   const copy = new PowerNode(leftSimplified, rightSimplified, this.opts);
+    //   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;
+    //   }
+    //   let externals: AlgebraicNode[] = [];
+    //   //TODO Fractions
+    //   const recursive = (node: AlgebraicNode) => {
+    //     if (isMultiplyNode(node)) {
+    //       recursive(node.leftChild);
+    //       recursive(node.rightChild);
+    //     } else {
+    //       externals.push(node);
+    //     }
+    //   };
+    //   recursive(copy.leftChild)
+    //   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 (isNumberNode(simplified) && simplified.value === 1) {
+    //             externals.splice(i, 1);
+    //           }
+    //           simplifyIteration();
+    //           return;
+    //         }
+    //       }
+    //     }
+    //   };
+    //   simplifyIteration();
+    //   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)) {
+    //     const powerValue = rightSimplified.value;
+    //     const powerIsEven = powerValue % 2 === 0;
+    //     if (powerIsEven) {
+    //       return new PowerNode(
+    //         leftSimplified.child,
+    //         new NumberNode(powerValue / 2),
+    //       ).simplify();
+    //     } else {
+    //       const parityPower = Math.floor(powerValue / 2);
+    //       return new MultiplyNode(
+    //         new PowerNode(leftSimplified.child, new NumberNode(parityPower)),
+    //         leftSimplified,
+    //       ).simplify();
+    //     }
+    //   }
+    //   return this;
+    //   // puissances négatives ?
+    // }
+    simplify(opts) {
+        //! temporaire
+        if ((0, numberNode_1.isNumberNode)(this.rightChild) && this.rightChild.value === 2) {
+            return new multiplyNode_1.MultiplyNode(this.leftChild, this.leftChild).simplify(opts);
+        }
+        return this;
+    }
+    equals(node) {
+        return (isPowerNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
+}
+exports.PowerNode = PowerNode;
+class SquareNode extends PowerNode {
+    constructor(child, opts) {
+        super(child, new numberNode_1.NumberNode(2), opts);
+    }
+}
+exports.SquareNode = SquareNode;

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

@@ -1,20 +1,20 @@
-import { Node, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
-export declare function isSubstractNode(a: Node): a is SubstractNode;
-export declare class SubstractNode implements OperatorNode {
-    id: OperatorIds;
-    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(opts?: SimplifyOptions): AlgebraicNode;
-    equals(node: AlgebraicNode): boolean;
-}
+import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+export declare function isSubstractNode(a: Node): a is SubstractNode;
+export declare class SubstractNode implements OperatorNode {
+    id: OperatorIds;
+    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(opts?: SimplifyOptions): AlgebraicNode;
+    equals(node: AlgebraicNode): boolean;
+}
 //# sourceMappingURL=substractNode.d.ts.map

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

@@ -1,64 +1,64 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = exports.isSubstractNode = void 0;
-// import { subtract } from "mathjs";
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const oppositeNode_1 = require("../functions/oppositeNode");
-const addNode_1 = require("./addNode");
-function isSubstractNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.substract;
-}
-exports.isSubstractNode = isSubstractNode;
-class SubstractNode {
-    constructor(leftChild, rightChild) {
-        this.id = operatorNode_1.OperatorIds.substract;
-        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()})`;
-    }
-    toEquivalentNodes() {
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new SubstractNode(leftNode, rightNode));
-                res.push(new addNode_1.AddNode(new oppositeNode_1.OppositeNode(rightNode), leftNode));
-            });
-        });
-        return res;
-    }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
-            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === "-";
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex}-${rightTex}`;
-    }
-    evaluate(vars) {
-        return this.leftChild.evaluate(vars) - this.rightChild.evaluate(vars);
-    }
-    // toMathjs() {
-    //   return subtract(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    // }
-    simplify(opts) {
-        return new addNode_1.AddNode(this.leftChild, new oppositeNode_1.OppositeNode(this.rightChild)).simplify(opts);
-    }
-    equals(node) {
-        return (isSubstractNode(node) &&
-            node.leftChild.equals(this.leftChild) &&
-            node.rightChild.equals(this.rightChild));
-    }
-}
-exports.SubstractNode = SubstractNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = exports.isSubstractNode = void 0;
+// import { subtract } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const oppositeNode_1 = require("../functions/oppositeNode");
+const addNode_1 = require("./addNode");
+function isSubstractNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.substract;
+}
+exports.isSubstractNode = isSubstractNode;
+class SubstractNode {
+    constructor(leftChild, rightChild) {
+        this.id = operatorNode_1.OperatorIds.substract;
+        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()})`;
+    }
+    toEquivalentNodes() {
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new SubstractNode(leftNode, rightNode));
+                res.push(new addNode_1.AddNode(new oppositeNode_1.OppositeNode(rightNode), leftNode));
+            });
+        });
+        return res;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes().map((node) => node.toTex());
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
+            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
+            rightTex[0] === "-";
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex}-${rightTex}`;
+    }
+    evaluate(vars) {
+        return this.leftChild.evaluate(vars) - this.rightChild.evaluate(vars);
+    }
+    // toMathjs() {
+    //   return subtract(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify(opts) {
+        return new addNode_1.AddNode(this.leftChild, new oppositeNode_1.OppositeNode(this.rightChild)).simplify(opts);
+    }
+    equals(node) {
+        return (isSubstractNode(node) &&
+            node.leftChild.equals(this.leftChild) &&
+            node.rightChild.equals(this.rightChild));
+    }
+}
+exports.SubstractNode = SubstractNode;