math-exercises 2.2.66 → 2.2.68

package/lib/exercises/math/probaStat/probabilityTree.js

@@ -1,72 +1,181 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probabilityTree = void 0;
+const rationalVEA_1 = require("../../../exercises/vea/rationalVEA");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const gcd_1 = require("../../../math/utils/arithmetic/gcd");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const latexParser_1 = require("../../../tree/parsers/latexParser");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const random_1 = require("../../../utils/alea/random");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-const getAnswerNode = ({ type, A, B, AC, AD, BC, BD }) => {
-    const pA = (0, fractionNode_1.frac)(A, A + B);
-    const pB = (0, fractionNode_1.frac)(B, A + B);
-    const pA_C = (0, fractionNode_1.frac)(AC, AC + AD);
-    const pA_D = (0, fractionNode_1.frac)(AD, AC + AD);
-    const pB_C = (0, fractionNode_1.frac)(BC, BC + BD);
-    const pB_D = (0, fractionNode_1.frac)(BD, BC + BD);
-    switch (type) {
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (oldIdentifiers.probaName)
+        return oldIdentifiers;
+    const ABTotal = oldIdentifiers.A + oldIdentifiers.B;
+    const ASubTotal = oldIdentifiers.AC + oldIdentifiers.AD;
+    const BSubTotal = oldIdentifiers.BC + oldIdentifiers.BD;
+    let probaName = "";
+    switch (oldIdentifiers.type) {
         case 1:
-            return (0, multiplyNode_1.multiply)(pA, pA_C).simplify();
+            probaName = "P(A\\cap C)";
+            break;
         case 2:
-            return (0, multiplyNode_1.multiply)(pA, pA_D).simplify();
+            probaName = "P(A\\cap D)";
+            break;
         case 3:
-            return (0, multiplyNode_1.multiply)(pB, pB_C).simplify();
+            probaName = "P(B\\cap C)";
+            break;
         case 4:
+            probaName = "P(B\\cap D)";
+            break;
+    }
+    return {
+        probaName,
+        A: (0, fractionNode_1.frac)(oldIdentifiers.A, ABTotal).simplify().toIdentifiers(),
+        B: (0, fractionNode_1.frac)(oldIdentifiers.B, ABTotal).simplify().toIdentifiers(),
+        AC: (0, fractionNode_1.frac)(oldIdentifiers.AC, ASubTotal).simplify().toIdentifiers(),
+        AD: (0, fractionNode_1.frac)(oldIdentifiers.AD, ASubTotal).simplify().toIdentifiers(),
+        BC: (0, fractionNode_1.frac)(oldIdentifiers.BC, BSubTotal).simplify().toIdentifiers(),
+        BD: (0, fractionNode_1.frac)(oldIdentifiers.BD, BSubTotal).simplify().toIdentifiers(),
+    };
+};
+const optionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
+];
+const defaultOptionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+];
+const buildAll = (identifiers) => {
+    return {
+        pA: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.A),
+        pAC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AC),
+        pAD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AD),
+        pB: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.B),
+        pBC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BC),
+        pBD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BD),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const probas = buildAll(identifiers);
+    switch (identifiers.probaName) {
+        case "P(A)":
+            return probas.pA;
+        case "P(B)":
+            return probas.pB;
+        case "P(A\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAC).simplify();
+        case "P(A\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAD).simplify();
+        case "P(B\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBC).simplify();
+        case "P(B\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBD).simplify();
+        case "P_A(C)":
+            return probas.pAC;
+        case "P_A(D)":
+            return probas.pAD;
+        case "P_B(C)":
+            return probas.pBC;
+        case "P_B(D)":
+            return probas.pBD;
+        case "P(C)":
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAC), (0, multiplyNode_1.multiply)(probas.pB, probas.pBC)).simplify();
+        case "P(D)":
         default:
-            return (0, multiplyNode_1.multiply)(pB, pB_D).simplify();
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAD), (0, multiplyNode_1.multiply)(probas.pB, probas.pBD)).simplify();
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, options) => {
+    let instr = `On considère l'arbre de probabilités ci-dessous. Calculer : 
+  
+$$
+${identifiers.probaName}
+$$`;
+    if (options?.allowApproximate) {
+        instr += `
+
+Donner la valeur exacte ou une valeur arrondie au ${options.allowApproximate}.`;
+    }
+    return instr;
+};
+const getProbaAndOpposite = (decimal = false) => {
+    if (!decimal) {
+        const proba = rational_1.RationalConstructor.randomIrreductibleProba().toTree();
+        return [proba, (0, substractNode_1.substract)(1, proba).simplify()];
+    }
+    else {
+        const proba = (0, round_1.round)((0, randfloat_1.randfloat)(0.01, 1, 2), 2);
+        return [proba.toTree(), (0, round_1.round)(1 - proba, 2).toTree()];
     }
 };
 const getProbabilityTree = (opts) => {
-    const A = (0, randint_1.randint)(2, 9);
-    const B = (0, randint_1.randint)(2, 10 - A);
-    const AC = (0, randint_1.randint)(2, 9);
-    const AD = (0, randint_1.randint)(2, 10 - AC);
-    const BC = (0, randint_1.randint)(2, 9);
-    const BD = (0, randint_1.randint)(2, 10 - BC);
-    let instruction = `En utilisant l'arbre de probabilité suivant, `;
-    let startStatement = "";
-    const type = (0, randint_1.randint)(1, 5);
-    const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-    const answerTex = answer.toTex();
-    switch (type) {
-        case 1: {
-            instruction += `calculer $P(A \\cap C)$.`;
-            startStatement = `P(A \\cap C)`;
+    const isDecimal = opts?.probaType === "Décimales";
+    const [pA, pB] = getProbaAndOpposite(isDecimal);
+    const [pC_A, pD_A] = getProbaAndOpposite(isDecimal);
+    const [pC_B, pD_B] = getProbaAndOpposite(isDecimal);
+    const eventTypes = opts?.eventTypes?.length
+        ? opts.eventTypes
+        : defaultOptionValues;
+    const type = (0, random_1.random)(eventTypes);
+    const index = optionValues.indexOf(type);
+    let probaName = "";
+    switch (index) {
+        case 0: //inter
+            probaName = (0, random_1.random)([
+                "P(A\\cap C)",
+                "P(A\\cap D)",
+                "P(B\\cap C)",
+                "P(B\\cap D)",
+            ]);
             break;
-        }
-        case 2: {
-            instruction += `calculer $P(A \\cap D)$.`;
-            startStatement = `P(A \\cap D)`;
+        case 1: //totale
+            probaName = (0, random_1.random)(["P(C)", "P(D)"]);
             break;
-        }
-        case 3: {
-            instruction += `calculer $P(B \\cap C)$.`;
-            startStatement = `P(B \\cap C)`;
+        case 2: //conditionnal
+            probaName = (0, random_1.random)(["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"]);
             break;
-        }
-        case 4: {
-            instruction += `calculer $P(B \\cap D)$.`;
-            startStatement = `P(B \\cap D)`;
+        case 3: //simple
+            probaName = (0, random_1.random)(["P(A)", "P(B)"]);
             break;
-        }
-    }
-    if (opts?.allowApproximate) {
-        instruction += ` Donner la valeur exacte ou une valeur arrondie au ${opts.allowApproximate}.`;
     }
+    const identifiers = {
+        A: pA.toIdentifiers(),
+        B: pB.toIdentifiers(),
+        AC: pC_A.toIdentifiers(),
+        AD: pD_A.toIdentifiers(),
+        BC: pC_B.toIdentifiers(),
+        BD: pD_B.toIdentifiers(),
+        probaName,
+    };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: probaName,
+        answer: getAnswer(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getGGBOptions = (identifiers, opts) => {
+    const probas = buildAll(identifiers);
     let commands = [
         "A = Point({2,2})",
         "B = Point({2,-2})",
@@ -80,12 +189,12 @@ const getProbabilityTree = (opts) => {
         "Segment(Point({0,0}),B)",
         "Segment(B,BC)",
         "Segment(B,BD)",
-        `Text("\\scriptsize ${A / (0, gcd_1.gcd)(A, A + B)}/${(A + B) / (0, gcd_1.gcd)(A, A + B)}", (0.3, 2.1), true, true)`,
-        `Text("\\scriptsize ${AC / (0, gcd_1.gcd)(AC, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AC, AC + AD)}", (2.8, 3.5), true, true)`,
-        `Text("\\scriptsize ${AD / (0, gcd_1.gcd)(AD, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AD, AC + AD)}", (2.8, 1.4), true, true)`,
-        `Text("\\scriptsize ${B / (0, gcd_1.gcd)(B, A + B)}/${(A + B) / (0, gcd_1.gcd)(B, A + B)}", (0.3, -1.2), true, true)`,
-        `Text("\\scriptsize ${BC / (0, gcd_1.gcd)(BC, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BC, BC + BD)}", (2.8, -0.6), true, true)`,
-        `Text("\\scriptsize ${BD / (0, gcd_1.gcd)(BD, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BD, BC + BD)}", (2.8, -2.5), true, true)`,
+        `Text("\\scriptsize ${probas.pA.toTex()}", (0.1, 2.2), true, true)`,
+        `Text("\\scriptsize ${probas.pAC.toTex()}", (2.8, 4), true, true)`,
+        `Text("\\scriptsize ${probas.pAD.toTex()}", (2.8, 1.6), true, true)`,
+        `Text("\\scriptsize ${probas.pB.toTex()}", (0.1, -0.8), true, true)`,
+        `Text("\\scriptsize ${probas.pBC.toTex()}", (2.8, -0.6), true, true)`,
+        `Text("\\scriptsize ${probas.pBD.toTex()}", (2.8, -2.5), true, true)`,
         'Text("A", (1.85 , 2.5))',
         'Text("B", (1.85 , -2.8))',
         'Text("C", (5.5 , 2.85))',
@@ -98,44 +207,30 @@ const getProbabilityTree = (opts) => {
         hideAxes: true,
         hideGrid: true,
     });
-    const question = {
-        instruction,
-        startStatement,
-        answer: answerTex,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-2, 8, -5, 5],
-        }),
-        answerFormat: "tex",
-        identifiers: { A, AC, AD, B, BC, BD, type },
-    };
-    return question;
+    return ggb.getOptions({
+        coords: [-2, 8, -5, 5],
+    });
 };
-const getPropositions = (n, { answer, A, AC, AD, B, BC, BD, type }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const answerNode = getAnswerNode({ A, AC, AD, B, BC, BD, type });
+    const answerNode = getAnswerNode(identifiers);
     while (propositions.length < n) {
         const wrongAnswer = (0, multiplyNode_1.multiply)(answerNode, (0, randint_1.randint)(2, 11)).simplify();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer, A, AC, AD, B, BC, BD, type }, opts) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
-        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-        if (!parsed)
-            return false;
-        const simplified = parsed.simplify();
-        if (opts?.allowApproximate) {
-            const rank = ["dixième", "centième", "millième"].indexOf(opts.allowApproximate);
-            return (answer === simplified.toTex() ||
-                simplified.evaluate() ===
-                    (0, round_1.round)(getAnswerNode({ type, A, AC, AD, B, BC, BD }).evaluate(), rank + 1));
-        }
-        return answer === simplified.toTex();
-        // const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-        // const texs = answer.toTree({ allowFractionToDecimal: true }).toAllValidTexs();
+        const rank = opts?.allowApproximate
+            ? ["dixième", "centième", "millième"].indexOf(opts.allowApproximate) + 1
+            : undefined;
+        return (0, rationalVEA_1.rationalVEA)(ans, answer, {
+            allowNonIrreductible: true,
+            allowDecimal: true,
+            decimalPrecision: rank,
+        });
     }
     catch (err) {
         return false;
@@ -147,25 +242,31 @@ const options = [
         label: "Autoriser les valeurs approchées au : ",
         target: exercise_1.GeneratorOptionTarget.vea,
         type: exercise_1.GeneratorOptionType.select,
-        defaultValue: "centieme",
+        defaultValue: "centième",
         values: ["dixième", "centième", "millième"],
     },
+    {
+        id: "eventTypes",
+        label: "Types de questions",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.multiselect,
+        defaultValue: defaultOptionValues,
+        values: optionValues,
+    },
+    {
+        id: "probaType",
+        label: "Format des probabilités",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.select,
+        defaultValue: "Fractions",
+        values: ["Fractions", "Décimales"],
+    },
 ];
 exports.probabilityTree = {
     id: "probabilityTree",
     connector: "=",
     label: "Calculs de probabilités à l'aide d'un arbre pondéré",
-    levels: [
-        "2nde",
-        "1reESM",
-        "1reSpé",
-        "1reTech",
-        "1rePro",
-        "TermPro",
-        "TermTech",
-    ],
     isSingleStep: false,
-    sections: ["Probabilités"],
     generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -174,4 +275,7 @@ exports.probabilityTree = {
     hasGeogebra: true,
     subject: "Mathématiques",
     options,
+    rebuildIdentifiers,
+    getInstruction,
+    getAnswer,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}
+{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.js

@@ -10,11 +10,11 @@ const addNode_1 = require("../../../../tree/nodes/operators/addNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const getHint = (identifiers) => {
-    return "La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées.";
+    return "Dans un repère dans l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées.";
 };
 const getCorrection = ({ x, y, z }) => {
     const answer = getAnswer({ x, y, z });
-    return `La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
+    return `Dans un repère de l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
  
 ${(0, alignTex_1.alignTex)([
         [
@@ -35,7 +35,11 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const u = new spaceVector_1.SpaceVector("u", identifiers.x.toTree(), identifiers.y.toTree(), identifiers.z.toTree());
-    return `Cacluler la norme du vecteur $${u.toTexWithCoords()}$`;
+    return `On se place dans un repère de l'espace orthonormé. Calculer la norme du vecteur : 
+
+$$
+${u.toTexWithCoords()}
+$$`;
 };
 const getSpaceVectorNormCalculationQuestion = () => {
     const u = spaceVector_1.SpaceVectorConstructor.random("u", false);

package/lib/exercises/vea/rationalVEA.d.ts

@@ -1,2 +1,8 @@
-export declare const rationalVEA: (studentAns: string, answer: string) => boolean;
+type Opts = {
+    allowNonIrreductible?: boolean;
+    allowDecimal?: boolean;
+    decimalPrecision?: number;
+};
+export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal }?: Opts) => boolean;
+export {};
 //# sourceMappingURL=rationalVEA.d.ts.map

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,eAAgB,MAAM,UAAU,MAAM,YAS7D,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,eACV,MAAM,UACV,MAAM,6DAC4C,IAAI,YAqC/D,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,16 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rationalVEA = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const latexParser_1 = require("../../tree/parsers/latexParser");
 const rationalParser_1 = require("../../tree/parsers/rationalParser");
-//return true if studentAns is a number or rational, and if it evaluates to answer
-const rationalVEA = (studentAns, answer) => {
+const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
+    allowNonIrreductible: true,
+    decimalPrecision: undefined,
+    allowDecimal: true,
+}) => {
+    allowDecimal = allowDecimal ?? true;
+    allowNonIrreductible = allowNonIrreductible ?? true;
+    decimalPrecision = decimalPrecision ?? undefined;
     const parsed = (0, rationalParser_1.rationalParser)(studentAns);
     if (!parsed)
         return false;
     try {
         const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
-        return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        if ((0, numberNode_1.isNumberNode)(parsed)) {
+            if (!allowDecimal)
+                return false;
+            if (decimalPrecision === undefined)
+                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001);
+            else {
+                //! accepte bien les arrondis au centième par ex, mais va aussi accepter les arrondis au millième
+                //! je juge ca ok
+                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                    Math.pow(10, -decimalPrecision - 1));
+            }
+        }
+        else if (allowNonIrreductible) {
+            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        }
+        else {
+            //parsed est une fraction ou opposite(frac)
+            return parsed.equals(parsedAnswer);
+        }
     }
     catch (err) {
         return false;

package/lib/index.d.ts

@@ -35,6 +35,7 @@ declare const mathExercises: (Exercise<{
 }, {
     allowNonIrreductible?: boolean | undefined;
 }> | Exercise<{
+    isIntegerFirst: boolean;
     integer: number;
     rational: [number, number];
 }, {
@@ -77,6 +78,8 @@ declare const mathExercises: (Exercise<{
     num2: number;
     denom1: number;
     denom2: number;
+}, {}> | Exercise<{
+    statementIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -1327,15 +1330,17 @@ declare const mathExercises: (Exercise<{
     nbFaces: number;
     faceAsked: number;
 }, {}> | Exercise<{
-    type: number;
-    A: number;
-    B: number;
-    AC: number;
-    AD: number;
-    BC: number;
-    BD: number;
+    A: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    B: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    probaName: string;
 }, {
     allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 }> | Exercise<{
     randomValues: number[];
     randomEffectives: number[];

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,sBAAsB,CAAC;AAG1D,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/complex/complex.d.ts

@@ -18,7 +18,7 @@ export declare class Complex {
     times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
-    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | FractionNode | OppositeNode | undefined;
+    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | OppositeNode | FractionNode | undefined;
     toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
     toTree(): ComplexNode;
 }

package/lib/math/numbers/rationals/rational.d.ts

@@ -28,7 +28,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): FractionNode | OppositeNode;
+    toTree(opts?: NodeOptions): OppositeNode | FractionNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -13,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | OppositeNode | MultiplyNode | AddNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode | AddNode | OppositeNode | MultiplyNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/math/polynomials/generalAffine.d.ts

@@ -5,6 +5,6 @@ export declare class GeneralAffine {
     variable: string;
     constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
     getRoot(): AlgebraicNode;
-    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
 }
 //# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalTrinom.d.ts

@@ -51,7 +51,7 @@ export declare class GeneralTrinom {
     constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: GeneralTrinomOptions);
     getDelta(): AlgebraicNode;
     getRoots(): AlgebraicNode[];
-    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
     toTex(): string;
     getCoeffs(): number[];
     toIdentifiers(): GeneralTrinomIdentifiers;

package/lib/math/polynomials/trinom.d.ts

@@ -65,11 +65,11 @@ export declare class Trinom extends Polynomial {
     getRootsNode(): AlgebraicNode[];
     getRootsEquationSolutionTex(): string;
     getAlpha(): number;
-    getAlphaNode(): NumberNode | FractionNode | OppositeNode;
+    getAlphaNode(): NumberNode | OppositeNode | FractionNode;
     getBeta(): number;
-    getBetaNode(): NumberNode | FractionNode | OppositeNode;
+    getBetaNode(): NumberNode | OppositeNode | FractionNode;
     getFactorizedForm(): AlgebraicNode | MultiplyNode;
-    getCanonicalForm(): MultiplyNode | AddNode;
+    getCanonicalForm(): AddNode | MultiplyNode;
     getSommet(): Point;
     getCoords(): number[];
     toPython(): string;

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAuCA,eAAO,MAAM,UAAU,YAItB,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AA8CA,eAAO,MAAM,UAAU,YAAW,CAAC"}

package/lib/playground.js

@@ -2,11 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => {
-    // logIdentifiers();
-    // const parsed = parseLatex("x\\times +3");
-    // console.log(parsed.toTex());
-};
+const playground = () => { };
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/prototypesEnhancement.d.ts

@@ -1,8 +1,10 @@
 import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 import { NodeOptions } from "./tree/nodes/node";
+import { ConstantNode } from "./tree/nodes/numbers/constantNode";
+import { NumberNode } from "./tree/nodes/numbers/numberNode";
 declare global {
     interface Number {
-        toTree: (opts?: NodeOptions) => AlgebraicNode;
+        toTree: (opts?: NodeOptions) => NumberNode | ConstantNode;
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }

package/lib/prototypesEnhancement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAStD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;QAC9C,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}
+{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAKjE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI7D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,UAAU,GAAG,YAAY,CAAC;QAC1D,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}

package/lib/tree/nodes/algebraicNode.d.ts

@@ -14,6 +14,7 @@ export interface AlgebraicNode extends Node {
     simplify: (opts?: SimplifyOptions) => AlgebraicNode;
     equals: (node: AlgebraicNode) => boolean;
     isNumeric: boolean;
+    derivative: (varName?: string) => AlgebraicNode;
 }
 export declare const isAlgebraicNode: (node: Node) => node is AlgebraicNode;
 //# sourceMappingURL=algebraicNode.d.ts.map

package/lib/tree/nodes/algebraicNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}
+{"version":3,"file":"algebraicNode.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/algebraicNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE3C,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AACF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,MAAM,CAAC;IACpD,oBAAoB,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,aAAa,CAAC;IAC7E,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,EAAE,CAAC;IAC3D,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,eAAe,KAAK,aAAa,CAAC;IACpD,MAAM,EAAE,CAAC,IAAI,EAAE,aAAa,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;CACjD;AAED,eAAO,MAAM,eAAe,SAAU,IAAI,0BACA,CAAC"}