math-exercises 3.0.208 → 3.0.209

package/lib/exercises/math/functions/logarithm/logSimplifiying.js

@@ -2,9 +2,11 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { logn, LogNode } from "../../../../tree/nodes/functions/logNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -21,7 +23,7 @@ const getStatementNode = (identifiers) => {
     }
 };
 const getInstruction = (identifiers) => {
-    return `Écrire le nombre suivant sous la forme $\\ln\\left(a\\right)$ : 
+    return `Écrire le nombre suivant sous la forme $\\ln\\left(a\\right)$, avec $a\\in \\mathbb{R}$ : 
   
 $$
 ${getStatementNode(identifiers).toTex()}
@@ -36,15 +38,50 @@ const getAnswer = (identifiers) => {
         return new LogNode(new Rational(a, b).simplify().toTree()).toTex();
     }
 };
+const getHint = () => {
+    return `Pour tous nombres réels $a$ et $b$ strictement positifs, on a : 
+  
+- $\\ln(a) + \\ln(b) = \\ln(a\\times b)$
+- $\\ln(a) - \\ln(b) = \\ln(\\frac{a}{b})$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, pm } = identifiers;
+    if (pm === 1) {
+        return `On sait que pour tous nombres réels $a$ et $b$ strictement positifs, on a :
+    
+$$
+\\ln(a) + \\ln(b) = \\ln(a\\times b)
+$$
+
+Ici on a donc : 
+
+$$
+\\ln(${a}) + \\ln(${b}) = ${logn(multiply(a, b)).toSimplificationTex()}
+$$`;
+    }
+    else {
+        return `On sait que pour tous nombres réels $a$ et $b$ strictement positifs, on a :
+    
+$$
+\\ln(a) - \\ln(b) = \\ln(\\frac{a}{b})
+$$
+
+Ici on a donc : 
+
+$$
+\\ln(${a}) - \\ln(${b}) = ${logn(frac(a, b)).toSimplificationTex()}
+$$`;
+    }
+};
 const getKeys = () => {
     return ["lnBrackets"];
 };
 const getExpSimplifiying = () => {
     const pm = coinFlip() ? 1 : -1;
-    const a = randint(1, 10);
+    const a = randint(2, 10);
     let b;
     do {
-        b = randint(1, 10);
+        b = randint(2, 10);
     } while (pm === -1 && a === b);
     const identifiers = { pm, a, b };
     return getQuestionFromIdentifiers(identifiers);
@@ -56,6 +93,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -85,7 +124,7 @@ const isAnswerValid = (ans, { a, b, pm }) => {
 export const logSimplifiying = {
     id: "logSimplifiying",
     connector: "\\iff",
-    label: "Simplifier des expressions avec $\\ln$",
+    label: "Utiliser la propriété algébrique du logarithme népérien $\\ln(a) \\pm \\ln(b) = \\ln(ab)$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getExpSimplifiying, nb),
     qcmTimer: 60,
@@ -94,4 +133,5 @@ export const logSimplifiying = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -26,4 +26,5 @@ export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
+export * from "./arithmetic/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AAEvC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/index.js

@@ -27,3 +27,4 @@ export * from "./pcExosInMath.js";
 export * from "./scratch/index.js";
 export * from "./integration/index.js";
 // export * from "./_debug/index.js";
+export * from "./arithmetic/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"}

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

@@ -0,0 +1,115 @@
+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 { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.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, randfloat(0.01, 0.9, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, lambda } = identifiers;
+    return round(substract(exp(-a * lambda), exp(-b * lambda)).evaluate(), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, lambda } = identifiers;
+    return `Soit $X$ une variable aléatoire qui suit une loi exponentielle de paramètre $${lambda.frenchify()}$. 
+  
+Calculer $P(${a}\\leq X\\leq ${b})$.
+
+Donner une valeur approchée au centième.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tous réels 
+  $c$ et $d$ positifs tels que $c\\leq d$,  on a : 
+  
+$$
+P(a\\leq X\\leq b) = e^{-\\lambda a} - e^{-\\lambda b}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, lambda } = identifiers;
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tous réels 
+  $c$ et $d$ positifs tels que $c\\leq d$,  on a : 
+  
+$$
+P(a\\leq X\\leq b) = e^{-\\lambda a} - e^{-\\lambda b}
+$$
+
+Ici, on a donc : 
+
+$$
+P(${a}\\leq X\\leq ${b}) = e^{${multiply(-lambda, a).toTex()}}-e^{${multiply(-lambda, b).toTex()}} \\approx ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExponentialLawComputeProbaQuestion = () => {
+    let lambda;
+    let a;
+    let b;
+    let rounded;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in exponentialLawComputeProba");
+        lambda = randfloat(0.01, 1, 2);
+        a = randint(2, 20);
+        b = randint(a + 5, a + 15);
+        rounded = round(substract(exp(-a * lambda), exp(-b * lambda)).evaluate(), 2);
+    } while (rounded === 0);
+    const identifiers = {
+        lambda,
+        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 exponentialLawComputeIntervalProba = {
+    id: "exponentialLawComputeIntervalProba",
+    connector: "=",
+    label: "Calculer une probabilité du type $P(a\\leq X\\leq b)$ pour une loi exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialLawComputeProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"exponentialLawComputeProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/exponential/exponentialLawComputeProba.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;CAEX,CAAC;AAkGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

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

@@ -0,0 +1,110 @@
+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 { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.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, randfloat(0.01, 0.9, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return round(substract(1, exp(-k * lambda)).evaluate(), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return `Soit $X$ une variable aléatoire qui suit une loi exponentielle de paramètre $${lambda.frenchify()}$. 
+  
+Calculer $P(X\\leq ${k})$.
+
+Donner une valeur approchée au centième.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tout réel $t\\geq 0$, on a : 
+  
+$$
+P(X\\leq t) = 1-e^{-\\lambda t}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tout réel $t\\geq 0$, on a : 
+  
+$$
+P(X\\leq t) = 1-e^{-\\lambda t}
+$$
+
+Ici, on a donc : 
+
+$$
+P(X\\leq ${k}) = 1-e^{${multiply(-lambda, k).toTex()}} \\approx ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExponentialLawComputeProbaQuestion = () => {
+    let lambda;
+    let k;
+    let rounded;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in exponentialLawComputeProba");
+        lambda = randfloat(0.01, 1, 2);
+        k = randint(2, 20);
+        rounded = round(substract(1, exp(-k * lambda)).evaluate(), 2);
+    } while (rounded === 1);
+    const identifiers = {
+        lambda,
+        k,
+    };
+    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 exponentialLawComputeProba = {
+    id: "exponentialLawComputeProba",
+    connector: "=",
+    label: "Calculer une probabilité du type $P(X\\leq t)$ pour une loi exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialLawComputeProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./exponentialLawComputeProba.js";
+export * from "./exponentialLawComputeIntervalProba.js";
+export * from "./exponentialLawAverage.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4BAA4B,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./exponentialLawComputeProba.js";
+export * from "./exponentialLawComputeIntervalProba.js";
+export * from "./exponentialLawAverage.js";

package/lib/exercises/math/probaStat/geometric/geometricLawAverage.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pIds: NodeIdentifiers;
+};
+export declare const geometricLawAverage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricLawAverage.d.ts.map

package/lib/exercises/math/probaStat/geometric/geometricLawAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricLawAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/geometric/geometricLawAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA8GF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}