math-exercises 3.0.171 → 3.0.173

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationProbabilityLaw.js

@@ -0,0 +1,162 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { xTableLineVEA } from "../../../../exercises/vea/xTableLineVEA.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/randomVariableSituations.js";
+const getAnswerTable = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getLawTable();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Déterminer la loi de probabilité de $X$.`);
+};
+const getHint = () => {
+    return `Détermine les valeurs possibles $x_i$ que peut prendre $X$. Puis, pour chaque valeur, calcule la probabilité $p_i$ associée.`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const table = getRandomVariableSituation(params).getVA().getLawMdTable();
+    switch (params.id) {
+        case "coin":
+            return `On liste toutes les issues possibles : 
+      
+- $2$ piles : le gain du joueur est alors $${multiply(2, params.a).toSimplificationTex()}$ points. De plus, la probabilité d'obtenir $2$ piles est  : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{4}
+$$
+
+- $1$ pile, $1$ face : le gain du joueur est alors $${substract(params.a, params.b).toSimplificationTex()}$ points. De plus, il y a deux possibilités pour réaliser cette issue : obtenir pile au premier lancer puis face au deuxième, ou obtenir face au premier lance puis pile au deuxième. La probabilité de cette issue est donc : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} + \\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{2}
+$$
+
+
+- $2$ faces: le gain du joueur est alors $${opposite(multiply(2, params.b)).toSimplificationTex()}$ points. De plus, la probabilité d'obtenir $2$ piles est  : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{4}
+$$
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+
+`;
+        case "urne": {
+            const total = params.n + params.r + params.b;
+            return `On s'intéresse à chaque issue : 
+
+- Tirer une boule blanche : le gain algébrique est $${params.gb}$, et la probabilité vaut $${frac(params.b, total).toSimplificationTex()}$ ; 
+- Tirer une boule rouge : le gain algébrique est $${params.gr}$, et la probabilité vaut $${frac(params.r, total).toSimplificationTex()}$ ; 
+- Tirer une boule noire : le gain algébrique est $${params.gn}$, et la probabilité vaut $${frac(params.n, total).toSimplificationTex()}$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        case "diceMultiple": {
+            const multiples = [];
+            for (let i = 1; i < params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            return `Les faces du dés qui sont des multiples de $${params.winningMultiple}$ sont : $${multiples.join("\\ ; \\ ")}$.
+      
+La probabilité d'obtenir un multiple de $${params.winningMultiple}$ est donc $${frac(multiples.length, params.n).toSimplificationTex()}$, et dans ce cas on gagne $${params.gain}\\ €$.
+
+La probabilité de ne pas obtenir un multiple de $${params.winningMultiple}$ est alors $${frac(params.n - multiples.length, params.n).toSimplificationTex()}$, et dans ce cas on perd $${params.loss}\\ €$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        case "cards": {
+            return `On s'intéresse à chaque issue : 
+
+- Tirer un as : le gain algébrique est $${params.gAs}$, et la probabilité vaut $${frac(4, 52).toSimplificationTex()}$ ; 
+- Tirer une figure: le gain algébrique est $${params.gFigure}$, et la probabilité vaut $${frac(12, 52).toSimplificationTex()}$ ; 
+- Tirer une autre carte : le gain algébrique est $${params.gOther}$, et la probabilité vaut $${frac(36, 52).toSimplificationTex()}$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        //     case "diceSum": {
+        //       const results = [["\\ ", "1", "2", "3", "4"], ["1"], ["2"], ["3"], ["4"]];
+        //       for (let i = 1; i < 5; i++) {
+        //         for (let j = 1; j < 5; j++) {
+        //           results[i][j] = (i + j).frenchify();
+        //         }
+        //       }
+        //       return `Voici tous les résultats possibles en fonction du résultat de chaque dé :
+        // ${mdTable(results, true)}
+        // Les valeurs possibles pour $X$ sont donc :
+        // ${mdTable(getAnswerTable(identifiers), true)}`;
+        //     }
+    }
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return (xTableLineVEA(ans[0], answerTable[0]) &&
+            xTableLineVEA(ans[1], answerTable[1]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationValuesQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const values = getRandomVariableSituation(params).getVA().xValues;
+    const identifiers = {
+        params,
+        initTable: [
+            [`$x_i$`, ...values.map((_e) => "")],
+            [`$P(X=x_i)$`, ...values.map((_e) => "")],
+        ],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const randomVariableSituationProbabilityLaw = {
+    id: "randomVariableSituationProbabilityLaw",
+    label: "Dresser la loi de probabilité d'une variable aléatoire avec contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    getAnswerTable,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationStandardDeviation.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationStandardDeviation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationStandardDeviation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableSituationStandardDeviation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA6HF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationStandardDeviation.js

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, sqrt(RationalConstructor.randomIrreductible(30).toTree())
+            .simplify()
+            .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getStandardDeviation().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Que vaut l'écart-type $\\sigma(X)$ de $X$ ?
+
+Donner la valeur exacte ou une valeur arrondie au centième.`);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$
+
+La variance $V(X)$ s'obtient par la formule :
+  
+$$
+V(X) = p_1(x_1-E(X))^2 + \\ldots + p_n(x_n-E(X))^2
+$$
+
+Et enfin, l'écart-type est la racine carrée de la variance : 
+
+$$
+\\sigma(X) = \\sqrt{V(X)}
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", va.getAverage().toTex()],
+        ["", "=", va.getAverage().simplify().toTex()],
+    ])}
+  
+Puis la variance : 
+
+${alignTex([
+        ["V(X)", "=", va.getVariance().toTex()],
+        ["", "=", va.getVariance().simplify().toTex()],
+    ])}
+
+Enfin, on en déduit l'écart type : 
+
+${alignTex([
+        ["\\sigma(X)", "=", "\\sqrt{V(X)}"],
+        ["", "=", va.getStandardDeviation().simplify().toTex()],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return rationalVEA(ans, answer) || parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const randomVariableSituationStandardDeviation = {
+    id: "randomVariableSituationStandardDeviation",
+    connector: "=",
+    label: "Calculer l'écart-type $\\sigma(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationValues.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationValues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableSituationValues.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAuPF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationValues.js

@@ -0,0 +1,211 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/randomVariableSituations.js";
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return new DiscreteSetNode(va.xValues).simplify().toTex();
+};
+const getPropositions = (_n, { answer, params }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (params.id) {
+        case "coin":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(["\\text{Pile}".toTree(), "\\text{Face}".toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), (-params.b).toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            break;
+        case "urne":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                "\\text{Blanche}".toTree(),
+                "\\text{Rouge}".toTree(),
+                "\\text{Noire}".toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.b.toTree(),
+                params.r.toTree(),
+                params.n.toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.gb.toTree(),
+                params.gr.toTree(),
+                (-params.gn).toTree(),
+            ])
+                .simplify()
+                .toTex());
+            break;
+        case "diceMultiple": {
+            const allValues = [...Array(params.n).keys()].map((i) => i + 1);
+            const multiples = [];
+            for (let i = 1; i < params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            tryToAddWrongProp(propositions, new DiscreteSetNode(multiples.map((m) => m.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(allValues.map((v) => v.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.gain.toTree(), params.loss.toTree()])
+                .simplify()
+                .toTex());
+        }
+    }
+    return shuffle(propositions);
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Quel est l'ensemble des valeurs possibles pour $X$ ?`);
+};
+const getHint = (identifiers) => {
+    const { params } = identifiers;
+    switch (params.id) {
+        case "coin":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd des points) en fonction du résultat de ses lancers. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "urne":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la boule qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "diceMultiple":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la face obtenue. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "cards":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la carte qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        // case "diceSum":
+        //   return `Chaque dé peut valoir $1$, $2$, $3$ ou $4$. Cela créé donc $16$ résultats possibles, par exemple $1+1=2$, $3+4=7$, etc... Détermine tous les résultats possibles.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    switch (params.id) {
+        case "coin":
+            return `On liste toutes les issues possibles : 
+      
+- $2$ piles : le gain du joueur est alors $${multiply(2, params.a).toSimplificationTex()}$ points.
+- $1$ pile, $1$ face : le gain du joueur est alors $${substract(params.a, params.b).toSimplificationTex()}$ points.
+- $2$ faces: le gain du joueur est alors $${opposite(multiply(2, params.b)).toSimplificationTex()}$ points.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+        case "urne":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gb}$ si on tire une boule blanche ; 
+- $${params.gr}$ si on tire une boule rouge ;
+- $${params.gn}$ si on tire une boule noire.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "diceMultiple":
+            return `Si on obtient un multiple de $${params.winningMultiple}$, on gagne $${params.gain}\\ €$, donc $X$ vaut $${params.gain}$ dans ce cas. Sinon, on perd $${params.loss}\\ €$, donc $X$ vaut $-${params.loss}$. 
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "cards":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gAs}$ si on tire un as ; 
+- $${params.gFigure}$ si on tire une figure ;
+- $${params.gOther}$ si on tire une autre carte.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        //     case "diceSum": {
+        //       const results = [["\\ ", "1", "2", "3", "4"], ["1"], ["2"], ["3"], ["4"]];
+        //       for (let i = 1; i < 5; i++) {
+        //         for (let j = 1; j < 5; j++) {
+        //           results[i][j] = (i + j).frenchify();
+        //         }
+        //       }
+        //       return `Voici tous les résultats possibles en fonction du résultat de chaque dé :
+        // ${mdTable(results, true)}
+        // Les valeurs possibles pour $X$ sont donc :
+        // ${mdTable(getAnswerTable(identifiers), true)}`;
+        //     }
+    }
+};
+const getKeys = () => {
+    return ["lbrace", "semicolon", "rbrace"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationValuesQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const randomVariableSituationValues = {
+    id: "randomVariableSituationValues",
+    label: "Donner l'ensemble des valeurs possibles d'une variable aléatoire avec contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationVariance.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationVariance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationVariance.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableSituationVariance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA4GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/randomVariableSituationVariance.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleWithSign().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getVariance().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Que vaut la variance $V(X)$ de $X$ ?
+
+Donner la valeur exacte ou une valeur arrondie au centième.`);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$
+
+La variance $V(X)$ s'obtient par la formule :
+  
+$$
+V(X) = p_1(x_1-E(X))^2 + \\ldots + p_n(x_n-E(X))^2
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", va.getAverage().toTex()],
+        ["", "=", va.getAverage().simplify().toTex()],
+    ])}
+  
+Enfin, on calcule la variance : 
+
+${alignTex([
+        ["V(X)", "=", va.getVariance().toTex()],
+        ["", "=", va.getVariance().simplify().toTex()],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const randomVariableSituationVariance = {
+    id: "randomVariableSituationVariance",
+    connector: "=",
+    label: "Calculer la variance $V(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.js

@@ -25,7 +25,7 @@ const getInstruction = (identifiers) => {
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
     return `Soit $X$ une variable aléatoire dont la loi de probabilités est donnée ci-dessous.
 
-${va.getLawTable()}
+${va.getLawMdTable()}
 
 Que vaut l'écart type $\\sigma(X)$ de $X$ ?
 

package/lib/exercises/math/probaStat/randomVariable/randomVariableVariance.js

@@ -27,7 +27,7 @@ const getInstruction = (identifiers) => {
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
     return `Soit $X$ une variable aléatoire dont la loi de probabilités est donnée ci-dessous.
 
-${va.getLawTable()}
+${va.getLawMdTable()}
 
 Que vaut la variance $V(X)$ de $X$ ?