math-exercises 3.0.184 → 3.0.185

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

@@ -1,11 +1,11 @@
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
-import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random } from "../../../../utils/alea/random.js";
@@ -18,12 +18,26 @@ const optionValues = [
     "Probabilité totale $P(C)$",
     "Probabilité conditionnelle $P_B(A)$",
     "Probabilité 'simple' $P(A)$",
+    "Probabilité d'inversion de causalité $P_B(A)$",
 ];
 const defaultOptionValues = [
     "Probabilité d'intersection $P(A\\cap C)$",
     "Probabilité totale $P(C)$",
     "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
 ];
+const getProbaType = (identifiers) => {
+    const { probaName } = identifiers;
+    return probaName.includes("\\cap")
+        ? "inter"
+        : ["P(C)", "P(D)"].includes(probaName)
+            ? "totale"
+            : ["P(A)", "P(B)"].includes(probaName)
+                ? "simple"
+                : ["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"].includes(probaName)
+                    ? "conditionnelle"
+                    : "inversion";
+};
 const buildAll = (identifiers) => {
     return {
         pA: NodeConstructor.fromIdentifiers(identifiers.A),
@@ -62,16 +76,82 @@ const getAnswerNode = (identifiers) => {
         case "P(D)":
         default:
             return add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+        case "P_C(A)": {
+            //anc / c
+            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
+            return frac(multiply(probas.pA, probas.pAC), pc).simplify();
+        }
+        case "P_C(B)": {
+            //cnb / c
+            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
+            return frac(multiply(probas.pB, probas.pBC), pc).simplify();
+        }
+        case "P_D(A)": {
+            //and / d
+            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+            return frac(multiply(probas.pA, probas.pAD), pd).simplify();
+        }
+        case "P_D(B)": {
+            //cnb / c
+            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+            return frac(multiply(probas.pB, probas.pBD), pd).simplify();
+        }
     }
 };
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
+const getTrueProbaName = (identifiers) => {
+    const { probaName, useContraryNames } = identifiers;
+    if (!useContraryNames)
+        return probaName;
+    return probaName
+        .replaceAll("_B", "_{\\overline{A}}")
+        .replaceAll("B", "\\overline{A}")
+        .replaceAll("_D", "_{\\overline{B}}")
+        .replaceAll("C", "B")
+        .replaceAll("D", "\\overline{B}");
+};
 const getInstruction = (identifiers, options) => {
-    let instr = `On considère l'arbre de probabilités ci-dessous. Calculer : 
+    const probas = buildAll(identifiers);
+    const type = getProbaType(identifiers);
+    const { useContraryNames } = identifiers;
+    const trueProbaName = getTrueProbaName(identifiers);
+    const tree = [
+        [
+            [
+                [`£${probas.pA.toTex()}£`, "£A£"],
+                [
+                    `£${probas.pB.toTex()}£`,
+                    useContraryNames ? "£\\overline{A}£" : "£B£",
+                ],
+            ],
+        ],
+        [
+            [
+                [`£${probas.pAC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
+                [
+                    `£${probas.pAD.toTex()}£`,
+                    useContraryNames ? "£\\overline{B}£" : "£D£",
+                ],
+            ],
+            [
+                [`£${probas.pBC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
+                [
+                    `£${probas.pBD.toTex()}£`,
+                    useContraryNames ? "£\\overline{B}£" : "£D£",
+                ],
+            ],
+        ],
+    ];
+    let instr = `On considère l'arbre de probabilités ci-dessous :
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+  
+${type === "conditionnelle" || type === "simple" ? "Déterminer :" : "Calculer :"} 
   
 $$
-${identifiers.probaName}
+${trueProbaName}
 $$`;
     if (options?.allowApproximate) {
         instr += `
@@ -91,7 +171,7 @@ const getProbaAndOpposite = (decimal = false) => {
     }
 };
 const getStartStatement = (identifiers) => {
-    return identifiers.probaName;
+    return getTrueProbaName(identifiers);
 };
 const getProbabilityTree = (opts) => {
     const isDecimal = opts?.probaType === "Décimales";
@@ -122,6 +202,9 @@ const getProbabilityTree = (opts) => {
         case 3: //simple
             probaName = random(["P(A)", "P(B)"]);
             break;
+        case 4: //inversion
+            probaName = random(["P_C(A)", "P_D(A)", "P_C(B)", "P_D(B)"]);
+            break;
     }
     const identifiers = {
         A: pA.toIdentifiers(),
@@ -131,58 +214,254 @@ const getProbabilityTree = (opts) => {
         BC: pCSachantB.toIdentifiers(),
         BD: pDSachantB.toIdentifiers(),
         probaName,
+        useContraryNames: opts?.eventsNames === "Événements et leur contraire",
     };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
+const getHint = (identifiers) => {
+    const { probaName, useContraryNames } = identifiers;
+    const type = getProbaType(identifiers);
+    const trueProbaName = getTrueProbaName(identifiers);
+    switch (type) {
+        case "conditionnelle": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames
+                ? over === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.`;
+        }
+        case "inter": {
+            const [first, second] = probaName
+                .replaceAll("P(", "")
+                .replaceAll(")", "")
+                .split("\\cap ");
+            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
+            const trueSecond = useContraryNames
+                ? second === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : second;
+            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
+      
+Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${trueSecond}$.
+`;
+        }
+        case "totale": {
+            const evenement = probaName[2];
+            const trueEvenement = useContraryNames
+                ? evenement === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : evenement;
+            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$. Sa probabilité est la somme des probabilités de chacun de ces chemins. Pour obtenir la probabilité d'un chemin, il faut multiplier les probabilités présentes sur les branches de ce chemin.`;
+        }
+        case "simple": {
+            const trueEvent = useContraryNames && probaName[2] === "B"
+                ? "\\overline{A}"
+                : probaName[2];
+            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.`;
+        }
+        case "inversion": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames
+                ? under === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Pour la déterminer, tu peux revenir à la définition d'une probabilité conditionnelle : pour deux évenements $M$ et $N$, on a : 
+
+$$
+P_M(N) = \\frac{P(M \\cap N)}{P(M)}
+$$
+`;
+        }
+    }
+};
+const getCorrection = (identifiers) => {
+    const { probaName } = identifiers;
+    const probas = buildAll(identifiers);
+    const type = getProbaType(identifiers);
+    const trueProbaName = getTrueProbaName(identifiers);
+    const { useContraryNames } = identifiers;
+    switch (type) {
+        case "conditionnelle": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames
+                ? over === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.
+
+On a donc : 
+
+$$
+${trueProbaName} = ${getAnswer(identifiers)}
+$$`;
+        }
+        case "inter": {
+            const [first, second] = probaName
+                .replaceAll("P(", "")
+                .replaceAll(")", "")
+                .split("\\cap ");
+            const firstProba = first === "A" ? probas.pA : probas.pB;
+            const secondProba = second === "C"
+                ? first === "A"
+                    ? probas.pAC
+                    : probas.pBC
+                : first === "A"
+                    ? probas.pAD
+                    : probas.pBD;
+            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
+            const secondFirst = useContraryNames
+                ? second === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : second;
+            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
+      
+Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${secondFirst}$. 
+
+On a donc : 
+
+$$
+${trueProbaName} = ${multiply(firstProba, secondProba).toSimplificationTex()}
+$$
+`;
+        }
+        case "totale": {
+            const evenement = probaName[2];
+            const trueEvenement = useContraryNames
+                ? evenement === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : evenement;
+            const first = evenement === "C" ? probas.pAC : probas.pAD;
+            const second = evenement === "C" ? probas.pBC : probas.pBD;
+            const firstWay = multiply(probas.pA, first);
+            const secondWay = multiply(probas.pB, second);
+            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$ : le chemin de l'intersection $A\\cap ${trueEvenement}$ et celui de l'intersection $${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}$. La probabilité $${trueProbaName}$ est la somme des probabilités de ces chemins.
+
+On a : 
+
+$$
+P(A\\cap ${trueEvenement}) = ${firstWay.toSimplificationTex()}
+$$
+
+et
+
+$$
+P(${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}) = ${secondWay.toSimplificationTex()}
+$$
+
+Donc : 
+
+$$
+${trueProbaName} = ${add(firstWay.simplify(), secondWay.simplify()).toSimplificationTex()}
+$$      
+`;
+        }
+        case "simple": {
+            const trueEvent = useContraryNames && probaName[2] === "B"
+                ? "\\overline{A}"
+                : probaName[2];
+            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.
+      
+On a donc : 
+
+$$
+${trueProbaName} = ${getAnswer(identifiers)}
+$$`;
+        }
+        case "inversion": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames
+                ? under === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
+            const total = add(multiply(probas.pA, under === "C" ? probas.pAC : probas.pAD), multiply(probas.pB, under === "C" ? probas.pBC : probas.pBD));
+            const inter = multiply(over === "A" ? probas.pA : probas.pB, under === "C"
+                ? over === "A"
+                    ? probas.pAC
+                    : probas.pBC
+                : over === "A"
+                    ? probas.pAD
+                    : probas.pBD);
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Pour la déterminer, on revient à la définition d'une probabilité conditionnelle : 
+
+$$
+${trueProbaName} = \\frac{P(${trueOver} \\cap ${trueUnder})}{P(${trueUnder})}
+$$
+
+On calcule donc d'abord $P(${trueOver} \\cap ${trueUnder})$ :
+
+$$
+P(${trueOver} \\cap ${trueUnder}) = ${inter.toSimplificationTex()}
+$$
+
+Puis on calcule la probabilité totale $P(${trueUnder})$ :
+
+$$
+P(${trueUnder})=${total.toSimplificationTex()}
+$$
+
+On a donc : 
+
+$$
+${trueProbaName} = ${frac(inter.simplify(), total.simplify()).toSimplificationTex()}
+$$
+`;
+        }
+    }
+};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers, opts),
         startStatement: getStartStatement(identifiers, opts),
-        answer: getAnswer(identifiers),
+        answer: getAnswer(identifiers, opts),
         keys: [],
-        ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
-const getGGBOptions = (identifiers) => {
-    const probas = buildAll(identifiers);
-    const commands = [
-        "A = Point({2,2})",
-        "B = Point({2,-2})",
-        "AC = Point({5,3})",
-        "AD = Point({5,1})",
-        "BC = Point({5,-1})",
-        "BD = Point({5,-3})",
-        "Segment(Point({0,0}),A)",
-        "Segment(A,AC)",
-        "Segment(A,AD)",
-        "Segment(Point({0,0}),B)",
-        "Segment(B,BC)",
-        "Segment(B,BD)",
-        `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))',
-        'Text("D", (5.5 , 0.85))',
-        'Text("C", (5.5 , -1.1))',
-        'Text("D", (5.5 , -3.1))',
-    ];
-    const ggb = new GeogebraConstructor({
-        commands,
-        hideAxes: true,
-        hideGrid: true,
-    });
-    return ggb.getOptions({
-        coords: [-2, 8, -5, 5],
-    });
-};
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -233,19 +512,114 @@ const options = [
         defaultValue: "Fractions",
         values: ["Fractions", "Décimales"],
     },
+    {
+        id: "eventsNames",
+        label: "Noms des événements",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        defaultValue: "Événements et leur contraire",
+        values: [
+            "Événements et leur contraire",
+            "Noms d'événements tous différents",
+        ],
+    },
 ];
+const partialOptions = options.filter((p) => p.id !== "eventTypes");
 export const probabilityTree = {
     id: "probabilityTree",
     connector: "=",
-    label: "Calculs de probabilités à l'aide d'un arbre pondéré",
+    label: "Calculer une probabilité dans un arbre pondéré (tous calculs)",
     isSingleStep: false,
     generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
-    hasGeogebra: true,
     subject: "Mathématiques",
     options,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeIntersection = {
+    id: "probabilityTreeIntersection",
+    connector: "=",
+    label: "Calculer une intersection dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité d'intersection $P(A\\cap C)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeTotalProbability = {
+    id: "probabilityTreeTotalProbability",
+    connector: "=",
+    label: "Calculer une probabilité totale dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité totale $P(C)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeReadProbability = {
+    id: "probabilityTreeReadProbability",
+    connector: "=",
+    label: "Lire une probabilité dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: [
+            "Probabilité conditionnelle $P_B(A)$",
+            "Probabilité 'simple' $P(A)$",
+        ],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeInversionProbability = {
+    id: "probabilityTreeInversionProbability",
+    connector: "=",
+    label: "Calculer une probabilité d'inversion de causalité du type $P_B(A)$ dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité d'inversion de causalité $P_B(A)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsOF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}
+{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.js

@@ -42,7 +42,7 @@ const getCorrection = (identifiers, optsIn) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     const { situationIndex, initial, reason, valueAsked } = identifiers;
     const situation = situations[situationIndex];
-    return situation.variationFindRank.getCorrectionStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder).str;
+    return situation.variationFindRank.getCorrectionStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder, situation.digitsValue, situation.digitsTarget).str;
 };
 const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;
@@ -54,12 +54,12 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const arrNodeWrong = [];
     //student: uses valueAsked as if it were rankAsked
     {
-        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked);
+        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked, situation.rankDecoder);
         tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
         arrNodeWrong.push(nodeWrong);
     }
     const rankValid = (() => {
-        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked);
+        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder);
         return round(rankNode.evaluate(), 0);
     })();
     //pseudo terror

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindThresholdFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA0PF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"arithmeticFindThresholdFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAG9C,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA6PF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.js

@@ -46,7 +46,7 @@ const getCorrection = (identifiers, optsIn) => {
     const { situationIndex, initial, reason, valueThreshold, inegSymbol } = identifiers;
     const situation = situations[situationIndex];
     const inequationSymbol = new InequationSymbol(inegSymbol);
-    return situation.variationFindThreshold.getCorrectionStuff(initial, reason, firstRank, valueThreshold, inequationSymbol, situation.rankDecoder).str;
+    return situation.variationFindThreshold.getCorrectionStuff(initial, reason, firstRank, valueThreshold, inequationSymbol, situation.rankDecoder, situation.digitsValue, situation.digitsTarget).str;
 };
 const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;
@@ -58,7 +58,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     addValidProp(propositions, answer);
     const arrNodeWrong = [];
     const rankValid = (() => {
-        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueThreshold, inequationSymbol);
+        const { rankNode } = situation.variationFindThreshold.getAnswerStuff(initial, reason, firstRank, valueThreshold, inequationSymbol, situation.rankDecoder);
         return round(rankNode.evaluate(), 0);
     })();
     //student: gives u[threshold] instead of threshold

package/lib/exercises/math/sequences/arithmetic/situations/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./arithmeticFindExplicitFormulaFromSituation.js";
 export * from "./arithmeticFindRecurrenceFormulaFromSituation.js";
 export * from "./arithmeticFindTermFromSituation.js";
+export * from "./arithmeticFindRankFromSituation.js";
+export * from "./arithmeticFindThresholdFromSituation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/arithmetic/situations/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC;AAChE,cAAc,mDAAmD,CAAC;AAClE,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC;AAChE,cAAc,mDAAmD,CAAC;AAClE,cAAc,sCAAsC,CAAC;AAErD,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/index.js

@@ -1,5 +1,5 @@
 export * from "./arithmeticFindExplicitFormulaFromSituation.js";
 export * from "./arithmeticFindRecurrenceFormulaFromSituation.js";
 export * from "./arithmeticFindTermFromSituation.js";
-// export * from "./arithmeticFindRankFromSituation.js";
-// export * from "./arithmeticFindThresholdFromSituation.js";
+export * from "./arithmeticFindRankFromSituation.js";
+export * from "./arithmeticFindThresholdFromSituation.js";

package/lib/index.d.ts

@@ -3380,6 +3380,19 @@ declare const mathExercises: (Exercise<{
     reason: number;
     superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
     rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+    valueAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+    valueThreshold: number;
+    inegSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
 }, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
     final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{