math-exercises 2.2.98 → 3.0.2

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

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,WAAW,EAIZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAYlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IACF,WAAW,UAAW,eAAe,aAUnC;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsJ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,WAAW,EAIZ,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAerE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IACF,WAAW,UAAW,eAAe,aAUnC;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAsJ/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

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

@@ -1,56 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddNode = exports.add = exports.isAddNode = void 0;
 // import { add } 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 substractNode_1 = require("./substractNode");
-const oppositeNode_1 = require("../functions/oppositeNode");
-const numberNode_1 = require("../numbers/numberNode");
-const multiplyNode_1 = require("./multiplyNode");
-const fractionNode_1 = require("./fractionNode");
-const colorize_1 = require("../../../utils/latex/colorize");
-const round_1 = require("../../../math/utils/round");
-const monomNode_1 = require("../polynomials/monomNode");
-function isAddNode(a) {
-    return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
+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 } from "../../../utils/arrays/cartesianProducts.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { isSubstractNode } from "./substractNode.js";
+import { OppositeNode, isOppositeNode } from "../functions/oppositeNode.js";
+import { NumberNode, isNumberNode } from "../numbers/numberNode.js";
+import { MultiplyNode, isMultiplyNode } from "./multiplyNode.js";
+import { FractionNode, isFractionNode } from "./fractionNode.js";
+import { colorize } from "../../../utils/latex/colorize.js";
+import { round } from "../../../math/utils/round.js";
+import { MonomNode, isMonom, parseToMonomNode, } from "../polynomials/monomNode.js";
+export function isAddNode(a) {
+    return isOperatorNode(a) && a.id === OperatorIds.add;
 }
-exports.isAddNode = isAddNode;
-const add = (a, b) => {
+export const add = (a, b) => {
     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 AddNode(nodeA, nodeB);
 };
-exports.add = add;
-class AddNode {
+export class AddNode {
+    id;
+    leftChild;
+    rightChild;
+    type;
+    opts;
+    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 AddNode(right, left, this.opts);
-            else
-                return new AddNode(left, right, this.opts);
-        };
-        this.id = operatorNode_1.OperatorIds.add;
+        this.id = OperatorIds.add;
         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 AddNode(right, left, this.opts);
+        else
+            return new AddNode(left, right, this.opts);
+    };
     toMathString() {
         return `${this.leftChild.toMathString()} + (${this.rightChild.toMathString()})`;
     }
@@ -61,7 +62,7 @@ class AddNode {
         //ce seront des nodes qui ne sont pas des AddNode
         //1: choper le sous arbre de type Non AddNode (ie les enfants nonAddNode des AddNode)
         const recursive = (node) => {
-            if ((0, operatorNode_1.isOperatorNode)(node)) {
+            if (isOperatorNode(node)) {
                 if (isAddNode(node)) {
                     recursive(node.leftChild);
                     recursive(node.rightChild);
@@ -76,12 +77,12 @@ class AddNode {
         //2: pour tous les nodes qui ne sont pas Add, on génère les equiv node
         const equivNodesArr = addTree.map((node) => node.toEquivalentNodes(options));
         //3: créer toutes les permutations de tous kes 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)(AddNode, product));
+                res.push(operatorComposition(AddNode, product));
             });
         });
         return res;
@@ -102,13 +103,13 @@ class AddNode {
         const rightTex = this.rightChild.toTex(childOpts);
         const leftTex = this.leftChild.toTex(childOpts);
         if (rightTex === "0")
-            return (0, colorize_1.colorize)(leftTex, color);
+            return colorize(leftTex, color);
         const tex = `${leftTex}${rightTex[0] === "-" ? "" : "+"}${rightTex}`;
         if (this.opts?.forceParenthesis) {
-            return (0, colorize_1.colorize)(`\\left(${tex}\\right)`, color);
+            return colorize(`\\left(${tex}\\right)`, color);
         }
         else
-            return (0, colorize_1.colorize)(tex, color);
+            return colorize(tex, color);
     }
     evaluate(vars) {
         return this.leftChild.evaluate(vars) + this.rightChild.evaluate(vars);
@@ -128,18 +129,18 @@ class AddNode {
                 recursive(node.leftChild);
                 recursive(node.rightChild);
             }
-            else if ((0, substractNode_1.isSubstractNode)(node)) {
+            else if (isSubstractNode(node)) {
                 recursive(node.leftChild);
-                recursive(new oppositeNode_1.OppositeNode(node.rightChild));
+                recursive(new OppositeNode(node.rightChild));
             }
             else {
                 externals.push(node);
             }
         };
         recursive(copy);
-        externals = externals.filter((node) => !(0, numberNode_1.isNumberNode)(node) || node.value !== 0);
+        externals = externals.filter((node) => !isNumberNode(node) || node.value !== 0);
         if (!externals.length)
-            return new numberNode_1.NumberNode(0);
+            return new NumberNode(0);
         if (externals.length === 1)
             return externals[0];
         const simplifyExternalNodes = (a, b) => {
@@ -165,13 +166,13 @@ class AddNode {
             const aSubExternals = [];
             const bSubExternals = [];
             const getAMultiplyExternals = (a) => {
-                if ((0, multiplyNode_1.isMultiplyNode)(a)) {
+                if (isMultiplyNode(a)) {
                     getAMultiplyExternals(a.leftChild);
                     getAMultiplyExternals(a.rightChild);
                 }
-                else if ((0, oppositeNode_1.isOppositeNode)(a)) {
+                else if (isOppositeNode(a)) {
                     //on transofmre les opposites en -1
-                    aSubExternals.push(new numberNode_1.NumberNode(-1));
+                    aSubExternals.push(new NumberNode(-1));
                     getAMultiplyExternals(a.child);
                 }
                 else {
@@ -179,13 +180,13 @@ class AddNode {
                 }
             };
             const getBMultiplyExternals = (b) => {
-                if ((0, multiplyNode_1.isMultiplyNode)(b)) {
+                if (isMultiplyNode(b)) {
                     getBMultiplyExternals(b.leftChild);
                     getBMultiplyExternals(b.rightChild);
                 }
-                else if ((0, oppositeNode_1.isOppositeNode)(b)) {
+                else if (isOppositeNode(b)) {
                     //on transofmre les opposites en -1
-                    bSubExternals.push(new numberNode_1.NumberNode(-1));
+                    bSubExternals.push(new NumberNode(-1));
                     getBMultiplyExternals(b.child);
                 }
                 else {
@@ -222,20 +223,20 @@ class AddNode {
                 return null;
             const factorsNode = factors.length === 1
                 ? factors[0]
-                : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, factors);
+                : operatorComposition(MultiplyNode, factors);
             // if (!aSubExternals.length && !bSubExternals.length) return factorsNode;
             const aNode = aSubExternals.length === 0
-                ? new numberNode_1.NumberNode(1)
+                ? new NumberNode(1)
                 : aSubExternals.length === 1
                     ? aSubExternals[0]
-                    : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, aSubExternals);
+                    : operatorComposition(MultiplyNode, aSubExternals);
             const bNode = bSubExternals.length === 0
-                ? new numberNode_1.NumberNode(1)
+                ? new NumberNode(1)
                 : bSubExternals.length === 1
                     ? bSubExternals[0]
-                    : (0, operatorComposition_1.operatorComposition)(multiplyNode_1.MultiplyNode, bSubExternals);
+                    : operatorComposition(MultiplyNode, bSubExternals);
             const addNode = new AddNode(aNode, bNode);
-            return new multiplyNode_1.MultiplyNode(addNode, factorsNode).simplify();
+            return new MultiplyNode(addNode, factorsNode).simplify();
         };
         let counter = 0;
         //pour chaque paire on essaye de simplifier,
@@ -252,7 +253,7 @@ class AddNode {
                     if (simplified) {
                         externals[i] = simplified;
                         externals.splice(j, 1);
-                        if ((0, numberNode_1.isNumberNode)(simplified) && simplified.value === 0) {
+                        if (isNumberNode(simplified) && simplified.value === 0) {
                             externals.splice(i, 1);
                         }
                         simplifyIteration();
@@ -263,14 +264,14 @@ class AddNode {
         };
         simplifyIteration();
         if (!externals.length)
-            return new numberNode_1.NumberNode(0);
+            return new NumberNode(0);
         if (externals.length === 1)
             return externals[0];
-        return (0, operatorComposition_1.operatorComposition)(AddNode, externals.sort(addSort));
+        return operatorComposition(AddNode, externals.sort(addSort));
     }
     toIdentifiers() {
         return {
-            id: node_1.NodeIds.add,
+            id: NodeIds.add,
             leftChild: this.leftChild.toIdentifiers(),
             rightChild: this.rightChild.toIdentifiers(),
         };
@@ -287,18 +288,17 @@ class AddNode {
         return new AddNode(this.leftChild.toDetailedEvaluation(vars), this.rightChild.toDetailedEvaluation(vars));
     }
     derivative(varName) {
-        return (0, exports.add)(this.leftChild.derivative(varName), this.rightChild.derivative(varName));
+        return add(this.leftChild.derivative(varName), this.rightChild.derivative(varName));
     }
 }
-exports.AddNode = AddNode;
 const addSort = (a, b) => {
     //! this is super risky,
     if (a.isNumeric !== b.isNumeric) {
         return Number(a.isNumeric) - Number(b.isNumeric);
     }
-    if ((0, monomNode_1.isMonom)(a) && (0, monomNode_1.isMonom)(b)) {
-        const parsedA = (0, monomNode_1.parseToMonomNode)(a);
-        const parsedB = (0, monomNode_1.parseToMonomNode)(b);
+    if (isMonom(a) && isMonom(b)) {
+        const parsedA = parseToMonomNode(a);
+        const parsedB = parseToMonomNode(b);
         if (parsedA && parsedB) {
             return Number(parsedB.degree) - Number(parsedA.degree);
         }
@@ -306,112 +306,112 @@ const addSort = (a, b) => {
     return 0;
 };
 const addSimplifyFrac = (a, b, opts) => {
-    if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a) && (0, fractionNode_1.isFractionNode)(b)) {
+    if (!opts?.towardsDistribute && isFractionNode(a) && isFractionNode(b)) {
         //c/d + e/f   =  cf+ed / df
         const c = a.leftChild;
         const d = a.rightChild;
         const e = b.leftChild;
         const f = b.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+        return new FractionNode(new AddNode(new MultiplyNode(c, f), new MultiplyNode(e, d)), new MultiplyNode(d, f)).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, oppositeNode_1.isOppositeNode)(a) &&
-        (0, fractionNode_1.isFractionNode)(a.child) &&
-        (0, fractionNode_1.isFractionNode)(b)) {
+        isOppositeNode(a) &&
+        isFractionNode(a.child) &&
+        isFractionNode(b)) {
         //-(c/d) + e/f   =  -cf+ed / df
         const c = a.child.leftChild;
         const d = a.child.rightChild;
         const e = b.leftChild;
         const f = b.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(e, d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+        return new FractionNode(new AddNode(new MultiplyNode(new OppositeNode(c), f), new MultiplyNode(e, d)), new MultiplyNode(d, f)).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, oppositeNode_1.isOppositeNode)(b) &&
-        (0, fractionNode_1.isFractionNode)(b.child) &&
-        (0, fractionNode_1.isFractionNode)(a)) {
+        isOppositeNode(b) &&
+        isFractionNode(b.child) &&
+        isFractionNode(a)) {
         //(c/d) + (-e/f)   =  cf-ed / df
         const c = a.leftChild;
         const d = a.rightChild;
         const e = b.child.leftChild;
         const f = b.child.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(c, f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+        return new FractionNode(new AddNode(new MultiplyNode(c, f), new MultiplyNode(new OppositeNode(e), d)), new MultiplyNode(d, f)).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, oppositeNode_1.isOppositeNode)(b) &&
-        (0, fractionNode_1.isFractionNode)(b.child) &&
-        (0, oppositeNode_1.isOppositeNode)(a) &&
-        (0, fractionNode_1.isFractionNode)(a.child)) {
+        isOppositeNode(b) &&
+        isFractionNode(b.child) &&
+        isOppositeNode(a) &&
+        isFractionNode(a.child)) {
         //-(c/d) + (-e/f)   =  -cf-ed / df
         const c = a.child.leftChild;
         const d = a.child.rightChild;
         const e = b.child.leftChild;
         const f = b.child.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(c), f), new multiplyNode_1.MultiplyNode(new oppositeNode_1.OppositeNode(e), d)), new multiplyNode_1.MultiplyNode(d, f)).simplify(opts);
+        return new FractionNode(new AddNode(new MultiplyNode(new OppositeNode(c), f), new MultiplyNode(new OppositeNode(e), d)), new MultiplyNode(d, f)).simplify(opts);
     }
-    if (!opts?.towardsDistribute && (0, fractionNode_1.isFractionNode)(a)) {
+    if (!opts?.towardsDistribute && isFractionNode(a)) {
         //c/d + b
         const c = a.leftChild;
         const d = a.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
+        return new FractionNode(new AddNode(c, new MultiplyNode(d, b)), d).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, oppositeNode_1.isOppositeNode)(a) &&
-        (0, fractionNode_1.isFractionNode)(a.child)) {
+        isOppositeNode(a) &&
+        isFractionNode(a.child)) {
         //-(c/d) + b = (-c+bd)/d
         const c = a.child.leftChild;
         const d = a.child.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, b)), d).simplify(opts);
+        return new FractionNode(new AddNode(new OppositeNode(c), new MultiplyNode(d, b)), d).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, fractionNode_1.isFractionNode)(b) &&
+        isFractionNode(b) &&
         !opts?.forceDistributeFractions) {
         //a+c/d
         const c = b.leftChild;
         const d = b.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(c, new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
+        return new FractionNode(new AddNode(c, new MultiplyNode(d, a)), d).simplify(opts);
     }
     if (!opts?.towardsDistribute &&
-        (0, oppositeNode_1.isOppositeNode)(b) &&
-        (0, fractionNode_1.isFractionNode)(b.child) &&
+        isOppositeNode(b) &&
+        isFractionNode(b.child) &&
         !opts?.forceDistributeFractions) {
         //a+-(c/d) = (da-c)/d
         const c = b.child.leftChild;
         const d = b.child.rightChild;
-        return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
+        return new FractionNode(new AddNode(new OppositeNode(c), new MultiplyNode(d, a)), d).simplify(opts);
     }
 };
 const addSimplifyNumbers = (a, b, opts) => {
-    if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
+    if (isNumberNode(a) && isNumberNode(b)) {
         //geogebra rounds to 12, il faut mettre <12
-        return new numberNode_1.NumberNode((0, round_1.round)(a.value + b.value, 10));
+        return new NumberNode(round(a.value + b.value, 10));
     }
-    if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
-        return new numberNode_1.NumberNode(-a.child.value + b.value);
+    if (isOppositeNode(a) && isNumberNode(a.child) && isNumberNode(b)) {
+        return new NumberNode(-a.child.value + b.value);
     }
-    if ((0, oppositeNode_1.isOppositeNode)(b) && (0, numberNode_1.isNumberNode)(b.child) && (0, numberNode_1.isNumberNode)(a)) {
-        return new numberNode_1.NumberNode(-b.child.value + a.value);
+    if (isOppositeNode(b) && isNumberNode(b.child) && isNumberNode(a)) {
+        return new NumberNode(-b.child.value + a.value);
     }
-    if ((0, oppositeNode_1.isOppositeNode)(a) &&
-        (0, numberNode_1.isNumberNode)(a.child) &&
-        (0, oppositeNode_1.isOppositeNode)(b) &&
-        (0, numberNode_1.isNumberNode)(b.child)) {
-        return new numberNode_1.NumberNode(a.child.value + b.child.value);
+    if (isOppositeNode(a) &&
+        isNumberNode(a.child) &&
+        isOppositeNode(b) &&
+        isNumberNode(b.child)) {
+        return new NumberNode(a.child.value + b.child.value);
     }
 };
 const addSimplifyMonoms = (a, b, opts) => {
-    const aMonom = (0, monomNode_1.parseToMonomNode)(a);
+    const aMonom = parseToMonomNode(a);
     if (!aMonom)
         return;
-    const bMonom = (0, monomNode_1.parseToMonomNode)(b);
+    const bMonom = parseToMonomNode(b);
     if (!bMonom)
         return;
     if (aMonom.degree === bMonom.degree) {
         if (aMonom.variable !== bMonom.variable)
             return;
-        const sum = (0, exports.add)(aMonom.a, bMonom.a).simplify(opts);
+        const sum = add(aMonom.a, bMonom.a).simplify(opts);
         if (sum.evaluate() === 0)
-            return new numberNode_1.NumberNode(0);
-        return new monomNode_1.MonomNode(sum, aMonom.degree, {
+            return new NumberNode(0);
+        return new MonomNode(sum, aMonom.degree, {
             variable: aMonom.variable,
         });
     }

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

@@ -1,6 +1,6 @@
-import { AlgebraicNode } from "../algebraicNode";
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
+import { AlgebraicNode } from "../algebraicNode.js";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { OperatorIds, OperatorNode } from "./operatorNode.js";
 export declare const isBinomialCoefficientNode: (a: Node) => a is BinomialCoefficientNode;
 export declare class BinomialCoefficientNode implements OperatorNode {
     opts?: NodeOptions;

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

@@ -1 +1 @@
-{"version":3,"file":"binomialCoefficientNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/binomialCoefficientNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAmB,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAgB,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAE3E,eAAO,MAAM,yBAAyB,MACjC,IAAI,iCAEsD,CAAC;AAEhE,qBAAa,uBAAwB,YAAW,YAAY;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IASpB,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,QAAQ;IAGR,QAAQ;IAGR,cAAc;IAGd,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,iBAAiB;IAGjB,aAAa;;;;;;;;;IAOb,YAAY;IAGZ,KAAK;IAGL,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"binomialCoefficientNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/binomialCoefficientNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAmB,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAgB,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,mBAAmB,CAAC;AAE9E,eAAO,MAAM,yBAAyB,MACjC,IAAI,KACN,CAAC,IAAI,uBACuD,CAAC;AAEhE,qBAAa,uBAAwB,YAAW,YAAY;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,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;IASpB,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,QAAQ;IAGR,QAAQ;IAGR,cAAc;IAGd,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,iBAAiB;IAGjB,aAAa;;;;;;;;;IAOb,YAAY;IAGZ,KAAK;IAGL,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -1,27 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinomialCoefficientNode = exports.isBinomialCoefficientNode = void 0;
-const combination_1 = require("../../../math/utils/combinatorics/combination");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-const isBinomialCoefficientNode = (a) => (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.binomialCoefficient;
-exports.isBinomialCoefficientNode = isBinomialCoefficientNode;
-class BinomialCoefficientNode {
+import { combinations } from "../../../math/utils/combinatorics/combination.js";
+import { NodeIds, NodeType } from "../node.js";
+import { OperatorIds, isOperatorNode } from "./operatorNode.js";
+export const isBinomialCoefficientNode = (a) => isOperatorNode(a) && a.id === OperatorIds.binomialCoefficient;
+export class BinomialCoefficientNode {
+    opts;
+    /**
+     * @param leftChild num
+     * @param rightChild denum
+     */
+    id;
+    leftChild;
+    rightChild;
+    type;
+    isNumeric;
     constructor(leftChild, rightChild, opts) {
-        this.id = operatorNode_1.OperatorIds.binomialCoefficient;
+        this.id = OperatorIds.binomialCoefficient;
         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;
     }
     equals(node) {
-        return ((0, exports.isBinomialCoefficientNode)(node) &&
+        return (isBinomialCoefficientNode(node) &&
             this.leftChild.equals(node.leftChild) &&
             this.rightChild.equals(node.rightChild));
     }
     evaluate() {
-        return (0, combination_1.combinations)(this.rightChild.evaluate(), this.leftChild.evaluate());
+        return combinations(this.rightChild.evaluate(), this.leftChild.evaluate());
     }
     simplify() {
         return this;
@@ -39,7 +45,7 @@ class BinomialCoefficientNode {
         return {
             leftChild: this.leftChild.toIdentifiers(),
             rightChild: this.rightChild.toIdentifiers(),
-            id: node_1.NodeIds.binomialCoefficient,
+            id: NodeIds.binomialCoefficient,
         };
     }
     toMathString() {
@@ -52,4 +58,3 @@ class BinomialCoefficientNode {
         throw new Error("unimplemented derivative");
     }
 }
-exports.BinomialCoefficientNode = BinomialCoefficientNode;

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

@@ -1,6 +1,6 @@
-import { Node, NodeIds, NodeOptions, NodeType } from "../node";
-import { OperatorIds, OperatorNode } from "./operatorNode";
-import { AlgebraicNode } from "../algebraicNode";
+import { Node, NodeIds, NodeOptions, NodeType } from "../node.js";
+import { OperatorIds, OperatorNode } from "./operatorNode.js";
+import { AlgebraicNode } from "../algebraicNode.js";
 export declare function isDivideNode(a: Node): a is DivideNode;
 export declare const divide: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => DivideNode;
 export declare class DivideNode implements OperatorNode {

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

@@ -1 +1 @@
-{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.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;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,eAAO,MAAM,MAAM,MACd,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,eAOnB,CAAC;AA4BF,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAGtB,kBAAkB;IAIlB,aAAa;;;;;;;;;IAQb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,OAAO,aAGL;CACH"}
+{"version":3,"file":"divideNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/divideNode.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;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AAED,eAAO,MAAM,MAAM,MACd,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,eAOnB,CAAC;AA4BF,qBAAa,UAAW,YAAW,YAAY;IAC7C,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;gBAES,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa;IAQ/D,YAAY,IAAI,MAAM;IAGtB,kBAAkB;IAIlB,aAAa;;;;;;;;;IAQb,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAYpC,cAAc,IAAI,MAAM,EAAE;IAI1B,KAAK,IAAI,MAAM;IAGf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ;IAGR,MAAM,CAAC,IAAI,EAAE,aAAa;IAO1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;IAGvD,OAAO,aAGL;CACH"}