math-exercises 2.0.0 → 2.0.2

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

@@ -1,19 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = void 0;
+exports.MultiplyNode = exports.isMultiplyNode = void 0;
 const mathjs_1 = require("mathjs");
-const functionNode_1 = require("../functions/functionNode");
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
-class MultiplyNode extends operatorNode_1.OperatorNode {
+const coinFlip_1 = require("../../../utils/coinFlip");
+const permutations_1 = require("../../../utils/permutations");
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const operatorComposition_1 = require("../../../tree/utilities/operatorComposition");
+const powerNode_1 = require("./powerNode");
+const numberNode_1 = require("../numbers/numberNode");
+const isInt_1 = require("../../../utils/isInt");
+const variableNode_1 = require("../variables/variableNode");
+function isMultiplyNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
+}
+exports.isMultiplyNode = isMultiplyNode;
+class MultiplyNode {
     constructor(leftChild, rightChild, opts) {
-        let [left, right] = [leftChild, rightChild];
-        const shouldSwitch = (rightChild.type === node_1.NodeType.function && rightChild.id === functionNode_1.FunctionsIds.opposite) ||
-            (leftChild.type === node_1.NodeType.constant && rightChild.type === node_1.NodeType.number);
-        if (shouldSwitch) {
-            [left, right] = [rightChild, leftChild];
-        }
-        super(operatorNode_1.OperatorIds.multiply, left, right, true, '\\times');
+        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;
     }
     toMathString() {
@@ -22,51 +43,151 @@ class MultiplyNode extends operatorNode_1.OperatorNode {
     toTex() {
         let leftTex = this.leftChild.toTex();
         let rightTex = this.rightChild.toTex();
-        if (this.rightChild.type === node_1.NodeType.variable) {
-            if (leftTex === '1') {
+        if (leftTex === "1") {
+            if ((0, numberNode_1.isNumberNode)(this.rightChild)) {
                 return rightTex;
             }
         }
-        if (this.leftChild.type === node_1.NodeType.operator) {
+        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
             if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
                 leftTex = `\\left(${leftTex}\\right)`;
         }
-        let needBrackets = rightTex[0] === '-';
-        if (this.rightChild.type === node_1.NodeType.operator) {
+        let needBrackets = rightTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
             const operatorRightChild = this.rightChild;
             needBrackets ||= [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(operatorRightChild.id);
         }
         if (needBrackets)
             rightTex = `\\left(${rightTex}\\right)`;
-        let showTimesSign = this.opts?.forceTimesSign || !isNaN(+rightTex[0]) || this.rightChild.type === node_1.NodeType.number;
-        if (this.rightChild.type === node_1.NodeType.operator) {
-            const operatorRightChild = this.rightChild;
-            showTimesSign ||= [operatorNode_1.OperatorIds.fraction].includes(operatorRightChild.id);
+        if (leftTex === "-1") {
+            if (!(0, numberNode_1.isNumberNode)(this.rightChild)) {
+                return "-" + rightTex;
+            }
+        }
+        let showTimesSign = this.opts?.forceTimesSign ||
+            !isNaN(+rightTex[0]) ||
+            (0, numberNode_1.isNumberNode)(this.rightChild) ||
+            ((0, variableNode_1.isVariableNode)(this.leftChild) &&
+                (0, variableNode_1.isVariableNode)(this.rightChild) &&
+                this.leftChild.name === this.rightChild.name);
+        if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
+            showTimesSign ||= [operatorNode_1.OperatorIds.fraction].includes(this.rightChild.id);
         }
         const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
-        return `${leftTex}${showTimesSign ? `\\times${nextIsLetter ? ' ' : ''}` : ''}${rightTex}`;
+        return `${leftTex}${showTimesSign ? `\\times${nextIsLetter ? " " : ""}` : ""}${rightTex}`;
     }
-    toEquivalentNodes() {
+    toAllTexs() {
         const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new MultiplyNode(leftNode, rightNode));
-                //! pas opti, ca va générer plusieurs nodes avec le même tex
-                //! comment gérer ce cas ?
-                res.push(new MultiplyNode(leftNode, rightNode, { forceTimesSign: true }));
-                res.push(new MultiplyNode(rightNode, leftNode));
-                res.push(new MultiplyNode(rightNode, leftNode, { forceTimesSign: true }));
+        let leftTex = this.leftChild.toTex();
+        let rightTex = this.rightChild.toTex();
+        if (leftTex === "1") {
+            if ((0, numberNode_1.isNumberNode)(this.rightChild)) {
+                res.push(rightTex);
+            }
+        }
+        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
+            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
+                leftTex = `\\left(${leftTex}\\right)`;
+        }
+        let needRightBrackets = rightTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
+            needRightBrackets ||= [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id);
+        }
+        if (needRightBrackets)
+            rightTex = `\\left(${rightTex}\\right)`;
+        if (leftTex === "-1") {
+            if ((0, numberNode_1.isNumberNode)(this.rightChild)) {
+                res.push("-" + rightTex);
+            }
+        }
+        let mustShowTimesSign = !isNaN(+rightTex[0]) || (0, numberNode_1.isNumberNode)(this.rightChild);
+        const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
+        res.push(`${leftTex}${`\\times${nextIsLetter ? " " : ""}`}${rightTex}`);
+        if (!needRightBrackets)
+            res.push(`${leftTex}${`\\times${nextIsLetter ? " " : ""}`}\\left(${rightTex}\\right)`);
+        if (mustShowTimesSign)
+            return res;
+        res.push(`${leftTex}${rightTex}`);
+        return res;
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const res = [];
+        const multiplyTree = [];
+        //ce seront des nodes qui ne sont pas des MultiNode
+        //si l'élement est un array ca signifie qu'il faudra faire les produits cartésiens pour avoir toutes les possibilités
+        //exp [2,[[5,5], 5^2], 3] -> il faudra faire les permutation sur [2,5,5,3] et sur [2,5^2,3]
+        //!manque d'opti si [2,[5x5,5^2],[5x5,5^2]] par exp, mais par contruction on aura écrit ca [2,5^4]
+        //1: choper le sous arbre de type Non Multi (ie les enfants nonMulti des Multi)
+        const recursive = (node) => {
+            if ((0, operatorNode_1.isOperatorNode)(node)) {
+                if (isMultiplyNode(node)) {
+                    recursive(node.leftChild);
+                    recursive(node.rightChild);
+                }
+                else if ((0, powerNode_1.isPowerNode)(node) &&
+                    !options?.forbidPowerToProduct &&
+                    (0, numberNode_1.isNumberNode)(node.rightChild)) {
+                    //si power node avec power=int, créer un array contenant chaque décomposition de la puissnace possible
+                    //genre 5^2 : [[5,5], 5^2]
+                    //5^3  : [[5,5,5], [5,5^2], 5^3]
+                    const power = node.rightChild;
+                    if ((0, numberNode_1.isNumberNode)(power)) {
+                        const powerNB = power.value;
+                        if ((0, isInt_1.isInt)(powerNB) && powerNB > 1) {
+                            const arr = [
+                                new powerNode_1.PowerNode(node.leftChild, node.rightChild, {
+                                    forbidPowerToProduct: true,
+                                }),
+                            ];
+                            for (let i = 0; i < powerNB - 1; i++) {
+                                const newPower = powerNB - (i + 1);
+                                if (newPower === 1) {
+                                    //que des nbs solos
+                                    const nbs = Array(powerNB).fill(node.leftChild);
+                                    arr.push(nbs);
+                                }
+                                else {
+                                    //powerNb-newPower nbs solos
+                                    const newPowerNode = new powerNode_1.PowerNode(node.leftChild, new numberNode_1.NumberNode(newPower), { forbidPowerToProduct: true });
+                                    const nbs = Array(powerNB - newPower).fill(node.leftChild);
+                                    arr.push([...nbs, newPowerNode]);
+                                }
+                            }
+                            multiplyTree.push(arr);
+                        }
+                    }
+                }
+                else
+                    multiplyTree.push(node);
+            }
+            else
+                multiplyTree.push(node);
+        };
+        recursive(this);
+        const multiplyCartesians = (0, cartesianProducts_1.getFlatCartesianProducts)(multiplyTree.map((el) => (Array.isArray(el) ? el : [el])));
+        multiplyCartesians.forEach((multiplyCartesian) => {
+            //2: pour tous les nodes qui ne sont pas Multi, on génère les equiv node
+            const equivNodesArr = multiplyCartesian.map((node) => node.toEquivalentNodes(opts));
+            //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
+            //3: créer toutes les permutations de tous les nodes equiv
+            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
+            equivNodesPermutations.forEach((permutation) => {
+                //4: créé les produits cartésiens des nodes equiv puis nodify
+                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                cartesiansProducts.forEach((product) => {
+                    res.push((0, operatorComposition_1.operatorComposition)(MultiplyNode, product));
+                });
             });
         });
         return res;
     }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
+    toAllValidTexs(opts) {
+        return this.toEquivalentNodes(opts).flatMap((node) => node.toAllTexs());
     }
     toMathjs() {
         return (0, mathjs_1.multiply)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
     }
+    simplify() { }
 }
 exports.MultiplyNode = MultiplyNode;

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

@@ -1,22 +1,21 @@
-import { Node, NodeType } from '../node';
+import { AlgebraicNode } from "../algebraicNode";
+import { Node } from "../node";
 export declare enum OperatorIds {
     add = 0,
     substract = 1,
     multiply = 2,
     fraction = 3,
     divide = 4,
-    power = 5,
-    equal = 6
+    power = 5
 }
-export declare abstract class OperatorNode {
+export interface OperatorNode extends AlgebraicNode {
     id: OperatorIds;
-    leftChild: Node;
-    rightChild: Node;
-    isCommutative: boolean;
-    type: NodeType;
-    tex: string;
-    constructor(id: OperatorIds, leftChild: Node, rightChild: Node, isCommutative: boolean, tex: string);
-    /**shuffles in place */
-    shuffle(): void;
+    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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;CACN;AAED,8BAAsB,YAAY;IAChC,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;IACvB,IAAI,WAAqB;IACzB,GAAG,EAAE,MAAM,CAAC;gBACA,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM;IAQnG,uBAAuB;IACvB,OAAO,IAAI,IAAI;CAMhB"}
+{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAY,MAAM,SAAS,CAAC;AAEzC,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;CACN;AAED,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;CAC3B;AACD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OperatorNode = exports.OperatorIds = void 0;
-const coinFlip_1 = require("../../../utils/coinFlip");
+exports.isOperatorNode = exports.OperatorIds = void 0;
 const node_1 = require("../node");
 var OperatorIds;
 (function (OperatorIds) {
@@ -11,25 +10,8 @@ var OperatorIds;
     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;
-    }
+function isOperatorNode(a) {
+    return a.type === node_1.NodeType.operator;
 }
-exports.OperatorNode = OperatorNode;
+exports.isOperatorNode = isOperatorNode;

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

@@ -1,16 +1,21 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-type PowerNodeOptions = {
-    allowProductSyntax?: boolean;
-};
-export declare class PowerNode extends OperatorNode implements Node {
-    opts?: PowerNodeOptions;
-    constructor(leftChild: Node, rightChild: Node, opts?: PowerNodeOptions);
+import { Node, NodeOptions, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode } 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;
+    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
     toEquivalentNodes(): Node[];
     toAllValidTexs(): string[];
     toTex(): string;
     toMathjs(): import("mathjs").MathType;
 }
-export {};
+export declare class SquareNode extends PowerNode {
+    constructor(child: Node, opts?: NodeOptions);
+}
 //# sourceMappingURL=powerNode.d.ts.map

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,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAI3D,KAAK,gBAAgB,GAAG;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,qBAAa,SAAU,SAAQ,YAAa,YAAW,IAAI;IACzD,IAAI,CAAC,EAAE,gBAAgB,CAAC;gBACZ,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,gBAAgB;IAKtE,YAAY,IAAI,MAAM;IAItB,iBAAiB;IAsBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAqBf,QAAQ;CAGT"}
+{"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;AAEjD,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;IAoBf,QAAQ;CAGT;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;CAG5C"}

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

@@ -1,13 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PowerNode = void 0;
+exports.SquareNode = exports.PowerNode = exports.isPowerNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
+const numberNode_1 = require("../numbers/numberNode");
 const multiplyNode_1 = require("./multiplyNode");
-class PowerNode extends operatorNode_1.OperatorNode {
+function isPowerNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.power;
+}
+exports.isPowerNode = isPowerNode;
+class PowerNode {
     constructor(leftChild, rightChild, opts) {
-        super(operatorNode_1.OperatorIds.power, leftChild, rightChild, false, '^');
+        this.id = operatorNode_1.OperatorIds.power;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
         this.opts = opts;
     }
     toMathString() {
@@ -20,7 +28,7 @@ class PowerNode extends operatorNode_1.OperatorNode {
         rightNodes.forEach((rightNode) => {
             leftNodes.forEach((leftNode) => {
                 res.push(new PowerNode(leftNode, rightNode));
-                if (this.opts?.allowProductSyntax && this.rightChild.type === node_1.NodeType.number) {
+                if (!this.opts?.forbidPowerToProduct && (0, numberNode_1.isNumberNode)(this.rightChild)) {
                     const power = this.rightChild.value;
                     if (Math.floor(power) !== power || power < 2)
                         return;
@@ -40,9 +48,8 @@ class PowerNode extends operatorNode_1.OperatorNode {
     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;
+        let needBrackets = leftTex[0] === "-";
+        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
             needBrackets ||= [
                 operatorNode_1.OperatorIds.add,
                 operatorNode_1.OperatorIds.substract,
@@ -50,7 +57,7 @@ class PowerNode extends operatorNode_1.OperatorNode {
                 operatorNode_1.OperatorIds.divide,
                 operatorNode_1.OperatorIds.fraction,
                 operatorNode_1.OperatorIds.power,
-            ].includes(childOperator.id);
+            ].includes(this.leftChild.id);
         }
         if (needBrackets)
             leftTex = `\\left(${leftTex}\\right)`;
@@ -65,3 +72,9 @@ class PowerNode extends operatorNode_1.OperatorNode {
     }
 }
 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,6 +1,11 @@
-import { Node } from '../node';
-import { OperatorNode } from './operatorNode';
-export declare class SubstractNode extends OperatorNode implements Node {
+import { Node, NodeType } from "../node";
+import { OperatorIds, OperatorNode } from "./operatorNode";
+export declare function isSubstractNode(a: Node): a is SubstractNode;
+export declare class SubstractNode implements OperatorNode {
+    id: OperatorIds;
+    leftChild: Node;
+    rightChild: Node;
+    type: NodeType;
     constructor(leftChild: Node, rightChild: Node);
     toMathString(): string;
     toEquivalentNodes(): Node[];

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,EAAY,MAAM,SAAS,CAAC;AACzC,OAAO,EAAe,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE3D,qBAAa,aAAc,SAAQ,YAAa,YAAW,IAAI;gBACjD,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAG7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAY3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAaf,QAAQ;CAGT"}
+{"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,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,aAAa,CAE3D;AACD,qBAAa,aAAc,YAAW,YAAY;IAChD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;IAO7C,YAAY,IAAI,MAAM;IAItB,iBAAiB,IAAI,IAAI,EAAE;IAa3B,cAAc,IAAI,MAAM,EAAE;IAG1B,KAAK,IAAI,MAAM;IAef,QAAQ;CAGT"}

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

@@ -1,12 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = void 0;
+exports.SubstractNode = exports.isSubstractNode = void 0;
 const mathjs_1 = require("mathjs");
 const node_1 = require("../node");
 const operatorNode_1 = require("./operatorNode");
-class SubstractNode extends operatorNode_1.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) {
-        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
+        this.id = operatorNode_1.OperatorIds.substract;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
     }
     toMathString() {
         return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
@@ -18,6 +27,7 @@ class SubstractNode extends operatorNode_1.OperatorNode {
         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;
@@ -28,9 +38,9 @@ class SubstractNode extends operatorNode_1.OperatorNode {
     toTex() {
         let rightTex = this.rightChild.toTex();
         let leftTex = this.leftChild.toTex();
-        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
+        const needBrackets = ((0, operatorNode_1.isOperatorNode)(this.rightChild) &&
             [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === '-';
+            rightTex[0] === "-";
         if (needBrackets)
             rightTex = `(${rightTex})`;
         return `${leftTex}-${rightTex}`;

package/lib/tree/nodes/sets/belongsNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class BelongsNode implements Node {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    leftChild: Node;
+    rightChild: SetNode;
+    constructor(leftChild: Node, rightChild: SetNode, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): Node[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=belongsNode.d.ts.map

package/lib/tree/nodes/sets/belongsNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"belongsNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/belongsNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,WAAY,YAAW,IAAI;IACtC,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;gBACR,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,WAAW;IAMpE,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,IAAI,EAAE;IAc7C,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAGN"}

package/lib/tree/nodes/sets/belongsNode.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsNode = void 0;
+const node_1 = require("../node");
+class BelongsNode {
+    constructor(leftChild, rightChild, opts) {
+        this.type = node_1.NodeType.belongs;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const rightEquivs = this.rightChild.toEquivalentNodes(options);
+        if (options?.allowRawRightChildAsSolution)
+            return rightEquivs.flatMap((equiv) => [
+                new BelongsNode(this.leftChild, equiv, options),
+                equiv,
+            ]);
+        else
+            return rightEquivs.map((equiv) => new BelongsNode(this.leftChild, equiv, options));
+    }
+    toMathString() {
+        return this.toTex();
+    }
+    toMathjs() {
+        return this.toTex();
+    }
+    toTex() {
+        return `${this.leftChild.toTex()}\\in${this.rightChild.toTex()}`;
+    }
+}
+exports.BelongsNode = BelongsNode;

package/lib/tree/nodes/sets/discreteSetNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare class DiscreteSetNode implements SetNode {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    elements: Node[];
+    constructor(elements: Node[], opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): DiscreteSetNode[];
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+export declare const EmptySet: DiscreteSetNode;
+//# sourceMappingURL=discreteSetNode.d.ts.map

package/lib/tree/nodes/sets/discreteSetNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discreteSetNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/discreteSetNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,qBAAa,eAAgB,YAAW,OAAO;IAC7C,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,QAAQ,EAAE,IAAI,EAAE,CAAC;gBACL,QAAQ,EAAE,IAAI,EAAE,EAAE,IAAI,CAAC,EAAE,WAAW;IAKhD,cAAc;IAGd,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAyBpC,YAAY;IAGZ,QAAQ;IAGR,KAAK;CAMN;AAED,eAAO,MAAM,QAAQ,iBAA0B,CAAC"}

package/lib/tree/nodes/sets/discreteSetNode.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptySet = exports.DiscreteSetNode = void 0;
+const cartesianProducts_1 = require("../../../utils/cartesianProducts");
+const permutations_1 = require("../../../utils/permutations");
+const node_1 = require("../node");
+class DiscreteSetNode {
+    constructor(elements, opts) {
+        this.type = node_1.NodeType.set;
+        this.elements = elements;
+        this.opts = opts;
+    }
+    toAllValidTexs() {
+        return this.toEquivalentNodes(this.opts).map((node) => node.toTex());
+    }
+    toEquivalentNodes(opts) {
+        if (this.elements.length === 0)
+            return [this];
+        if (this.elements.length === 1) {
+            return this.elements[0]
+                .toEquivalentNodes(opts ?? this.opts)
+                .map((node) => new DiscreteSetNode([node]));
+        }
+        //produits cartésiens
+        else {
+            const res = [];
+            const equivNodesArr = this.elements.map((node) => node.toEquivalentNodes(opts ?? this.opts));
+            //!pas opti car si [2,3,3] alors les 3 se permutent et donc double sortie [2,3_1,3_2], [2,3_2,3_1]
+            let equivNodesPermutations = (0, permutations_1.permute)(equivNodesArr);
+            equivNodesPermutations.forEach((permutation) => {
+                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                cartesiansProducts.forEach((product) => {
+                    res.push(new DiscreteSetNode(product));
+                });
+            });
+            return res;
+        }
+    }
+    toMathString() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toMathjs() {
+        return `{${this.elements.map((el) => el.toTex()).join(";")}}`;
+    }
+    toTex() {
+        if (!this.elements.length)
+            return `\\emptyset`;
+        return `\\left\\{${this.elements
+            .map((el) => el.toTex())
+            .join(";")}\\right\\}`;
+    }
+}
+exports.DiscreteSetNode = DiscreteSetNode;
+exports.EmptySet = new DiscreteSetNode([]);

package/lib/tree/nodes/sets/intervalNode.d.ts

@@ -0,0 +1,24 @@
+import { InequationNode } from "../inequations/inequationNode";
+import { Node, NodeOptions, NodeType } from "../node";
+import { SetNode } from "./setNode";
+export declare enum ClosureType {
+    FF = 0,
+    FO = 1,
+    OF = 2,
+    OO = 3
+}
+export declare class IntervalNode implements SetNode {
+    type: NodeType;
+    opts?: NodeOptions | undefined;
+    closure: ClosureType;
+    a: Node;
+    b: Node;
+    constructor(a: Node, b: Node, closure: ClosureType, opts?: NodeOptions);
+    toAllValidTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): IntervalNode[];
+    toInequality(middleChild?: Node): InequationNode;
+    toMathString(): string;
+    toMathjs(): string;
+    toTex(): string;
+}
+//# sourceMappingURL=intervalNode.d.ts.map

package/lib/tree/nodes/sets/intervalNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/sets/intervalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,oBAAY,WAAW;IACrB,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;IACF,EAAE,IAAA;CACH;AAED,qBAAa,YAAa,YAAW,OAAO;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;IAC/B,OAAO,EAAE,WAAW,CAAC;IACrB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW;IAQtE,cAAc;IAId,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAoBpC,YAAY,CAAC,WAAW,CAAC,EAAE,IAAI;IA4B/B,YAAY;IAIZ,QAAQ;IAIR,KAAK;CAWN"}