math-exercises 3.0.207 → 3.0.209

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

@@ -3,18 +3,20 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
 import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
-import { Log10Node } from "../../../../tree/nodes/functions/log10Node.js";
-import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { log10, Log10Node } from "../../../../tree/nodes/functions/log10Node.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 { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { frac, FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power, PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
 import { equationSolutionParser } from "../../../../tree/parsers/equationSolutionParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 /**a*b^x+c=d */
 const getKeys = (_identifiers, opts) => {
     const keys = ["x", "equal", "S", "lbrace", "semicolon", "rbrace"];
@@ -44,12 +46,55 @@ const getAnswer = (identifiers, opts) => {
 };
 const getLogPowerEquationQuestion = (opts) => {
     const powered = randint(2, 8);
-    const a = randint(1, 10, [powered]);
+    const a = randint(2, 10, [powered]);
     const c = randint(-5, 5, [a]);
     const k = randint(5, 15, [powered]);
     const identifiers = { a, c, k, powered, isLog10: opts?.isLog10 ?? false };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
+const getHint = (identifiers, opts) => {
+    const logString = opts?.isLog10 ? "\\log" : "\\ln";
+    const { powered } = identifiers;
+    const powerN = power(powered, "x");
+    return `Commence par isoler $${powerN.toTex()}$ d'un côté de l'équation.
+
+Puis, applique le logarithme sur les deux membres de l'équation. 
+
+Cela te permettra d'obtenir la solution, en utilisant la propriété suivante : pour tout nombre réel $a>0$ et tout nombre réel $b$, 
+
+$$
+${logString}(a^b) = b${logString}(a)
+$$
+`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { a, powered, c, k } = identifiers;
+    const d = k * a + c;
+    const powerN = power(powered, "x");
+    const loga = opts?.isLog10 ? log10 : logn;
+    //a*powered^x+c = d
+    //poweerd^x = (d-c)/a
+    const b = frac(substract(d, c), a).simplify();
+    return `On commence par isoler $${powerN.toTex()}$ d'un côté de l'équation : 
+  
+$$
+${powerN.toTex()} = ${frac(substract(d, c), a).toSimplificationTex()}
+$$
+
+Ensuite, on applique le logarithme sur les deux membres de l'équation (ce qui est possible car les deux membres sont strictement positifs), et on utilise la propriété $${loga("a^x").toTex()}= x${loga("a").toTex()}$ :
+
+${alignTex([
+        [loga(powerN).toTex(), "=", loga(b).toTex()],
+        [multiply("x", loga(powered)).toTex(), "=", loga(b).toTex()],
+        ["x", "=", frac(loga(b), loga(powered)).toTex()],
+    ])}
+
+La solution est donc : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers, opts),
@@ -57,6 +102,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -106,6 +153,7 @@ export const logPowerEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
 export const log10PowerEquation = {
     id: "log10PowerEquation",
@@ -119,4 +167,5 @@ export const log10PowerEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/logarithm/logSimplifiying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"logSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

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"}