math-exercises 3.0.188 → 3.0.189

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js

@@ -0,0 +1,173 @@
+import { RandomVariable } from "../../../../../math/probability/randomVariable.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { binom } from "../../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { pluralize } from "../../../../../utils/strings/pluralize.js";
+const getUrneRandomParams = () => {
+    const [b, r, n] = randTupleInt(3, {
+        from: 1,
+        to: 5,
+        allDifferent: false,
+    });
+    const [gb, gr] = randTupleInt(2, {
+        from: 1,
+        to: 10,
+        allDifferent: true,
+    });
+    const gn = randint(-10, 0);
+    return { b, r, n, gb, gr, gn };
+};
+const getUrneSituation = (params) => {
+    const { b, r, n, gb, gr, gn } = params;
+    return {
+        getContext: () => {
+            const getWord = (g) => g > 0 ? `rapporte $${g}\\ €$` : `fait perdre $${Math.abs(g)}\\ €$`;
+            return `Une urne contient $${b}$ ${pluralize("boule", b)} ${pluralize("blanche", b)}, $${r}$ ${pluralize("boule", r)} ${pluralize("rouge", r)} et $${n}$ ${pluralize("boule", r)} ${pluralize("noire", n)}. On tire au hasard une boule de l'urne. Tirer une boule blanche ${getWord(gb)}, une boule rouge ${getWord(gr)} et une boule noire ${getWord(gn)}. La variable aléatoire $X$ associe à chaque tirage le gain algébrique du joueur.`;
+        },
+        getVA: () => {
+            const total = b + r + n;
+            const sorted = [
+                { gain: gb, eff: b },
+                { gain: gr, eff: r },
+                { gain: gn, eff: r },
+            ].sort((a, b) => a.gain - b.gain);
+            return new RandomVariable(sorted.map((s) => s.gain), sorted.map((s) => frac(s.eff, total).simplify()));
+        },
+    };
+};
+const getCoinRandomParams = () => {
+    const n = 2;
+    let a, b;
+    do {
+        a = randint(1, 10);
+        b = randint(1, 10);
+    } while (2 * a === a - b || -2 * b === a - b);
+    return { a, b, n };
+};
+const getCoinSituation = (params) => {
+    const { a, b, n } = params;
+    return {
+        getContext: () => {
+            return `On lance $${n}$ fois d'affilée une pièce de monnaie bien équilibrée. Chaque pile rapporte $${a}$ ${pluralize("point", a)} et chaque face fait perdre $${b}$ ${pluralize("point", b)}. La variable aléatoire $X$ associe à chaque tirage le gain algébrique du joueur.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            const values = [];
+            const probas = [];
+            for (let i = 0; i < n + 1; i++) {
+                const value = (a + b) * i - n * b;
+                values.push(value);
+                probas.push(multiply(binom(n, i), power(frac(1, 2), n)).simplify());
+            }
+            return new RandomVariable(values, probas);
+        },
+    };
+};
+const getDiceMultipleRandomParams = () => {
+    const n = 6;
+    const winningMultiple = random([2, 3]);
+    const gain = randint(1, 10);
+    const loss = randint(1, 10);
+    return { n, gain, loss, winningMultiple };
+};
+const getDiceMultipleSituation = (params) => {
+    const { gain, loss, n, winningMultiple } = params;
+    return {
+        getContext: () => {
+            return `Un jeu consiste à lancer un dé bien équilibré à $${n}$ faces. On gagne $${gain}\\ €$ si on obtient un multiple de $${winningMultiple}$, et on perd $${loss}\\ €$ sinon.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            const values = [-loss, gain];
+            let multiples = 0;
+            for (let i = 2; i <= n; i++) {
+                if (i % winningMultiple === 0) {
+                    multiples++;
+                }
+            }
+            return new RandomVariable(values, [
+                frac(n - multiples, n).simplify(),
+                frac(multiples, n).simplify(),
+            ]);
+        },
+    };
+};
+const getCardsRandomParams = () => {
+    const gAs = randint(5, 10);
+    const gFigure = randint(1, gAs);
+    const gOther = randint(-10, 0);
+    return { gAs, gFigure, gOther };
+};
+const getCardsSituation = (params) => {
+    const { gAs, gFigure, gOther } = params;
+    return {
+        getContext: () => {
+            return `Un jeu consiste à tirer au hasard une carte dans un jeu de $52$ cartes. Si on tire un as, on gagne $${gAs}\\ €$; si on tire une figure, on gagne $${gFigure}\\ €$; dans les autres cas, on perd $${Math.abs(gOther)}\\ €$.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            return new RandomVariable([gOther, gFigure, gAs], [frac(52 - 16, 52).simplify(), frac(12, 52).simplify(), frac(1, 13)]);
+        },
+    };
+};
+// | (DiceSumParams & { id: "diceSum" });
+export const getRandomVariableSituation = (params) => {
+    switch (params.id) {
+        case "coin":
+            return getCoinSituation(params);
+        case "urne":
+            return getUrneSituation(params);
+        case "diceMultiple":
+            return getDiceMultipleSituation(params);
+        case "cards":
+            return getCardsSituation(params);
+        // case "diceSum":
+        //   return getDiceSumSituation(params);
+    }
+};
+export const buildRandomVariableSituation = () => {
+    const id = random(["urne", "coin", "diceMultiple", "cards"]);
+    switch (id) {
+        case "coin":
+            return { ...getCoinRandomParams(), id: "coin" };
+        case "urne":
+            return { ...getUrneRandomParams(), id: "urne" };
+        case "diceMultiple":
+            return { ...getDiceMultipleRandomParams(), id: "diceMultiple" };
+        case "cards":
+            return { ...getCardsRandomParams(), id: "cards" };
+        // case "diceSum":
+        //   return { ...getDiceSumRandomParams(), id: "diceSum" };
+    }
+};
+// {
+//   //param nbFaces; g_2, g_3, g_4, g_5, g_6
+//   label:
+//     "On lance un dé équilibré à 12 faces (ou 4 ou 6 ou 20. Paramétrable ?). On gagne g_2€ pour chaque multiple de 2, g_3€ pour chaque multiples de 3 ... g_6€ pour chaque multiple de 6. Les gains sont cumulables. X donne le gain total du joueur.",
+// },
+// {
+//   //param b;r , gb;gr
+//   label:
+//     "Une urne contient b boules rouges blanches et r boules rouges. On tire deux boules successivement et avec remise (ou sans remise : paramétrable). Une boule rouge rapporte x points, une boule noire en fait perdre y. La varialbe aléatoire X associe à chaque tirage le est le gain algébrique du joueur.",
+// },
+// {
+// },
+// {
+//   label:
+//     ,
+// },
+// {
+//   label:
+//     "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la différence des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+// },
+// {
+//   label:
+//     "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la CL... des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+// },

package/lib/exercises/math/python/list/pyListMutationMix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pyListMutationMix.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListMutationMix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AAsbF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"pyListMutationMix.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListMutationMix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AAoaF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/math/python/list/pyListMutationMix.js

@@ -265,21 +265,26 @@ const getPropositions = (n, { answer, ...identifiers }) => {
         };
         return getAnswer(identifiersWrong);
     }
+    function checkAndTryToAddWrongProp(str) {
+        if (!str.includes("undefined")) {
+            tryToAddWrongProp(propositions, codifyChunk(str), "raw");
+        }
+    }
     //indexAsked-1
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index - 1)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => index - 1));
     }
     //indexAsked+1
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index + 1)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => index + 1));
     }
     //student: lst[index]=value -> lst[value]=index
     if (typeof value === "number") {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong(() => value, () => index)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong(() => value, () => index));
     }
     //-indexAsked
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => -index)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => -index));
     }
     //append
     {
@@ -289,13 +294,13 @@ const getPropositions = (n, { answer, ...identifiers }) => {
                 return { ...instruction, type: "append" };
             }),
         };
-        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+        checkAndTryToAddWrongProp(getAnswer(identifiersWrong));
     }
     //filler
     {
         propWhile(propositions, n, () => {
             const identifiersWrong = createRandomIdentifiers();
-            tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+            checkAndTryToAddWrongProp(getAnswer(identifiersWrong));
         });
     }
     return shuffleProps(propositions, n);

package/lib/index.d.ts

@@ -1341,15 +1341,6 @@ declare const mathExercises: (Exercise<{
 }, {
     parameter: string;
 }> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
     trinomial: number[];
     leftbound: number;
     rightbound: number;
@@ -1358,10 +1349,6 @@ declare const mathExercises: (Exercise<{
     xB: number;
     yA: number;
     yB: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    situationIndex: number;
-    initial: number;
-    growth: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     correctA: number;
     correctB: number;
@@ -1430,6 +1417,39 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    id: string;
+    situationIndex: number;
+    initial: number;
+    growth: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationId: string;
+    initial: number;
+    growth: number;
+    x: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationId: string;
+    initial: number;
+    growth: number;
+    y: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    growth: number;
+    situationId: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    growth: number;
+    situationId: string;
+    threshold: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -3287,23 +3307,23 @@ declare const mathExercises: (Exercise<{
     probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     intervalIds: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-    xi: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, {
     averageFormulation: string;
 }> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+    xi: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
     initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     pValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tree/utilities/nodeUtils.d.ts

@@ -1,6 +1,8 @@
 import { AlgebraicNode } from "../nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../nodes/nodeConstructor.js";
 export declare abstract class NodeUtils {
     static getDepth: <T extends AlgebraicNode>(algebraicNode: T) => number;
     static getChildren(algebraicNode: AlgebraicNode): AlgebraicNode[];
+    static getStrCodeForNodeIdentifiers(nodeIdentifiers: NodeIdentifiers): string;
 }
 //# sourceMappingURL=nodeUtils.d.ts.map

package/lib/tree/utilities/nodeUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeUtils.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D,8BAAsB,SAAS;IAC7B,MAAM,CAAC,QAAQ,GAAI,CAAC,SAAS,aAAa,EAAE,eAAe,CAAC,KAAG,MAAM,CASnE;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;CAShD"}
+{"version":3,"file":"nodeUtils.d.ts","sourceRoot":"","sources":["../../../src/tree/utilities/nodeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG1D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAG9D,8BAAsB,SAAS;IAC7B,MAAM,CAAC,QAAQ,GAAI,CAAC,SAAS,aAAa,EAAE,eAAe,CAAC,KAAG,MAAM,CASnE;IAEF,MAAM,CAAC,WAAW,CAAC,aAAa,EAAE,aAAa;IAU/C,MAAM,CAAC,4BAA4B,CACjC,eAAe,EAAE,eAAe,GAC/B,MAAM;CA2CV"}

package/lib/tree/utilities/nodeUtils.js

@@ -1,4 +1,5 @@
 import { isFunctionNode } from "../nodes/functions/functionNode.js";
+import { NodeIds } from "../nodes/node.js";
 import { isOperatorNode } from "../nodes/operators/operatorNode.js";
 export class NodeUtils {
     static getDepth = (algebraicNode) => {
@@ -21,4 +22,43 @@ export class NodeUtils {
             return [];
         }
     }
+    static getStrCodeForNodeIdentifiers(nodeIdentifiers) {
+        const nodeId = nodeIdentifiers.id;
+        switch (nodeId) {
+            case NodeIds.add:
+            case NodeIds.substract:
+            case NodeIds.multiply:
+            case NodeIds.fraction:
+            case NodeIds.divide:
+            case NodeIds.power: {
+                const strCodeOp = (() => {
+                    switch (nodeId) {
+                        case NodeIds.add:
+                            return "add";
+                        case NodeIds.substract:
+                            return "substract";
+                        case NodeIds.multiply:
+                            return "multiply";
+                        case NodeIds.fraction:
+                            return "frac";
+                        case NodeIds.divide:
+                            return "divide";
+                        case NodeIds.power:
+                            return "power";
+                    }
+                })();
+                const [strCodeNodeLeft, strCodeNodeRight] = [
+                    nodeIdentifiers.leftChild,
+                    nodeIdentifiers.rightChild,
+                ].map((nodeIdentifiers) => this.getStrCodeForNodeIdentifiers(nodeIdentifiers));
+                return `${strCodeOp}(${strCodeNodeLeft},${strCodeNodeRight})`;
+            }
+            case NodeIds.number:
+                return nodeIdentifiers.value;
+            case NodeIds.variable:
+                return `new VariableNode("${nodeIdentifiers.name}")`;
+            default:
+                throw new Error("Unsupported nodeId: " + nodeId);
+        }
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.188",
+  "version": "3.0.189",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [