math-exercises 2.2.98 → 3.0.2

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

@@ -1,76 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiplyNode = exports.sortMultiplyNodes = exports.multiply = exports.isMultiplyNode = void 0;
 // import { multiply } from "mathjs";
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const coinFlip_1 = require("../../../utils/alea/coinFlip");
-const permutations_1 = require("../../../utils/arrays/permutations");
-const cartesianProducts_1 = require("../../../utils/arrays/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");
-const addNode_1 = require("./addNode");
-const round_1 = require("../../../math/utils/round");
-const colorize_1 = require("../../../utils/latex/colorize");
-const substractNode_1 = require("./substractNode");
-const constantNode_1 = require("../numbers/constantNode");
-function isMultiplyNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.multiply;
+import { NodeIds, NodeType } from "../node.js";
+import { OperatorIds, isCommutativeOperatorNode, isOperatorNode, } from "./operatorNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { permute } from "../../../utils/arrays/permutations.js";
+import { getCartesiansProducts, getFlatCartesianProducts, } from "../../../utils/arrays/cartesianProducts.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { PowerNode, SquareNode, isPowerNode } from "./powerNode.js";
+import { NumberNode, isNumberNode } from "../numbers/numberNode.js";
+import { isInt } from "../../../utils/isInt.js";
+import { isVariableNode } from "../variables/variableNode.js";
+import { SqrtNode, isSqrtNode } from "../functions/sqrtNode.js";
+import { isOppositeNode } from "../functions/oppositeNode.js";
+import { FractionNode, isFractionNode } from "./fractionNode.js";
+import { isFunctionNode } from "../functions/functionNode.js";
+import { AddNode, add, isAddNode } from "./addNode.js";
+import { round } from "../../../math/utils/round.js";
+import { colorize } from "../../../utils/latex/colorize.js";
+import { isSubstractNode } from "./substractNode.js";
+import { isConstantNode } from "../numbers/constantNode.js";
+export function isMultiplyNode(a) {
+    return isOperatorNode(a) && a.id === OperatorIds.multiply;
 }
-exports.isMultiplyNode = isMultiplyNode;
-const multiply = (a, b, opts) => {
+export const multiply = (a, b, opts) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
     return new MultiplyNode(nodeA, nodeB, opts);
 };
-exports.multiply = multiply;
-const sortMultiplyNodes = (arr) => {
+export 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, operatorNode_1.isOperatorNode)(b)) - Number((0, operatorNode_1.isOperatorNode)(a)) ||
-            Number((0, variableNode_1.isVariableNode)(b)) - Number((0, variableNode_1.isVariableNode)(a)) ||
-            Number((0, functionNode_1.isFunctionNode)(b)) - Number((0, functionNode_1.isFunctionNode)(a)));
+            Number(isNumberNode(b) && b.value === -1) -
+                Number(isNumberNode(a) && a.value === -1) ||
+            Number(isNumberNode(b)) - Number(isNumberNode(a)) ||
+            Number(isOperatorNode(b)) - Number(isOperatorNode(a)) ||
+            Number(isVariableNode(b)) - Number(isVariableNode(a)) ||
+            Number(isFunctionNode(b)) - Number(isFunctionNode(a)));
     });
 };
-exports.sortMultiplyNodes = sortMultiplyNodes;
-class MultiplyNode {
+export class MultiplyNode {
+    opts;
+    id;
+    leftChild;
+    rightChild;
+    type;
+    isNumeric;
     constructor(leftChild, rightChild, opts) {
-        this.shuffle = () => {
-            if ((0, coinFlip_1.coinFlip)())
-                [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
-        };
-        this.deepShuffle = (opts) => {
-            const left = (0, operatorNode_1.isCommutativeOperatorNode)(this.leftChild)
-                ? this.leftChild.deepShuffle(opts)
-                : this.leftChild;
-            const right = (0, operatorNode_1.isCommutativeOperatorNode)(this.rightChild)
-                ? this.rightChild.deepShuffle(opts)
-                : this.rightChild;
-            if ((0, coinFlip_1.coinFlip)() && (!opts || opts?.nodeIdsToShuffle?.includes(this.id)))
-                return new MultiplyNode(right, left, this.opts);
-            else
-                return new MultiplyNode(left, right, this.opts);
-        };
-        this.toReversed = () => {
-            return new MultiplyNode(this.rightChild, this.leftChild, this.opts);
-        };
-        this.id = operatorNode_1.OperatorIds.multiply;
+        this.id = OperatorIds.multiply;
         this.leftChild = leftChild;
         this.rightChild = rightChild;
-        this.type = node_1.NodeType.operator;
+        this.type = NodeType.operator;
         this.opts = opts;
         this.isNumeric = leftChild.isNumeric && rightChild.isNumeric;
     }
+    shuffle = () => {
+        if (coinFlip())
+            [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
+    };
+    deepShuffle = (opts) => {
+        const left = isCommutativeOperatorNode(this.leftChild)
+            ? this.leftChild.deepShuffle(opts)
+            : this.leftChild;
+        const right = isCommutativeOperatorNode(this.rightChild)
+            ? this.rightChild.deepShuffle(opts)
+            : this.rightChild;
+        if (coinFlip() && (!opts || opts?.nodeIdsToShuffle?.includes(this.id)))
+            return new MultiplyNode(right, left, this.opts);
+        else
+            return new MultiplyNode(left, right, this.opts);
+    };
+    toReversed = () => {
+        return new MultiplyNode(this.rightChild, this.leftChild, this.opts);
+    };
     toMathString() {
         return `(${this.leftChild.toMathString()})*(${this.rightChild.toMathString()})`;
     }
@@ -83,29 +83,29 @@ class MultiplyNode {
         let leftTex = this.leftChild.toTex(childOpts);
         let rightTex = this.rightChild.toTex(childOpts);
         if (!opts?.forceNoSimplification &&
-            (0, numberNode_1.isNumberNode)(this.leftChild) &&
+            isNumberNode(this.leftChild) &&
             this.leftChild.value === 1 &&
             opts?.scientific === undefined) {
-            return (0, colorize_1.colorize)(rightTex, color);
+            return colorize(rightTex, color);
         }
-        if ((0, operatorNode_1.isOperatorNode)(this.leftChild)) {
-            if ([operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract, operatorNode_1.OperatorIds.divide].includes(this.leftChild.id))
+        if (isOperatorNode(this.leftChild)) {
+            if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes(this.leftChild.id))
                 leftTex = `\\left(${leftTex}\\right)`;
         }
         let needBrackets = rightTex[0] === "-";
-        if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
+        if (isOperatorNode(this.rightChild)) {
             const operatorRightChild = this.rightChild;
             needBrackets ||= [
-                operatorNode_1.OperatorIds.add,
-                operatorNode_1.OperatorIds.substract,
-                operatorNode_1.OperatorIds.divide,
+                OperatorIds.add,
+                OperatorIds.substract,
+                OperatorIds.divide,
             ].includes(operatorRightChild.id);
         }
         if (needBrackets)
             rightTex = `\\left(${rightTex}\\right)`;
         if (leftTex === "-1" && !opts?.forceNoSimplification) {
             // if (!isNumberNode(this.rightChild)) {
-            return (0, colorize_1.colorize)("-" + rightTex, color);
+            return colorize("-" + rightTex, color);
             // }
         }
         //!this is atrocious
@@ -114,23 +114,23 @@ class MultiplyNode {
                 !isNaN(+rightTex[0]) ||
                 (this.rightChild.isNumeric &&
                     this.leftChild.isNumeric &&
-                    !(0, constantNode_1.isConstantNode)(this.rightChild) &&
-                    !(0, functionNode_1.isFunctionNode)(this.rightChild)) ||
-                (0, numberNode_1.isNumberNode)(this.rightChild) ||
-                ((0, variableNode_1.isVariableNode)(this.leftChild) &&
-                    (0, variableNode_1.isVariableNode)(this.rightChild) &&
+                    !isConstantNode(this.rightChild) &&
+                    !isFunctionNode(this.rightChild)) ||
+                isNumberNode(this.rightChild) ||
+                (isVariableNode(this.leftChild) &&
+                    isVariableNode(this.rightChild) &&
                     this.leftChild.name === this.rightChild.name) ||
-                ((0, sqrtNode_1.isSqrtNode)(this.leftChild) && (0, sqrtNode_1.isSqrtNode)(this.rightChild)));
-        if ((0, operatorNode_1.isOperatorNode)(this.rightChild)) {
-            showTimesSign ||= [operatorNode_1.OperatorIds.fraction].includes(this.rightChild.id);
-            if ((0, fractionNode_1.isFractionNode)(this.rightChild.leftChild)) {
+                (isSqrtNode(this.leftChild) && isSqrtNode(this.rightChild)));
+        if (isOperatorNode(this.rightChild)) {
+            showTimesSign ||= [OperatorIds.fraction].includes(this.rightChild.id);
+            if (isFractionNode(this.rightChild.leftChild)) {
                 showTimesSign = true;
             }
         }
         const cDotSign = opts?.forceDotSign ? ` \\cdot ` : "";
         const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
         const prevIsCommand = leftTex.match(/\\[a-z]*$/);
-        return (0, colorize_1.colorize)(`${leftTex}${showTimesSign
+        return colorize(`${leftTex}${showTimesSign
             ? `\\times${nextIsLetter ? " " : ""}`
             : prevIsCommand && nextIsLetter
                 ? " "
@@ -145,13 +145,13 @@ class MultiplyNode {
             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))
+        if (isOperatorNode(this.leftChild)) {
+            if ([OperatorIds.add, OperatorIds.substract, 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 (isOperatorNode(this.rightChild)) {
+            needRightBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(this.rightChild.id);
         }
         if (needRightBrackets)
             rightTex = `\\left(${rightTex}\\right)`;
@@ -160,7 +160,7 @@ class MultiplyNode {
             res.push("-" + rightTex);
             // }
         }
-        let mustShowTimesSign = !isNaN(+rightTex[0]) || (0, numberNode_1.isNumberNode)(this.rightChild);
+        let mustShowTimesSign = !isNaN(+rightTex[0]) || isNumberNode(this.rightChild);
         const nextIsLetter = rightTex[0].toLowerCase() !== rightTex[0].toUpperCase();
         res.push(`${leftTex}${`\\times${nextIsLetter ? " " : ""}`}${rightTex}`);
         if (!needRightBrackets)
@@ -180,23 +180,23 @@ class MultiplyNode {
         //!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 (isOperatorNode(node)) {
                 if (isMultiplyNode(node)) {
                     recursive(node.leftChild);
                     recursive(node.rightChild);
                 }
-                else if ((0, powerNode_1.isPowerNode)(node) &&
+                else if (isPowerNode(node) &&
                     !options?.forbidPowerToProduct &&
-                    (0, numberNode_1.isNumberNode)(node.rightChild)) {
+                    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)) {
+                    if (isNumberNode(power)) {
                         const powerNB = power.value;
-                        if ((0, isInt_1.isInt)(powerNB) && powerNB > 1) {
+                        if (isInt(powerNB) && powerNB > 1) {
                             const arr = [
-                                new powerNode_1.PowerNode(node.leftChild, node.rightChild, {
+                                new PowerNode(node.leftChild, node.rightChild, {
                                     forbidPowerToProduct: true,
                                 }),
                             ];
@@ -209,7 +209,7 @@ class MultiplyNode {
                                 }
                                 else {
                                     //powerNb-newPower nbs solos
-                                    const newPowerNode = new powerNode_1.PowerNode(node.leftChild, new numberNode_1.NumberNode(newPower), { forbidPowerToProduct: true });
+                                    const newPowerNode = new PowerNode(node.leftChild, new NumberNode(newPower), { forbidPowerToProduct: true });
                                     const nbs = Array(powerNB - newPower).fill(node.leftChild);
                                     arr.push([...nbs, newPowerNode]);
                                 }
@@ -225,18 +225,18 @@ class MultiplyNode {
                 multiplyTree.push(node);
         };
         recursive(this);
-        const multiplyCartesians = (0, cartesianProducts_1.getFlatCartesianProducts)(multiplyTree.map((el) => (Array.isArray(el) ? el : [el])));
+        const multiplyCartesians = 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);
+            let equivNodesPermutations = permute(equivNodesArr);
             equivNodesPermutations.forEach((permutation) => {
                 //4: créé les produits cartésiens des nodes equiv puis nodify
-                const cartesiansProducts = (0, cartesianProducts_1.getCartesiansProducts)(permutation);
+                const cartesiansProducts = getCartesiansProducts(permutation);
                 cartesiansProducts.forEach((product) => {
-                    res.push((0, operatorComposition_1.operatorComposition)(MultiplyNode, product));
+                    res.push(operatorComposition(MultiplyNode, product));
                 });
             });
         });
@@ -247,7 +247,7 @@ class MultiplyNode {
     }
     toIdentifiers() {
         return {
-            id: node_1.NodeIds.multiply,
+            id: NodeIds.multiply,
             leftChild: this.leftChild.toIdentifiers(),
             rightChild: this.rightChild.toIdentifiers(),
         };
@@ -277,13 +277,13 @@ class MultiplyNode {
                     recursive(node.leftChild);
                     recursive(node.rightChild);
                 }
-                else if ((0, oppositeNode_1.isOppositeNode)(node)) {
+                else if (isOppositeNode(node)) {
                     oppositesCount++;
                     recursive(node.child);
                 }
-                else if ((0, numberNode_1.isNumberNode)(node) && node.value < 0) {
+                else if (isNumberNode(node) && node.value < 0) {
                     oppositesCount++;
-                    res.push(new numberNode_1.NumberNode(Math.abs(node.value)));
+                    res.push(new NumberNode(Math.abs(node.value)));
                 }
                 else {
                     res.push(node);
@@ -291,70 +291,70 @@ class MultiplyNode {
             };
             recursive(root);
             if (oppositesCount % 2 === 1) {
-                res.unshift(new numberNode_1.NumberNode(-1));
+                res.unshift(new NumberNode(-1));
             }
             return res;
         };
         let externals = getExternalNodes(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 (externals.some((node) => isNumberNode(node) && node.value === 0)) {
+            return new NumberNode(0);
         }
         //suppression des 1
-        externals = externals.filter((node) => !(0, numberNode_1.isNumberNode)(node) || node.value !== 1);
+        externals = externals.filter((node) => !isNumberNode(node) || node.value !== 1);
         if (!externals.length)
-            return new numberNode_1.NumberNode(1);
+            return new NumberNode(1);
         if (externals.length === 1)
             return externals[0];
         //tout ca est un peu bordelique
         //forceDistributeFractions sert à avoir par exemple (a/b)*x plutot que (ax/b)
         if (!opts?.forceDistributeFractions)
-            if (externals.some((node) => (0, fractionNode_1.isFractionNode)(node))) {
+            if (externals.some((node) => 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)) {
+                    if (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);
+                if (nums.some((node) => isNumberNode(node) && node.value === 0)) {
+                    return new NumberNode(0);
                 }
-                (0, exports.sortMultiplyNodes)(nums);
-                (0, exports.sortMultiplyNodes)(denums);
-                const numNode = (0, operatorComposition_1.operatorComposition)(MultiplyNode, nums);
+                sortMultiplyNodes(nums);
+                sortMultiplyNodes(denums);
+                const numNode = 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);
+                    : operatorComposition(MultiplyNode, denums);
+                return new FractionNode(numNode, denumNode).simplify(opts);
             }
         const simplifyExternalNodes = (a, b) => {
-            if ((0, variableNode_1.isVariableNode)(a) && (0, variableNode_1.isVariableNode)(b)) {
+            if (isVariableNode(a) && isVariableNode(b)) {
                 if (a.name === b.name) {
-                    return new powerNode_1.SquareNode(a);
+                    return new SquareNode(a);
                 }
             }
-            if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
-                return new numberNode_1.NumberNode((0, round_1.round)(a.value * b.value, 12));
+            if (isNumberNode(a) && isNumberNode(b)) {
+                return new NumberNode(round(a.value * b.value, 12));
             }
-            if ((0, sqrtNode_1.isSqrtNode)(a) && (0, sqrtNode_1.isSqrtNode)(b)) {
-                return new sqrtNode_1.SqrtNode(new MultiplyNode(a.child, b.child)).simplify(opts);
+            if (isSqrtNode(a) && isSqrtNode(b)) {
+                return new SqrtNode(new MultiplyNode(a.child, b.child)).simplify(opts);
             }
-            if ((0, numberNode_1.isNumberNode)(a) &&
-                (0, powerNode_1.isPowerNode)(b) &&
-                (0, numberNode_1.isNumberNode)(b.leftChild) &&
+            if (isNumberNode(a) &&
+                isPowerNode(b) &&
+                isNumberNode(b.leftChild) &&
                 a.value === b.leftChild.value) {
-                return new powerNode_1.PowerNode(b.leftChild, new addNode_1.AddNode(b.rightChild, (1).toTree())).simplify();
+                return new PowerNode(b.leftChild, new AddNode(b.rightChild, (1).toTree())).simplify();
             }
-            if ((0, fractionNode_1.isFractionNode)(a) &&
+            if (isFractionNode(a) &&
                 a.isNumeric &&
-                (0, fractionNode_1.isFractionNode)(b) &&
+                isFractionNode(b) &&
                 b.isNumeric) {
-                return new fractionNode_1.FractionNode((0, exports.multiply)(a.leftChild, b.leftChild), (0, exports.multiply)(a.rightChild, b.rightChild)).simplify(opts);
+                return new FractionNode(multiply(a.leftChild, b.leftChild), multiply(a.rightChild, b.rightChild)).simplify(opts);
             }
             let powerSimplified = powerSimplify(a, b, opts);
             if (powerSimplified)
@@ -362,18 +362,18 @@ class MultiplyNode {
             powerSimplified = powerSimplify(b, a, opts);
             if (powerSimplified)
                 return powerSimplified;
-            if (opts?.towardsDistribute && ((0, addNode_1.isAddNode)(a) || (0, substractNode_1.isSubstractNode)(a))) {
-                return (0, addNode_1.add)((0, exports.multiply)(a.leftChild, b), (0, exports.multiply)(a.rightChild, b)).simplify(opts);
+            if (opts?.towardsDistribute && (isAddNode(a) || isSubstractNode(a))) {
+                return add(multiply(a.leftChild, b), multiply(a.rightChild, b)).simplify(opts);
             }
             else if (opts?.towardsDistribute &&
-                ((0, addNode_1.isAddNode)(b) || (0, substractNode_1.isSubstractNode)(b))) {
-                return (0, addNode_1.add)((0, exports.multiply)(a, b.leftChild), (0, exports.multiply)(a, b.rightChild)).simplify(opts);
+                (isAddNode(b) || isSubstractNode(b))) {
+                return add(multiply(a, b.leftChild), multiply(a, b.rightChild)).simplify(opts);
             }
             //! j'aime po
             //! doit etre à la fin
             //l'idée est que ici on n'a pas réussi à simplifier donc par défaut on renvoit le carré
             if (a.equals(b))
-                return new powerNode_1.SquareNode(a);
+                return new SquareNode(a);
             //TODo continue
             return null;
         };
@@ -398,7 +398,7 @@ class MultiplyNode {
                         else {
                             externals[i] = simplified;
                         }
-                        if ((0, numberNode_1.isNumberNode)(simplified) && simplified.value === 1) {
+                        if (isNumberNode(simplified) && simplified.value === 1) {
                             externals.splice(i, 1);
                         }
                         simplifyIteration();
@@ -409,11 +409,11 @@ class MultiplyNode {
         };
         simplifyIteration();
         if (!externals.length)
-            return new numberNode_1.NumberNode(1);
+            return new NumberNode(1);
         if (externals.length === 1)
             return externals[0];
-        (0, exports.sortMultiplyNodes)(externals);
-        return (0, operatorComposition_1.operatorComposition)(MultiplyNode, externals);
+        sortMultiplyNodes(externals);
+        return operatorComposition(MultiplyNode, externals);
     }
     equals(node) {
         //!incorrect, il faut plutot vérifier qu'ils ont les meme externals
@@ -428,20 +428,19 @@ class MultiplyNode {
     }
     //(uv)' = u'v + uv'
     derivative(varName) {
-        return (0, addNode_1.add)((0, exports.multiply)(this.leftChild.derivative(varName), this.rightChild), (0, exports.multiply)(this.leftChild, this.rightChild.derivative(varName)));
+        return add(multiply(this.leftChild.derivative(varName), this.rightChild), multiply(this.leftChild, this.rightChild.derivative(varName)));
     }
 }
-exports.MultiplyNode = MultiplyNode;
 const powerSimplify = (a, b, opts) => {
-    if ((0, powerNode_1.isPowerNode)(a) && (0, powerNode_1.isPowerNode)(b)) {
+    if (isPowerNode(a) && isPowerNode(b)) {
         if (a.leftChild.toTex() === b.leftChild.toTex())
-            return new powerNode_1.PowerNode(a.leftChild, new addNode_1.AddNode(a.rightChild, b.rightChild).simplify(opts)).simplify(opts);
+            return new PowerNode(a.leftChild, new AddNode(a.rightChild, b.rightChild).simplify(opts)).simplify(opts);
     }
-    if ((0, variableNode_1.isVariableNode)(a)) {
-        if ((0, variableNode_1.isVariableNode)(b) && b.toTex() === a.toTex() && opts?.keepPowers)
-            return new powerNode_1.PowerNode(a, new numberNode_1.NumberNode(2)).simplify(opts);
-        if ((0, powerNode_1.isPowerNode)(b) && b.leftChild.toTex() === a.toTex()) {
-            return new powerNode_1.PowerNode(a, new addNode_1.AddNode(new numberNode_1.NumberNode(1), b.rightChild).simplify(opts)).simplify(opts);
+    if (isVariableNode(a)) {
+        if (isVariableNode(b) && b.toTex() === a.toTex() && opts?.keepPowers)
+            return new PowerNode(a, new NumberNode(2)).simplify(opts);
+        if (isPowerNode(b) && b.leftChild.toTex() === a.toTex()) {
+            return new PowerNode(a, new AddNode(new NumberNode(1), b.rightChild).simplify(opts)).simplify(opts);
         }
     }
 };

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

@@ -1,5 +1,5 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node } from "../node";
+import { AlgebraicNode } from "../algebraicNode.js";
+import { Node } from "../node.js";
 export declare enum OperatorIds {
     add = 0,
     substract = 1,

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":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAqB,MAAM,SAAS,CAAC;AAElD,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;IACnB,MAAM,IAAA;CACP;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,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,uBAAuB,CAI9B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;CACjC,CAAC;AACF,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,uBAAuB,CAAC;IACjE,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,qBAAqB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAqB,MAAM,YAAY,CAAC;AAErD,oBAAY,WAAW;IACrB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,QAAQ,IAAA;IACR,mBAAmB,IAAA;IACnB,MAAM,IAAA;CACP;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,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,uBAAuB,CAI9B;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,gBAAgB,EAAE,WAAW,EAAE,CAAC;CACjC,CAAC;AACF,MAAM,WAAW,uBAAwB,SAAQ,YAAY;IAC3D,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,uBAAuB,CAAC;IACjE,SAAS,EAAE,MAAM,MAAM,EAAE,CAAC;CAC3B"}

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

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCommutativeOperatorNode = exports.isOperatorNode = exports.OperatorIds = void 0;
-const node_1 = require("../node");
-var OperatorIds;
+import { NodeType } from "../node.js";
+export var OperatorIds;
 (function (OperatorIds) {
     OperatorIds[OperatorIds["add"] = 0] = "add";
     OperatorIds[OperatorIds["substract"] = 1] = "substract";
@@ -14,12 +11,10 @@ var OperatorIds;
     OperatorIds[OperatorIds["integral"] = 7] = "integral";
     OperatorIds[OperatorIds["binomialCoefficient"] = 8] = "binomialCoefficient";
     OperatorIds[OperatorIds["square"] = 9] = "square";
-})(OperatorIds || (exports.OperatorIds = OperatorIds = {}));
-function isOperatorNode(a) {
-    return a.type === node_1.NodeType.operator;
+})(OperatorIds || (OperatorIds = {}));
+export function isOperatorNode(a) {
+    return a.type === NodeType.operator;
 }
-exports.isOperatorNode = isOperatorNode;
-function isCommutativeOperatorNode(a) {
+export function isCommutativeOperatorNode(a) {
     return (isOperatorNode(a) && [OperatorIds.add, OperatorIds.multiply].includes(a.id));
 }
-exports.isCommutativeOperatorNode = isCommutativeOperatorNode;

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

@@ -1,6 +1,6 @@
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { OperatorIds, OperatorNode } from "./operatorNode.js";
+import { AlgebraicNode, SimplifyOptions } from "../algebraicNode.js";
 export declare function isPowerNode(a: Node): a is PowerNode;
 export declare function isSquareNode(a: Node): a is SquareNode;
 export declare const square: (a: AlgebraicNode | number | string) => SquareNode;

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

@@ -1 +1 @@
-{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAG3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGlE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA8C/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAcxD;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}
+{"version":3,"file":"powerNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/powerNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAClE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAG9E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,eAAO,MAAM,MAAM,MAAO,aAAa,GAAG,MAAM,GAAG,MAAM,eAKxD,CAAC;AAEF,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,cAOnB,CAAC;AAEF,qBAAa,SAAU,YAAW,YAAY;IAC5C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,YAAY,IAAI,MAAM;IAGtB,aAAa;;;;;;;;;IAOb,iBAAiB;IAqBjB,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAuBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA8C/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAcxD;AAED,qBAAa,UAAW,SAAQ,SAAS;gBAC3B,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;CAIrD"}