math-exercises 3.0.208 → 3.0.211

package/lib/exercises/math/limits/algorithms/pyLimitProgramExecution.js

@@ -0,0 +1,353 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.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 { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsAbscissa, nodeIdsPrecision, nodeIdsImage } = identifiers;
+    const [nodeF, nodeAbsissa, nodeImage] = [
+        nodeIdsF,
+        nodeIdsAbscissa,
+        nodeIdsImage,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodePrecision = nodeIdsPrecision &&
+        NodeConstructor.fromIdentifiers(nodeIdsPrecision);
+    return {
+        nodeF,
+        nodeAbsissa,
+        nodeImage,
+        nodePrecision,
+    };
+};
+const getStrPythonProgram = (identifiers) => {
+    const { abscissaType, imageType } = identifiers;
+    const { nodeF, nodeAbsissa, nodeImage, nodePrecision } = getHydrated(identifiers);
+    const [strAbscissa, strImage] = [nodeAbsissa, nodeImage].map((node) => createStrPythonForNode(node));
+    const strPrecision = nodePrecision && createStrPythonForNode(nodePrecision);
+    return `def f(x):
+    return ${createStrPythonForNode(nodeF)}
+    
+${(() => {
+        switch (abscissaType) {
+            case "$-\\infty$":
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = 0
+while abs(f(x)) < 10000 :
+  x = x - 10`;
+                    case "$x \\in \\mathbb{R}$":
+                        return `x = 0
+while abs(f(x) - ${strImage}) > ${strPrecision} :
+  x = x - 10`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            case "$+\\infty$": {
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = 0
+while abs(f(x)) < 10000 :
+  x = x + 10`;
+                    case "$x \\in \\mathbb{R}$":
+                        return `x = 0
+while abs(f(x) - ${strImage}) > ${strPrecision} :
+  x = x + 10`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            }
+            case "$x \\in \\mathbb{R}$": {
+                switch (imageType) {
+                    case "$-\\infty$":
+                    case "$+\\infty$":
+                        return `x = ${strAbscissa} + 1
+while abs(f(x)) < 10000 :
+  x = x - 0.01`;
+                    default:
+                        throw new Error("Unsupported imageType: " + imageType);
+                }
+            }
+            default:
+                throw new Error("Unsupported abscissaType: " + abscissaType);
+        }
+    })()}`;
+};
+const getXValueForPythonProgram = (identifiers) => {
+    const { abscissaType, imageType } = identifiers;
+    const { nodeF, nodeAbsissa, nodeImage, nodePrecision } = getHydrated(identifiers);
+    switch (abscissaType) {
+        case "$-\\infty$":
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                case "$x \\in \\mathbb{R}$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x }) - nodeImage.evaluate()) >
+                        nodePrecision.evaluate()) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        case "$+\\infty$":
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                case "$x \\in \\mathbb{R}$": {
+                    let x = 0;
+                    while (Math.abs(nodeF.evaluate({ x }) - nodeImage.evaluate()) >
+                        nodePrecision.evaluate()) {
+                        x = x - 10;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        case "$x \\in \\mathbb{R}$": {
+            switch (imageType) {
+                case "$-\\infty$":
+                case "$+\\infty$": {
+                    let x = nodeAbsissa.evaluate() + 1;
+                    while (Math.abs(nodeF.evaluate({ x })) < 10000) {
+                        x = x - 0.01;
+                    }
+                    return x;
+                }
+                default:
+                    throw new Error("Unsupported imageType: " + imageType);
+            }
+        }
+        default:
+            throw new Error("Unsupported abscissaType: " + abscissaType);
+    }
+};
+const getInstruction = (identifiers) => {
+    return `On considère le script suivant en langage Python. Quelle valeur contient la variable $x$ après son exécution ?
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    return codifyChunk(createStrPythonForNode(getXValueForPythonProgram(identifiers).toTree()));
+};
+const getHint = (_identifiers) => {
+    return "Trouve la valeur qui semble la plus probable dans la liste des valeurs proposées.";
+};
+const getCorrection = (identifiers) => {
+    return `La valeur de $x$ quand on exécute le script est $${getAnswer(identifiers)}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, getAnswer(identifiers), "raw");
+    const { nodeAbsissa } = getHydrated(identifiers);
+    const x = getXValueForPythonProgram(identifiers);
+    if (nodeAbsissa.toTex() === "+\\infty") {
+        [
+            (-8000).toTree(),
+            (-4290).toTree(),
+            (-19800).toTree(),
+            randint(-50, 50, [0]).toTree(),
+        ].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    else if (nodeAbsissa.toTex() === "-\\infty") {
+        [
+            (+8000).toTree(),
+            (+4290).toTree(),
+            (+19800).toTree(),
+            randint(-50, 50, [0]).toTree(),
+        ].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    else {
+        [(8000).toTree(), (-8000).toTree(), (-x).toTree()].forEach((node) => {
+            tryToAddWrongProp(propositions, codifyChunk(createStrPythonForNode(node)), "raw");
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getPyLimitProgramExecutionQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const pool = getCartesiansProducts([
+        arrayedOpts.abscissaType,
+        arrayedOpts.imageType,
+    ]).filter(([abscissaType, imageType]) => {
+        return !(abscissaType === "$x \\in \\mathbb{R}$" &&
+            imageType === "$x \\in \\mathbb{R}$");
+    });
+    const [abscissaType, imageType] = random(pool);
+    const [nodeF, nodeAbsissa, nodeImage, nodePrecision] = (() => {
+        const nodeVarX = new VariableNode("x");
+        switch (abscissaType) {
+            case "$-\\infty$":
+            case "$+\\infty$": {
+                const nodeAbsissa = abscissaType === "$-\\infty$" ? PlusInfinityNode : MinusInfinityNode;
+                const [nodeF, nodeImage, nodePrecision] = (() => {
+                    switch (imageType) {
+                        case "$-\\infty$": {
+                            const nodePrecision = random([0.1, 0.01, 0.001]).toTree();
+                            const nodeF = (() => {
+                                const [a, b, c, d] = [...Array(4).keys()].reduce((acc, _i) => {
+                                    acc = [...acc, randint(1, 10, acc)];
+                                    return acc;
+                                }, []);
+                                const nodeNum = add(multiply(-a, square(nodeVarX)), b);
+                                const nodeDen = add(multiply(c, nodeVarX), d);
+                                return frac(nodeNum, nodeDen);
+                            })();
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage, nodePrecision];
+                        }
+                        case "$x \\in \\mathbb{R}$": {
+                            const nodeImage = randint(-50, 51).toTree();
+                            const a = randint(-9, 10, [0]);
+                            const nodeF = add(nodeImage, frac(a, nodeVarX));
+                            return [nodeF, nodeImage, undefined];
+                        }
+                        case "$+\\infty$": {
+                            const nodePrecision = random([0.1, 0.01, 0.001]).toTree();
+                            const nodeF = (() => {
+                                const [a, b, c, d] = [...Array(4).keys()].reduce((acc, _i) => {
+                                    acc = [...acc, randint(1, 10, acc)];
+                                    return acc;
+                                }, []);
+                                const nodeNum = add(multiply(+a, square(nodeVarX)), b);
+                                const nodeDen = add(multiply(c, nodeVarX), d);
+                                return frac(nodeNum, nodeDen);
+                            })();
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage, nodePrecision];
+                        }
+                        default:
+                            throw new Error("Unsupported imageType: " + imageType);
+                    }
+                })();
+                return [nodeF, nodeAbsissa, nodeImage, nodePrecision];
+            }
+            case "$x \\in \\mathbb{R}$": {
+                const nodeAbsissa = randint(-50, 51).toTree();
+                const [nodeF, nodeImage] = (() => {
+                    switch (imageType) {
+                        case "$-\\infty$": {
+                            const a = randint(-9, 0);
+                            const nodeF = frac(a, square(substract(nodeVarX, nodeAbsissa)));
+                            const nodeImage = MinusInfinityNode;
+                            return [nodeF, nodeImage];
+                        }
+                        case "$+\\infty$": {
+                            const a = randint(1, 10);
+                            const nodeF = frac(a, square(substract(nodeVarX, nodeAbsissa)));
+                            const nodeImage = PlusInfinityNode;
+                            return [nodeF, nodeImage];
+                        }
+                        default:
+                            throw new Error("Unsupported imageType: " + imageType);
+                    }
+                })();
+                return [nodeF, nodeAbsissa, nodeImage, undefined];
+            }
+            default:
+                throw new Error("Unsupported abscissaType: " + abscissaType);
+        }
+    })();
+    const identifiers = {
+        abscissaType,
+        imageType,
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsAbscissa: nodeAbsissa.toIdentifiers(),
+        nodeIdsImage: nodeImage.toIdentifiers(),
+        nodeIdsPrecision: nodePrecision?.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    abscissaType: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+    imageType: ["$-\\infty$", "$+\\infty$"],
+};
+const options = [
+    {
+        id: "abscissaType",
+        label: "Type d'abscisse",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+        defaultValue: arrayedOptsDefault.abscissaType,
+    },
+    {
+        id: "imageType",
+        label: "Type d'image",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$-\\infty$", "$x \\in \\mathbb{R}$", "$+\\infty$"],
+        defaultValue: arrayedOptsDefault.imageType,
+    },
+];
+export const pyLimitProgramExecution = {
+    id: "pyLimitProgramExecution",
+    label: "Exécuter un script Python de manifestation d'une limite de fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyLimitProgramExecutionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getInstruction,
+    getHint,
+    getCorrection,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -7,4 +7,5 @@ export * from "./frac1XTimesALogXPlusBLimit.js";
 export * from "./kLogXPlusTrinomLimit.js";
 export * from "./logOfPolynomialLimit.js";
 export * from "./sequences/index.js";
+export * from "./algorithms/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AAEvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AAEvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AAErC,cAAc,uBAAuB,CAAC"}

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

@@ -7,3 +7,4 @@ export * from "./frac1XTimesALogXPlusBLimit.js";
 export * from "./kLogXPlusTrinomLimit.js";
 export * from "./logOfPolynomialLimit.js";
 export * from "./sequences/index.js";
+export * from "./algorithms/index.js";

package/lib/exercises/math/probaStat/density/findParamToMakeDensity.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const findParamToMakeDensity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findParamToMakeDensity.d.ts.map

package/lib/exercises/math/probaStat/density/findParamToMakeDensity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findParamToMakeDensity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/density/findParamToMakeDensity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAyHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

package/lib/exercises/math/probaStat/density/findParamToMakeDensity.js

@@ -0,0 +1,127 @@
+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 { randint } from "../../../../math/utils/random/randint.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";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleProba().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    // k = 2/(b^2-a^2)
+    return frac(2, substract(b ** 2, a ** 2))
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `On considère la fonction $f$ définie sur $I = [${a};${b}]$ par :
+  
+$$
+f(t) = kt
+$$
+
+où $k$ est un réel strictement positif.
+
+Déterminer la valeur de $k$ pour que $f$ soit une densité de probabilité sur $I$.`;
+};
+const getHint = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Une fonction $f$ est une densité de probabilité sur un intervalle $[a;b]$ si et seulement si $f$ est continue et positive sur $[a;b]$ et :
+  
+$$
+\\int_{a}^{b} f(x)\\ \\mathrm{d}x = 1
+$$
+
+Ici, il faut donc vérifier que $f$ est continue et positive sur $[${a};${b}]$ et déterminer la valeur de $k$ pour laquelle :
+
+$$
+\\int_{${a}}^{${b}} kt\\ \\mathrm{d}t = 1
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const k = frac(2, substract(b ** 2, a ** 2)).simplify();
+    return `$f$ est une fonction affine, elle est donc continue sur $[${a};${b}]$. Puisque $k$ est positif, $f$ est également positive sur $[${a};${b}]$.
+
+Une primitive de $f$ sur $[${a};${b}]$ est :
+
+$$
+F(t) = \\frac{k}{2}t^2 
+$$
+  
+On intègre alors $f$ sur $[${a};${b}]$ :
+
+$$
+\\int_{${a}}^{${b}} f(t)\\ \\mathrm{d}t = F(${b})-F(${a}) = \\frac{k}{2}(${b}^2-${a}^2)
+$$
+
+On doit donc résoudre l'équation suivante : 
+
+$$
+${multiply(b ** 2 - a ** 2, frac("k", 2)).toTex()} = 1
+$$
+
+On trouve $k = ${k.toTex()}$.
+
+La fonction $f$ définie par $f(t) = ${multiply(k, "t").toTex()}$ est donc une densité de probabilité sur $[${a};${b}]$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindParamToMakeDensityQuestion = () => {
+    const a = randint(1, 10);
+    const b = randint(a + 1, a + 8);
+    const identifiers = {
+        a,
+        b,
+    };
+    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 findParamToMakeDensity = {
+    id: "findParamToMakeDensity",
+    connector: "=",
+    label: "Déterminer un paramètre pour qu'une fonction soit une densité de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindParamToMakeDensityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,2 @@
+export * from "./findParamToMakeDensity.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/density/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./findParamToMakeDensity.js";

package/lib/exercises/math/probaStat/exponential/exponentialLawAverage.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    lambda: number;
+};
+export declare const exponentialLawAverage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=exponentialLawAverage.d.ts.map

package/lib/exercises/math/probaStat/exponential/exponentialLawAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialLawAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/exponential/exponentialLawAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

package/lib/exercises/math/probaStat/exponential/exponentialLawAverage.js

@@ -0,0 +1,95 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0.01, 0.9, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { lambda } = identifiers;
+    return round(frac(1, lambda).evaluate(), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { lambda } = identifiers;
+    return `Soit $X$ une variable aléatoire qui suit une loi exponentielle de paramètre $${lambda.frenchify()}$.
+  
+Quelle est l'espérance $E(X)$ de $X$ ? Donner une valeur arrondie au centième.`;
+};
+const getHint = () => {
+    return `L'espérance d'une variable aléatoire $X$ de loi exponentielle de paramètre $\\lambda>0$ est égale à : 
+  
+$$
+E(X) = \\frac{1}{\\lambda}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { lambda } = identifiers;
+    const ans = frac(1, lambda).evaluate();
+    return `L'espérance d'une variable aléatoire $X$ de loi exponentielle de paramètre $\\lambda>0$ est égale à : 
+  
+$$
+E(X) = \\frac{1}{\\lambda}
+$$
+
+Ici, on a donc : 
+
+$$
+E(X) = ${frac(1, lambda).toTex()} ${approxOrEqual(ans, 2).join("")}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExponentialLawAverageQuestion = () => {
+    const lambda = randfloat(0.01, 1, 2);
+    const identifiers = {
+        lambda,
+    };
+    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 exponentialLawAverage = {
+    id: "exponentialLawAverage",
+    connector: "=",
+    label: "Calculer l'espérance d'une loi exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialLawAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/exponential/exponentialLawComputeIntervalProba.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    lambda: number;
+    a: number;
+    b: number;
+};
+export declare const exponentialLawComputeIntervalProba: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=exponentialLawComputeIntervalProba.d.ts.map

package/lib/exercises/math/probaStat/exponential/exponentialLawComputeIntervalProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialLawComputeIntervalProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/exponential/exponentialLawComputeIntervalProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA8GF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAmBpE,CAAC"}