math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/probaStat/conditional/conditionalProbability.js

@@ -0,0 +1,332 @@
+/* eslint-disable @typescript-eslint/naming-convention*/
+//? it makes sense here to use pA_B
+import { randint } from "../../../../math/utils/random/randint.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { round } from "../../../../math/utils/round.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { flip, pA, pAB, pA_B, pB, pB_A } = identifiers;
+    let instruction = `On considère deux événements $A$ et $B$ tels que `;
+    switch (flip) {
+        case 1: {
+            const pAStr = (pA / 100).frenchify();
+            const pABStr = (pAB / 100).frenchify();
+            instruction += `$P(A) = ${pAStr}\\ $ et $\\ P(A \\cap B) = ${pABStr}$.
+      
+Déterminer $P_A(B)$ (arrondir au centième).`;
+            break;
+        }
+        case 2: {
+            const pBStr = (pB / 100).frenchify();
+            const pABStr = (pAB / 100).frenchify();
+            instruction += `$P(B) = ${pBStr}\\ $ et $\\ P(B \\cap A) = ${pABStr}$.
+
+Déterminer $P_B(A)$ (arrondir au centième).`;
+            break;
+        }
+        case 3: {
+            const pAStr = (pA / 100).frenchify();
+            const pB_AStr = (pB_A / 100).frenchify();
+            instruction += `$P(A) = ${pAStr}\\ $ et $\\ P_A(B) = ${pB_AStr}$.
+      
+Déterminer $P(A \\cap B)$ (arrondir au centième).`;
+            break;
+        }
+        case 4: {
+            const pBStr = (pB / 100).frenchify();
+            const pA_BStr = (pA_B / 100).frenchify();
+            instruction += `$P(B) = ${pBStr}\\ $ et $\\ P_B(A) = ${pA_BStr}$.
+      
+Déterminer $P(A \\cap B)$ (arrondir au centième).`;
+            break;
+        }
+        case 5: {
+            const pABStr = (pAB / 100).frenchify();
+            const pA_BStr = (pA_B / 100).frenchify();
+            instruction += `$P(A \\cap B) = ${pABStr}\\ $ et $\\ P_B(A) = ${pA_BStr}$.
+      
+Déterminer $P(B)$ (arrondir au centième).`;
+            break;
+        }
+        case 6: {
+            const pABStr = (pAB / 100).frenchify();
+            const pB_AStr = (pB_A / 100).frenchify();
+            instruction += `$P(A \\cap B) = ${pABStr}\\ $ et $\\ P_A(B) = ${pB_AStr}$.
+      
+Déterminer $P(A)$ (arrondir au centième).`;
+            break;
+        }
+    }
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { flip, pA, pAB, pB } = identifiers;
+    switch (flip) {
+        case 1:
+            return round(pAB / pA, 2).frenchify();
+        case 2:
+            return round(pAB / pB, 2).frenchify();
+        case 3:
+            return pAB.frenchify();
+        case 4:
+            return pAB.frenchify();
+        case 5:
+            return pB.frenchify();
+        case 6:
+        default:
+            return pA.frenchify();
+    }
+};
+const getHint = () => {
+    return `Pour deux événements $M$ et $N$, on a: 
+    
+$$
+P_M(N) = \\frac{P(M \\cap N)}{P(M)}
+$$
+`;
+};
+const getStartStatement = (identifiers) => {
+    const { flip } = identifiers;
+    switch (flip) {
+        case 1:
+            return `P_A(B)`;
+        case 2:
+            return `P_B(A)`;
+        case 3:
+            return `P(A \\cap B)`;
+        case 4:
+            return `P(A \\cap B)`;
+        case 5:
+            return `P(B)`;
+        case 6:
+        default:
+            return `P(A)`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { flip, pA, pAB, pA_B, pB, pB_A } = identifiers;
+    const answer = getAnswer(identifiers);
+    switch (flip) {
+        case 1: {
+            const pAStr = (pA / 100).frenchify();
+            const pABStr = (pAB / 100).frenchify();
+            return `
+On sait que : 
+
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+$$
+P_A(B) = \\frac{${pABStr}}{${pAStr}} \\approx ${answer}
+$$
+      `;
+        }
+        case 2: {
+            const pBStr = (pB / 100).frenchify();
+            const pABStr = (pAB / 100).frenchify();
+            return `
+On sait que : 
+
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+$$
+P_B(A) = \\frac{${pABStr}}{${pBStr}} \\approx ${answer}
+$$
+      `;
+        }
+        case 3: {
+            const pAStr = (pA / 100).frenchify();
+            const pB_AStr = (pB_A / 100).frenchify();
+            return `
+On sait que : 
+      
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+${alignTex([
+                ["P(A \\cap B)", "=", "P_A(B)\\times P(A)"],
+                ["", "=", `${pB_AStr}\\times ${pAStr}`],
+                ["", "\\approx", answer],
+            ])}
+`;
+        }
+        case 4: {
+            const pBStr = (pB / 100).frenchify();
+            const pA_BStr = (pA_B / 100).frenchify();
+            return `
+On sait que : 
+      
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+${alignTex([
+                ["P(A \\cap B)", "=", "P_B(A)\\times P(B)"],
+                ["", "=", `${pA_BStr}\\times ${pBStr}`],
+                ["", "\\approx", answer],
+            ])}
+            `;
+        }
+        case 5: {
+            const pABStr = (pAB / 100).frenchify();
+            const pA_BStr = (pA_B / 100).frenchify();
+            return `
+On sait que : 
+      
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+${alignTex([
+                ["P(B)", "=", "\\frac{P(A\\cap B)}{P_B(A)}"],
+                ["", "=", `\\frac{${pABStr}}{${pA_BStr}}`],
+                ["", "\\approx", answer],
+            ])}
+`;
+        }
+        case 6:
+        default: {
+            const pABStr = (pAB / 100).frenchify();
+            const pB_AStr = (pB_A / 100).frenchify();
+            return `
+On sait que : 
+      
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+${alignTex([
+                ["P(A)", "=", "\\frac{P(A\\cap B)}{P_A(B)}"],
+                ["", "=", `\\frac{${pABStr}}{${pB_AStr}}`],
+                ["", "\\approx", answer],
+            ])}
+`;
+        }
+    }
+};
+const getConditionalProbability = (opts) => {
+    let pA, pB, pAB, pA_B, pB_A;
+    const types = opts?.probaType ?? ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"];
+    const flipChoices = [];
+    if (types.includes("$P(A)$"))
+        flipChoices.push(5, 6);
+    if (types.includes("$P(A\\cap B)$"))
+        flipChoices.push(3, 4);
+    if (types.includes("$P_A(B)$"))
+        flipChoices.push(1, 2);
+    const flip = random(flipChoices);
+    //1,2 = P_AB, 3,4 = PANB, 5,6 = PA
+    switch (flip) {
+        case 1:
+            pA = randint(2, 100);
+            pAB = randint(1, pA);
+            break;
+        case 2:
+            pB = randint(2, 100);
+            pAB = randint(1, pB);
+            break;
+        case 3:
+            pA = randint(2, 100);
+            pB_A = randint(1, pA);
+            pAB = round((pB_A * pA) / 10000, 2);
+            break;
+        case 4:
+            pB = randint(2, 100);
+            pA_B = randint(1, pB);
+            pAB = round((pA_B * pB) / 10000, 2);
+            break;
+        case 5:
+            pA_B = randint(1, 100);
+            pAB = randint(1, pA_B);
+            pB = round(pAB / pA_B, 2);
+            break;
+        case 6:
+        default:
+            pB_A = randint(1, 100);
+            pAB = randint(1, pB_A);
+            pA = round(pAB / pB_A, 2);
+    }
+    const identifiers = { flip, pA, pAB, pB, pA_B, pB_A };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const options = [
+    {
+        id: "probaType",
+        label: "Probabilité demandée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+        defaultValue: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts?.probaType?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de probabilité demandée.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["p", "cap", "underscore"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, (Math.floor(Math.random() * 100) / 100 + "").replace(".", ","));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+export const conditionalProbability = {
+    id: "conditionalProbability",
+    connector: "=",
+    label: "Calcul de probabilité conditionnelle avec la formule de Bayes $P(A \\cap B) = P_A(B) \\times P(A)$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getConditionalProbability(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    options,
+    validateOptions,
+};

package/lib/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ProbaTreeSituationParams } from "../trees/probaTreeSituations.js";
+type Identifiers = {
+    params: ProbaTreeSituationParams;
+};
+export declare const fillTableConditionalProbabilitySituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=fillTableConditionalProbabilitySituation.d.ts.map

package/lib/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fillTableConditionalProbabilitySituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAsOF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}

package/lib/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.js

@@ -0,0 +1,222 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { valueTableVEA } from "../../../../exercises/vea/valueTableVEA.js";
+import { reifyAlgebraic } 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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { buildProbaTreeSituation, getProbaTreeSituation, } from "../trees/probaTreeSituations.js";
+const getAnswerTable = (identifiers) => {
+    const situation = getProbaTreeSituation(identifiers.params);
+    const { firstCondProba, mainEventProba, secondCondProba } = situation;
+    const mainEventProbaDec = frac(mainEventProba, 100).evaluate();
+    const firstCondProbaDec = frac(firstCondProba, 100).evaluate();
+    const secondCondProbaDec = frac(secondCondProba, 100).evaluate();
+    const aNb = multiply(mainEventProbaDec, firstCondProbaDec).simplify();
+    const abarreNb = multiply(substract(1, mainEventProbaDec), secondCondProbaDec).simplify();
+    const pb = add(aNb, abarreNb).simplify();
+    return [
+        [
+            "$\\ $",
+            `${situation.secondEvent}`,
+            `\\overline{${situation.secondEvent}}`,
+            "\\text{Total}",
+        ],
+        [
+            `$${situation.mainEvent}$`,
+            `${aNb.toTex()}`,
+            `${substract(mainEventProbaDec, aNb).simplify().toTex()}`,
+            `${mainEventProbaDec.frenchify()}`,
+        ],
+        [
+            `$\\overline{${situation.mainEvent}}$`,
+            `${abarreNb.toTex()}`,
+            `${substract(1 - mainEventProbaDec, abarreNb)
+                .simplify()
+                .toTex()}`,
+            `${substract(1, mainEventProbaDec).simplify().toTex()}`,
+        ],
+        ["Total", `${pb.toTex()}`, `${substract(1, pb).simplify().toTex()}`, "1"],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    return `${situation.context}
+  
+Compléter le tableau suivant avec les probabilités manquantes.`;
+};
+const getHint = () => {
+    return `Commence par remplir la colonne "Total" à la droite du tableau.
+  
+Puis, sers-toi des probabilités conditionnelles données dans l'énoncé pour déterminer les probabilités manquantes. Les cases à l'intersection de deux évenements représentent des probabilités d'intersection.`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    let mainEventProba;
+    let firstCondProba;
+    let secondCondProba;
+    const mainEvent = situation.mainEvent;
+    const secondEvent = situation.secondEvent;
+    switch (params.id) {
+        case "virus":
+            {
+                const { pContamineIds, pNegSainIds, pPosContamineIds } = params;
+                const pContamine = reifyAlgebraic(pContamineIds);
+                const pPosContamine = reifyAlgebraic(pPosContamineIds);
+                const pNegSain = reifyAlgebraic(pNegSainIds);
+                const aNb = multiply(frac(pContamine, 100), frac(pPosContamine, 100)).evaluate();
+                const abarreNbbarre = multiply(substract(1, frac(pContamine, 100)), frac(pNegSain, 100)).evaluate();
+                return `D'après l'énoncé, on a : 
+       
+$$
+P(C) = ${pContamine.toTex()}\\%
+$$
+
+$$
+P_C(T) = ${pPosContamine.toTex()}\\%
+$$
+
+$$
+P_{\\overline{C}}\\left(\\overline{T}\\right) = ${pNegSain.toTex()}\\%
+$$
+
+On en déduit les probabilités manquantes : 
+
+$$
+P(C\\cap T) = P(C)\\times P_C(T) = ${aNb.frenchify()} 
+$$
+
+donc 
+
+$$
+P(C\\cap \\overline{T}) = P(C)-P(C\\cap T) = 
+${substract(frac(pContamine, 100), aNb).evaluate().frenchify()}
+$$
+
+
+et
+
+$$
+P(\\overline{C}\\cap \\overline{T}) = P(\\overline{C})\\times P_{\\overline{C}}(\\overline{T}) = ${abarreNbbarre.frenchify()} 
+$$
+
+donc 
+
+$$
+P(\\overline{C}\\cap T) = P(\\overline{C})- P(\\overline{C}\\cap \\overline{T}) = ${substract(substract(1, frac(pContamine, 100)), abarreNbbarre)
+                    .evaluate()
+                    .frenchify()}
+$$
+
+`;
+            }
+            break;
+        default:
+            mainEventProba = situation.mainEventProba;
+            secondCondProba = situation.secondCondProba;
+            firstCondProba = situation.firstCondProba;
+            break;
+    }
+    const aNb = multiply(frac(mainEventProba, 100), frac(firstCondProba, 100)).evaluate();
+    const abarreNb = multiply(frac(substract(100, mainEventProba), 100), frac(secondCondProba, 100)).evaluate();
+    return `D'après l'énoncé, on a : 
+       
+$$
+P(${mainEvent}) = ${mainEventProba.toTex()}\\%
+$$
+
+$$
+P_{${mainEvent}}(${secondEvent}) = ${firstCondProba.toTex()}\\%
+$$
+
+$$
+P_{\\overline{${mainEvent}}}(${secondEvent}) = ${secondCondProba.toTex()}\\%
+$$
+
+On en déduit les probabilités manquantes : 
+
+$$
+P(${mainEvent}\\cap ${secondEvent}) = P(${mainEvent})\\times P_{${mainEvent}}(${secondEvent}) = ${aNb.frenchify()} 
+$$
+
+donc 
+
+$$
+P(${mainEvent}\\cap \\overline{${secondEvent}}) = P(${mainEvent})-P(${mainEvent}\\cap ${secondEvent})  = 
+${substract(frac(mainEventProba, 100), aNb).evaluate().frenchify()}
+$$
+
+et
+
+$$
+P(\\overline{${mainEvent}}\\cap ${secondEvent}) = P(\\overline{${mainEvent}})\\times P_{\\overline{${mainEvent}}}(${secondEvent}) = ${abarreNb.frenchify()} 
+$$
+
+donc 
+
+$$
+P(\\overline{${mainEvent}}\\cap \\overline{${secondEvent}}) = P(\\overline{${mainEvent}})- P(\\overline{${mainEvent}}\\cap ${secondEvent}) = ${substract(substract(1, frac(mainEventProba, 100)), abarreNb)
+        .evaluate()
+        .frenchify()}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return valueTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFillTableConditionalProbabilityQuestion = () => {
+    const params = buildProbaTreeSituation();
+    const identifiers = { params };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const situation = getProbaTreeSituation(identifiers.params);
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: [
+            [
+                "$\\ $",
+                `${situation.secondEvent}`,
+                `\\overline{${situation.secondEvent}}`,
+                "\\text{Total}",
+            ],
+            [`$${situation.mainEvent}$`, "", "", ""],
+            [`$\\overline{${situation.mainEvent}}$`, "", "", ""],
+            ["Total", "", "", "1"],
+        ],
+    };
+};
+export const fillTableConditionalProbabilitySituation = {
+    id: "fillTableConditionalProbabilitySituation",
+    label: "Compléter un tableau à double entrée de probabilités à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFillTableConditionalProbabilityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+    isAnswerTableValid,
+};

package/lib/exercises/math/probaStat/conditional/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./conditionalProbability.js";
+export * from "./fillTableConditionalProbabilitySituation.js";
+export * from "./conditionalProbaFromTableWithContext.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/conditional/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+CAA+C,CAAC;AAC9D,cAAc,2CAA2C,CAAC"}

package/lib/exercises/math/probaStat/conditional/index.js

@@ -0,0 +1,4 @@
+export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./conditionalProbability.js";
+export * from "./fillTableConditionalProbabilitySituation.js";
+export * from "./conditionalProbaFromTableWithContext.js";

package/lib/exercises/math/probaStat/index.d.ts

@@ -1,4 +1,3 @@
-export * from "./conditionalProbability.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
 export * from "./independancy/index.js";
@@ -13,7 +12,7 @@ export * from "./checkEquiprobability.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
 export * from "./probaAsSumOfProbas.js";
-export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC"}

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

@@ -1,4 +1,3 @@
-export * from "./conditionalProbability.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
 export * from "./independancy/index.js";
@@ -13,6 +12,6 @@ export * from "./checkEquiprobability.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
 export * from "./probaAsSumOfProbas.js";
-export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";

package/lib/exercises/math/probaStat/probaFromTableWithContext.d.ts

@@ -14,6 +14,7 @@ type Identifiers = {
 };
 type Options = {
     allowedAnsType: string[];
+    probaTypes: string[];
 };
 export declare const probaFromTableWithContext: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/probaStat/probaFromTableWithContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA4oBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA+ZF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+BF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}