math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/probaStat/basicProbas/expectedValueOfSumFromDice.js

@@ -0,0 +1,163 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { arrNbSide } = identifiers;
+    const [nbSidesX, nbSidesY] = arrNbSide;
+    return `On lance un dé classique à $${nbSidesX.frenchify()}$ faces et un dé classique à $${nbSidesY.frenchify()}$ faces. 
+On note $S$ la variable aléatoire qui donne la somme des deux résultats. 
+Calculer l'espérance de $S$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNbSide } = identifiers;
+    const [nbSidesX, nbSidesY] = arrNbSide;
+    const [nodeEXForResult, nodeEYForResult] = [nbSidesX, nbSidesY].map((nbSides) => frac(add(nbSides, 1).simplify(), 2));
+    const EXPlusY = add(nodeEXForResult, nodeEYForResult);
+    return EXPlusY;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = () => {
+    return `Soient $X$ et $Y$ les variables aléatoires associées à chaque dé.
+  
+Calcule d'abord $E(X)$ et $E(Y)$ :
+
+$E(X)$ est la somme des produits des valeurs de $X$ par leur probabilité.
+
+Calcule ensuite $E(X+Y)$ :
+
+$$
+E(X+Y) = E(X) + E(Y)
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { arrNbSide } = identifiers;
+    const [nbSidesX, nbSidesY] = arrNbSide;
+    const [nodeEXForResult, nodeEYForResult] = [nbSidesX, nbSidesY].map((nbSides) => frac(add(nbSides, 1).simplify(), 2));
+    const [texEX1, texEY1] = zip(["X", "Y"], [nbSidesX, nbSidesY]).map(([letter, nbSides]) => {
+        const letterLowercase = letter.toLocaleLowerCase();
+        const letterUppercase = letter.toLocaleUpperCase();
+        return `\\displaystyle \\sum_{i=1}^{i=${nbSides}} ${letterLowercase}_{i} P(${letterUppercase} = ${letterLowercase}_{i})`;
+    });
+    const [texEX2, texEY2] = zip(["X", "Y"], [nbSidesX, nbSidesY]).map(([letter, nbSides]) => {
+        const letterLowercase = letter.toLocaleLowerCase();
+        return `\\displaystyle \\sum_{i=1}^{i=${nbSides}} ${letterLowercase}_{i} \\frac{1}{${nbSides}}`;
+    });
+    const [texEX3, texEY3] = zip(["X", "Y"], [nbSidesX, nbSidesY]).map(([_letter, nbSides]) => {
+        return `\\frac{1}{${nbSides}} \\displaystyle \\sum_{i=1}^{i=${nbSides}} i`;
+    });
+    const [texEX4, texEY4] = zip(["X", "Y"], [nbSidesX, nbSidesY]).map(([_letter, nbSides]) => {
+        return `\\frac{1}{${nbSides}} \\times \\frac{${nbSides} \\times ${nbSides + 1}}{2}`;
+    });
+    const nodeEXPlusY = add(nodeEXForResult, nodeEYForResult);
+    return `On note $X$ et $Y$ les variables aléatoires associées à chaque dé.
+  
+On a :
+  
+${alignTex([
+        ["", "E(X)"],
+        ["=", texEX1],
+        ["=", texEX2],
+        ["=", texEX3],
+        ["=", texEX4],
+        ["=", nodeEXForResult.toTex()],
+    ])}
+  
+${alignTex([
+        ["", "E(Y)"],
+        ["=", texEY1],
+        ["=", texEY2],
+        ["=", texEY3],
+        ["=", texEY4],
+        ["=", nodeEYForResult.toTex()],
+    ])}
+
+Par conséquent :
+
+${alignTex([
+        ["S", "=", "E(X+Y)"],
+        ["", "=", "E(X)+E(Y)"],
+        ["", "=", nodeEXPlusY.toTex()],
+        ["", "=", nodeEXPlusY.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const arrNbSide = randomMany([4, 6, 8, 10, 12, 20], 2);
+    const identifiers = {
+        arrNbSide,
+    };
+    return identifiers;
+};
+const getExpectedValueOfSumFromDiceQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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 expectedValueOfSumFromDice = {
+    id: "expectedValueOfSumFromDice",
+    connector: "=",
+    label: "Calculer l'espérance d'une somme de lancers de dés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpectedValueOfSumFromDiceQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/basicProbas/expectedValueOfSumFromProbaLaw.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type RVIds = {
+    xValuesIds: NodeIdentifiers[];
+    yValuesIds: NodeIdentifiers[];
+    name: string;
+};
+type Identifiers = {
+    rvIdsX: RVIds;
+    rvIdsY: RVIds;
+};
+export declare const expectedValueOfSumFromProbaLaw: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=expectedValueOfSumFromProbaLaw.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/expectedValueOfSumFromProbaLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectedValueOfSumFromProbaLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/expectedValueOfSumFromProbaLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAmBF,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;CACf,CAAC;AAuIF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/expectedValueOfSumFromProbaLaw.js

@@ -0,0 +1,150 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RandomVariable, RandomVariableConstructor, } from "../../../../math/probability/randomVariable.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const createRVIds = (rv) => {
+    return {
+        xValuesIds: rv.xValues.map((e) => e.toIdentifiers()),
+        yValuesIds: rv.yValues.map((e) => e.toIdentifiers()),
+        name: rv.name,
+    };
+};
+const rvFromIds = (rvIds) => {
+    const { xValuesIds, yValuesIds } = rvIds;
+    return new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)), rvIds.name);
+};
+const getHydrated = (identifiers) => {
+    const { rvIdsX, rvIdsY } = identifiers;
+    const [rvX, rvY] = [rvIdsX, rvIdsY].map((rvIds) => rvFromIds(rvIds));
+    const [EX, EY] = [rvX, rvY].map((rv) => rv.getAverage());
+    const EXPlusY = add(EX.simplify(), EY.simplify());
+    return {
+        rvX,
+        rvY,
+        EX,
+        EY,
+        EXPlusY,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { rvX, rvY } = getHydrated(identifiers);
+    return `Soient $X$ et $Y$ deux variables aléatoires dont les lois de probabilités sont données ci-dessous :
+
+${rvX.getLawMdTable()}
+
+${rvY.getLawMdTable()}
+
+Que vaut $E(X+Y)$ ?
+`;
+};
+const getAnswer = (identifiers) => {
+    const { EXPlusY } = getHydrated(identifiers);
+    return EXPlusY.simplify().toTex();
+};
+const getHint = () => {
+    return `Calcule d'abord $E(X)$ et $E(Y)$ :
+
+$E(X)$ est la somme des produits des valeurs de $X$ par leur probabilité.
+
+Calcule ensuite $E(X+Y)$ :
+
+$$
+E(X+Y) = E(X) + E(Y)
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { EX, EY, EXPlusY } = getHydrated(identifiers);
+    return `On a :
+  
+${alignTex([
+        ["", "E(X)"],
+        ["=", EX.toTex()],
+        ["=", EX.simplify().toTex()],
+    ])}
+  
+${alignTex([
+        ["", "E(Y)"],
+        ["=", EY.toTex()],
+        ["=", EY.simplify().toTex()],
+    ])}
+
+Par conséquent :
+
+$$
+E(X+Y) = E(X) + E(Y) = ${EXPlusY.toTex()} = ${EXPlusY.simplify().toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const rvX = RandomVariableConstructor.random("X", 3);
+    const rvY = RandomVariableConstructor.random("Y", 3);
+    const identifiers = {
+        rvIdsX: createRVIds(rvX),
+        rvIdsY: createRVIds(rvY),
+    };
+    return identifiers;
+};
+const getExpectedValueOfSumFromProbaLawQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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 expectedValueOfSumFromProbaLaw = {
+    id: "expectedValueOfSumFromProbaLaw",
+    connector: "=",
+    label: "Calculer l'espérance d'une somme de variables aléatoires à partir des lois de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpectedValueOfSumFromProbaLawQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -12,4 +12,9 @@ export * from "./getMissingProbabilityValueMiddleSchool.js";
 export * from "./findEffectifFromProba.js";
 export * from "./calculateProbaFromProbaLaw.js";
 export * from "./pickEquiprobableSituations.js";
+export * from "./expectedValueOfSumFromProbaLaw.js";
+export * from "./expectedValueOfLinearCombination.js";
+export * from "./varianceOfLinearCombination.js";
+export * from "./expectedValueOfSumFromDice.js";
+export * from "./varianceOfMean.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,qCAAqC,CAAC;AACpD,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC"}

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

@@ -12,3 +12,8 @@ export * from "./getMissingProbabilityValueMiddleSchool.js";
 export * from "./findEffectifFromProba.js";
 export * from "./calculateProbaFromProbaLaw.js";
 export * from "./pickEquiprobableSituations.js";
+export * from "./expectedValueOfSumFromProbaLaw.js";
+export * from "./expectedValueOfLinearCombination.js";
+export * from "./varianceOfLinearCombination.js";
+export * from "./expectedValueOfSumFromDice.js";
+export * from "./varianceOfMean.js";

package/lib/exercises/math/probaStat/basicProbas/varianceOfLinearCombination.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsV: NodeIdentifiers[];
+    nodeIdsCoeff: NodeIdentifiers[];
+};
+type Options = {
+    typeLinearCombination: string;
+};
+export declare const varianceOfLinearCombination: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=varianceOfLinearCombination.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/varianceOfLinearCombination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varianceOfLinearCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/varianceOfLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC,CAAC;AAkNF,KAAK,OAAO,GAAG;IACb,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAgBF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBtE,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/varianceOfLinearCombination.js

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsV, nodeIdsCoeff } = identifiers;
+    const [nodeVX, nodeVY, nodeCoeffX, nodeCoeffY] = [
+        ...nodeIdsV,
+        ...nodeIdsCoeff,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texV = `V(${add(multiply(nodeCoeffX, new VariableNode("X")), multiply(nodeCoeffY, new VariableNode("Y")))
+        .simplify({ towardsDistribute: true })
+        .toTex({})})`;
+    const nodeLinearCombinationForTex = nodeCoeffY.evaluate() !== 0
+        ? add(multiply(square(nodeCoeffX), new VariableNode("V(X)")), multiply(square(nodeCoeffY), new VariableNode("V(Y)")))
+        : multiply(square(nodeCoeffX), new VariableNode("V(X)"));
+    const nodeLinearCombinationForResult = nodeCoeffY.evaluate() !== 0
+        ? add(multiply(square(nodeCoeffX), nodeVX), multiply(nodeCoeffY, nodeVY))
+        : multiply(square(nodeCoeffX), nodeVX);
+    return {
+        nodeVX,
+        nodeVY,
+        nodeCoeffX,
+        nodeCoeffY,
+        texV,
+        nodeLinearCombinationForTex,
+        nodeLinearCombinationForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeVX, nodeVY, texV } = getHydrated(identifiers);
+    return `Soient $X$ et $Y$ deux variables aléatoires dont les variances sont données ci-dessous :
+
+$$
+V(X) = ${nodeVX.toTex()}
+$$
+
+$$
+V(Y) = ${nodeVY.toTex()}
+$$
+
+Que vaut $${texV}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeLinearCombinationForResult } = getHydrated(identifiers);
+    return nodeLinearCombinationForResult.simplify().toTex();
+};
+const getHint = () => {
+    return `Soit $a$ et $b$ deux réels :
+$$
+V(aX+bY) = a^2 \\ V(X) + b^2 \\ V(Y)
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { texV, nodeLinearCombinationForTex, nodeLinearCombinationForResult } = getHydrated(identifiers);
+    return `
+  
+${alignTex([
+        ["", texV],
+        ["=", nodeLinearCombinationForTex.toTex({ forceTimesSign: true })],
+        ["=", nodeLinearCombinationForResult.toTex()],
+        ["=", nodeLinearCombinationForResult.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeIdsV, nodeIdsCoeff } = identifiers;
+    const [nodeVX, nodeVY, nodeCoeffX, nodeCoeffY] = [
+        ...nodeIdsV,
+        ...nodeIdsCoeff,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    //student: a V(X) + b V(Y)
+    {
+        const nodeLinearCombinationForResultWrong = nodeCoeffY.evaluate() !== 0
+            ? add(multiply(nodeCoeffX, nodeVX), multiply(nodeCoeffY, nodeVY))
+            : multiply(nodeCoeffX, nodeVX);
+        tryToAddWrongProp(propositions, nodeLinearCombinationForResultWrong.simplify().toTex());
+    }
+    //student: -a² V(X) + b V(Y)
+    if (nodeCoeffX.evaluate() < 0) {
+        const nodeLinearCombinationForResultWrong = nodeCoeffY.evaluate() !== 0
+            ? add(multiply(opposite(square(nodeCoeffX)), nodeVX), multiply(nodeCoeffY, nodeVY))
+            : multiply(opposite(square(nodeCoeffX)), nodeVX);
+        tryToAddWrongProp(propositions, nodeLinearCombinationForResultWrong.simplify().toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const { typeLinearCombination } = opts;
+    const [nodeVX, nodeVY] = [...Array(2).keys()].map(() => randfloat(1, 10, 2).toTree());
+    const [nodeCoeffX, nodeCoeffY] = (() => {
+        switch (typeLinearCombination) {
+            case "aX": {
+                return [randint(-5, 5, [0, 1]).toTree(), (0).toTree()];
+            }
+            case "X+Y": {
+                return [(1).toTree(), (1).toTree()];
+            }
+            case "aX+Y": {
+                return [randint(-5, 5, [0, 1]).toTree(), (1).toTree()];
+            }
+            default:
+                throw new Error("Unsupported typeLinearCombination: " + typeLinearCombination);
+        }
+    })();
+    const identifiers = {
+        nodeIdsV: [nodeVX, nodeVY].map((node) => node.toIdentifiers()),
+        nodeIdsCoeff: [nodeCoeffX, nodeCoeffY].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getVarianceOfLinearCombinationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const optsDefault = {
+    typeLinearCombination: "aX+Y",
+};
+const options = [
+    {
+        id: "typeLinearCombination",
+        label: "Type de combinaison linéaire",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["aX", "X+Y", "aX+Y"],
+        defaultValue: optsDefault.typeLinearCombination,
+    },
+];
+export const varianceOfLinearCombination = {
+    id: "varianceOfLinearCombination",
+    connector: "=",
+    label: "Calculer la variance d'une combination linéaire de variables aléatoires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarianceOfLinearCombinationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/basicProbas/varianceOfMean.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsE: NodeIdentifiers;
+    nodeIdsV: NodeIdentifiers;
+    nodeIdsN: NodeIdentifiers;
+};
+type Options = {
+    typeN: string;
+};
+export declare const varianceOfMean: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=varianceOfMean.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/varianceOfMean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varianceOfMean.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/varianceOfMean.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAsKF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzD,CAAC"}