math-exercises 2.0.12 → 2.0.13

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

@@ -1,311 +1,311 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = exports.sortMultiplyNodes = 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");
-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];
-        };
-        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()})`;
-    }
-    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 (!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 (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 (!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());
-    // }
-    evaluate(vars) {
-        return this.leftChild.evaluate(vars) * this.rightChild.evaluate(vars);
-    }
-    copy() {
-        return new MultiplyNode(this.leftChild, this.rightChild, this.opts);
-    }
-    simplify(opts) {
-        const leftSimplified = this.leftChild.simplify(opts);
-        const rightSimplified = this.rightChild.simplify(opts);
-        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(opts);
-        }
-        (0, exports.sortMultiplyNodes)(externals);
-        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(opts);
-            }
-            //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;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiplyNode = exports.sortMultiplyNodes = 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");
+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];
+        };
+        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()})`;
+    }
+    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 (!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 (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 (!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());
+    // }
+    evaluate(vars) {
+        return this.leftChild.evaluate(vars) * this.rightChild.evaluate(vars);
+    }
+    copy() {
+        return new MultiplyNode(this.leftChild, this.rightChild, this.opts);
+    }
+    simplify(opts) {
+        const leftSimplified = this.leftChild.simplify(opts);
+        const rightSimplified = this.rightChild.simplify(opts);
+        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;
+        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];
+        if (!opts?.forceDistributeFractions)
+            if (externals.some((node) => (0, fractionNode_1.isFractionNode)(node))) {
+                //s'il y a une fraction on transforme en fracNode
+                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(opts);
+            }
+        (0, exports.sortMultiplyNodes)(externals);
+        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(opts);
+            }
+            //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;