math-exercises 2.0.2 → 2.0.4

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

@@ -1,70 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FractionNode = exports.isFractionNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const numberNode_1 = require("../numbers/numberNode");
-const round_1 = require("../../../math/utils/round");
-const oppositeNode_1 = require("../functions/oppositeNode");
-function isFractionNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
-}
-exports.isFractionNode = isFractionNode;
-class FractionNode {
-    constructor(leftChild, rightChild, opts) {
-        this.id = operatorNode_1.OperatorIds.fraction;
-        this.leftChild = leftChild;
-        this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
-        this.opts = opts;
-    }
-    toMathString() {
-        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
-    }
-    toInversed() {
-        return new FractionNode(this.rightChild, this.leftChild);
-    }
-    toEquivalentNodes(opts) {
-        const options = opts ?? this.opts;
-        const res = [];
-        const rightNodes = this.rightChild.toEquivalentNodes();
-        const leftNodes = this.leftChild.toEquivalentNodes();
-        rightNodes.forEach((rightNode) => {
-            leftNodes.forEach((leftNode) => {
-                res.push(new FractionNode(leftNode, rightNode));
-                if (options?.allowFractionToDecimal &&
-                    (0, numberNode_1.isNumberNode)(leftNode) &&
-                    (0, numberNode_1.isNumberNode)(rightNode)) {
-                    const [num, denum] = [leftNode.value, rightNode.value];
-                    const decimal = (0, round_1.round)(num / denum, 12);
-                    //on ne push pas les non décimaux (limite arbitraire : partie décimale de 12 => non décimal)
-                    if ((decimal + "").split(".")[1].length > 11)
-                        return;
-                    res.push(new numberNode_1.NumberNode(decimal));
-                }
-            });
-        });
-        return res;
-        //! cas x/2 : doit on créer 1*x/2 ainsi que 0.5*x ??
-        //! si le num est un multiplynode, ex x*y/z , est ce qu'on créé x*(y/z), y*(x/z) ??
-        //! est ce qu'on gère le placement du moins n'importe où
-    }
-    toAllValidTexs(opts) {
-        return this.toEquivalentNodes(opts).map((node) => node.toTex());
-    }
-    toTex() {
-        if (!this.opts?.allowMinusAnywhereInFraction &&
-            ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||
-                ((0, numberNode_1.isNumberNode)(this.leftChild) && this.leftChild.value < 0))) {
-            return `-\\frac{${this.leftChild
-                .toTex()
-                .slice(1)}}{${this.rightChild.toTex()}}`;
-        }
-        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.fraction)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.FractionNode = FractionNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FractionNode = exports.isFractionNode = void 0;
+// import { fraction } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+const numberNode_1 = require("../numbers/numberNode");
+const round_1 = require("../../../math/utils/round");
+const oppositeNode_1 = require("../functions/oppositeNode");
+function isFractionNode(a) {
+    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.fraction;
+}
+exports.isFractionNode = isFractionNode;
+class FractionNode {
+    constructor(leftChild, rightChild, opts) {
+        this.id = operatorNode_1.OperatorIds.fraction;
+        this.leftChild = leftChild;
+        this.rightChild = rightChild;
+        this.type = node_1.NodeType.operator;
+        this.opts = opts;
+    }
+    toMathString() {
+        return `(${this.leftChild.toMathString()}) / (${this.rightChild.toMathString()})`;
+    }
+    toInversed() {
+        return new FractionNode(this.rightChild, this.leftChild);
+    }
+    toEquivalentNodes(opts) {
+        const options = opts ?? this.opts;
+        const res = [];
+        const rightNodes = this.rightChild.toEquivalentNodes();
+        const leftNodes = this.leftChild.toEquivalentNodes();
+        rightNodes.forEach((rightNode) => {
+            leftNodes.forEach((leftNode) => {
+                res.push(new FractionNode(leftNode, rightNode));
+                if (options?.allowFractionToDecimal &&
+                    (0, numberNode_1.isNumberNode)(leftNode) &&
+                    (0, numberNode_1.isNumberNode)(rightNode)) {
+                    const [num, denum] = [leftNode.value, rightNode.value];
+                    const decimal = (0, round_1.round)(num / denum, 12);
+                    //on ne push pas les non décimaux (limite arbitraire : partie décimale de 12 => non décimal)
+                    if ((decimal + "").split(".")[1].length > 11)
+                        return;
+                    res.push(new numberNode_1.NumberNode(decimal));
+                }
+            });
+        });
+        return res;
+        //! cas x/2 : doit on créer 1*x/2 ainsi que 0.5*x ??
+        //! si le num est un multiplynode, ex x*y/z , est ce qu'on créé x*(y/z), y*(x/z) ??
+        //! est ce qu'on gère le placement du moins n'importe où
+    }
+    toAllValidTexs(opts) {
+        return this.toEquivalentNodes(opts).map((node) => node.toTex());
+    }
+    toTex() {
+        if (!this.opts?.allowMinusAnywhereInFraction &&
+            ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||
+                ((0, numberNode_1.isNumberNode)(this.leftChild) && this.leftChild.value < 0))) {
+            return `-\\frac{${this.leftChild
+                .toTex()
+                .slice(1)}}{${this.rightChild.toTex()}}`;
+        }
+        return `\\frac{${this.leftChild.toTex()}}{${this.rightChild.toTex()}}`;
+    }
+}
+exports.FractionNode = FractionNode;

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

@@ -1,21 +1,20 @@
-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 class MultiplyNode implements CommutativeOperatorNode {
-    opts?: NodeOptions;
-    id: OperatorIds;
-    leftChild: AlgebraicNode;
-    rightChild: AlgebraicNode;
-    type: NodeType;
-    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
-    shuffle: () => void;
-    toMathString(): string;
-    toTex(): string;
-    toAllTexs(): string[];
-    toEquivalentNodes(opts?: NodeOptions): MultiplyNode[];
-    toAllValidTexs(opts?: NodeOptions): string[];
-    toMathjs(): any;
-    simplify(): void;
-}
+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 class MultiplyNode implements CommutativeOperatorNode {
+    opts?: NodeOptions;
+    id: OperatorIds;
+    leftChild: AlgebraicNode;
+    rightChild: AlgebraicNode;
+    type: NodeType;
+    constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
+    shuffle: () => void;
+    toMathString(): string;
+    toTex(): string;
+    toAllTexs(): string[];
+    toEquivalentNodes(opts?: NodeOptions): MultiplyNode[];
+    toAllValidTexs(opts?: NodeOptions): string[];
+    simplify(): void;
+}
 //# 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;IAI5C,QAAQ;IAIR,QAAQ;CACT"}
+{"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;CACT"}

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

@@ -1,193 +1,193 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = exports.isMultiplyNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./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) {
-        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() {
-        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let leftTex = this.leftChild.toTex();
-        let rightTex = this.rightChild.toTex();
-        if (leftTex === "1") {
-            if ((0, numberNode_1.isNumberNode)(this.rightChild)) {
-                return 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 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)`;
-        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}`;
-    }
-    toAllTexs() {
-        const res = [];
-        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(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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiplyNode = exports.isMultiplyNode = void 0;
+// import { multiply } from "mathjs";
+const node_1 = require("../node");
+const operatorNode_1 = require("./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) {
+        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() {
+        return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let leftTex = this.leftChild.toTex();
+        let rightTex = this.rightChild.toTex();
+        if (leftTex === "1") {
+            // if (isNumberNode(this.rightChild) || isVariableNode(this.rightChild)) {
+            return 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 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)`;
+        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}`;
+    }
+    toAllTexs() {
+        const res = [];
+        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(opts) {
+        return this.toEquivalentNodes(opts).flatMap((node) => node.toAllTexs());
+    }
+    // toMathjs() {
+    //   return multiply(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    // }
+    simplify() { }
+}
+exports.MultiplyNode = MultiplyNode;

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

@@ -1,21 +1,21 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node } from "../node";
-export declare enum OperatorIds {
-    add = 0,
-    substract = 1,
-    multiply = 2,
-    fraction = 3,
-    divide = 4,
-    power = 5
-}
-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
+}
+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.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"operatorNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/operatorNode.ts"],"names":[],"mappings":"AAAA,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"}