math-exercises 3.0.200 → 3.0.202

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

@@ -0,0 +1,154 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { getArrNodeCoeffOfPolynomialNode } from "../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { LogNode } from "../../../tree/nodes/functions/logNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../tree/nodes/numbers/infiniteNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsLimitAbscissa, nodeIdsP, isPossible } = identifiers;
+    const [nodeLimitAbscissa, nodeP] = [nodeIdsLimitAbscissa, nodeIdsP].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeLimitP = isPossible ? PlusInfinityNode : MinusInfinityNode;
+    return {
+        nodeLimitAbscissa,
+        nodeP,
+        isPossible,
+        nodeLimitP,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeLimitAbscissa, nodeP } = getHydrated(identifiers);
+    return `Déterminer la limite en $${nodeLimitAbscissa.toTex()}$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = \\ln(${nodeP.toTex()})
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { isPossible, nodeLimitP } = getHydrated(identifiers);
+    return isPossible
+        ? nodeLimitP.toTex()
+        : "Absurde : $\\ln$ est définie seulement sur $]0;+\\infty[$.";
+};
+const getHint = (identifiers) => {
+    const { nodeLimitAbscissa, nodeP } = getHydrated(identifiers);
+    return `Commence par déterminer : 
+
+$$
+\\displaystyle \\lim_{x \\to ${nodeLimitAbscissa.toTex()}} ${nodeP.toTex()}
+$$
+  
+et détermine ensuite, pour la limite demandée dans l'énoncé : 
+
+- Est-ce absurde ? $x$ peut-il tendre vers la valeur demandée ? Attention : $\\ln$ est définie seulement sur $]0;+\\infty[$.
+
+- Est-ce possible ? La limite existe-t-elle quand $x$ tend vers la valeur demandée ? Certaines fonctions, comme par exemple $\\cos$ ou $\\sin$ n'ont pas de limite en $+\\infty$.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeLimitAbscissa, nodeP, isPossible, nodeLimitP } = getHydrated(identifiers);
+    if (isPossible) {
+        return `On a : 
+
+$$
+\\displaystyle \\lim_{x \\to ${nodeLimitAbscissa.toTex()}} ${nodeP.toTex()} = ${nodeLimitP.toTex()}
+$$
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} \\ln(x) = ${nodeLimitP.toTex()}
+$$
+
+Par conséquent : 
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} \\ln(${nodeP.toTex()}) = ${nodeLimitP.toTex()}
+$$
+
+`;
+    }
+    else {
+        return `On a : 
+
+$$
+\\displaystyle \\lim_{x \\to ${nodeLimitAbscissa.toTex()}} ${nodeP.toTex()} = ${nodeLimitP.toTex()}
+$$
+
+Mais, $\\ln$ est seulement définie sur $]0;+\\infty[$.
+
+L'écriture suivante est donc absurde : 
+
+$$
+\\displaystyle \\lim_{x \\to ${nodeLimitAbscissa.toTex()}} \\ln(${nodeP.toTex()})
+$$
+    
+`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { isPossible } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer, isPossible ? "tex" : "raw");
+    const { nodeP } = getHydrated(identifiers);
+    const [nodeC, _nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeP);
+    tryToAddWrongProp(propositions, MinusInfinityNode.toTex());
+    tryToAddWrongProp(propositions, (0).frenchify());
+    if (nodeA.evaluate() > 0) {
+        tryToAddWrongProp(propositions, multiply(2, new LogNode(nodeA)).toTex());
+    }
+    if (nodeC.evaluate() > 0) {
+        tryToAddWrongProp(propositions, new LogNode(nodeC).toTex());
+    }
+    tryToAddWrongProp(propositions, "Impossible : Cette limite n'existe pas.", "raw");
+    tryToAddWrongProp(propositions, "Absurde : $\\ln$ est définie seulement sur $]0;+\\infty[$.", "raw");
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const isPossible = coinFlip();
+    const nodeVarX = new VariableNode("x");
+    const k = isPossible ? randint(1, 7) : randint(-6, -1);
+    const a = randint(1, 11, [0]);
+    const b = randint(-10, 11, [0, a]);
+    const nodeP = multiply(k, multiply(substract(nodeVarX, a), substract(nodeVarX, b))).simplify({ towardsDistribute: true, forbidFactorize: true });
+    const nodeLimitAbscissa = coinFlip() ? MinusInfinityNode : PlusInfinityNode;
+    const identifiers = {
+        nodeIdsLimitAbscissa: nodeLimitAbscissa.toIdentifiers(),
+        nodeIdsP: nodeP.toIdentifiers(),
+        isPossible,
+    };
+    return identifiers;
+};
+const getLogOfPolynomialLimitQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { isPossible } = identifiers;
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        answerFormat: isPossible ? "tex" : "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const logOfPolynomialLimit = {
+    id: "logOfPolynomialLimit",
+    connector: "\\iff",
+    label: "Limite de $\\ln(P(x))$ en $-\\infty$ ou $+\\infty$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getLogOfPolynomialLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/primitive/constantPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAOJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAgCF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAMxE,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,EACX,OAAO,CAaR,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,EAAE,OAAO,CAmB/E,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAQpE,CAAC;AAYF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc5D,CAAC"}
+{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EASJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAyDF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAMxE,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,EACX,OAAO,CAeR,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAQpE,CAAC;AAYF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe5D,CAAC"}

package/lib/exercises/math/primitive/constantPrimitive.js

@@ -16,13 +16,34 @@ const getInstruction = (identifiers, opts) => {
     const { c } = identifiers;
     const isAskingParticularPrimitive = opts?.askParticularPrimitive;
     return `${isAskingParticularPrimitive
-        ? "Déterminer une primitive en particulier de la fonction constante $f$ définie par"
+        ? "Donner une des primitives de la fonction constante $f$ définie par"
         : "Déterminer la forme générale des primitives de la fonction constante $f$ définie par"} : 
   
 $$
 f(x) = ${c}
 $$`;
 };
+const getHint = (identifiers) => {
+    const { c } = identifiers;
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${c}$ ?`;
+};
+const getCorrection = (identifiers, opts) => {
+    if (opts?.askParticularPrimitive)
+        return `Une primitive de $f$ est : 
+  
+$$
+F(x) = ${getAnswerNode(identifiers, opts).toTex()}
+$$
+
+En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswerNode(identifiers, opts).toTex()}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 const getAnswer = (identifiers, opts) => {
     return getAnswerNode(identifiers, opts).toTex();
 };
@@ -39,6 +60,8 @@ export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers, opts) =
         keys: opts?.askParticularPrimitive ? ["x"] : ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         options: opts,
     };
     return question;
@@ -82,4 +105,5 @@ export const constantPrimitive = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getConstantPrimitiveQuestionFromIdentifiers,
     options,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/exponentialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAKJ,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwBF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAIlE,CAAC;AAEF,eAAO,MAAM,8CAA8C,EAAE,0BAA0B,CACrF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAKJ,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwBF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAIlE,CAAC;AAqBF,eAAO,MAAM,8CAA8C,EAAE,0BAA0B,CACrF,WAAW,CAcZ,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/primitive/exponentialPrimitive.js

@@ -28,6 +28,20 @@ export const getExponentialPrimitive = () => {
     const identifiers = { a };
     return getExponentialPrimitiveQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    const integratedFuction = new MultiplyNode(new NumberNode(a), new ExpNode(new VariableNode("x")));
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${integratedFuction.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 export const getExponentialPrimitiveQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -36,6 +50,8 @@ export const getExponentialPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C", "epower", "exp"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -80,4 +96,5 @@ export const exponentialPrimitive = {
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
     getQuestionFromIdentifiers: getExponentialPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAcZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -6,13 +6,26 @@ import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
-    const polynomial = new Polynomial(identifiers.coeffs);
+    const polynomial = new Polynomial(identifiers.coeffs).toTree();
     return `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par : 
 
 $$
 f(x) = ${polynomial.toTex()}
 $$`;
 };
+const getHint = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs).toTree();
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${polynomial.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 const getAnswer = (identifiers) => {
     const polynomial = new Polynomial(identifiers.coeffs);
     const integralPolynomial = polynomial.integrateToNode();
@@ -33,6 +46,8 @@ export const getPolynomialPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -85,4 +100,5 @@ export const polynomialPrimitive = {
     isAnswerValid: isPolynomialPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getPolynomialPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/sinCosPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwBF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CAM7D,CAAC;AAEF,eAAO,MAAM,yCAAyC,EAAE,0BAA0B,CAChF,WAAW,CAYZ,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwBF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CAM7D,CAAC;AAoBF,eAAO,MAAM,yCAAyC,EAAE,0BAA0B,CAChF,WAAW,CAcZ,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/primitive/sinCosPrimitive.js

@@ -34,6 +34,22 @@ export const getSinCosPrimitive = () => {
     const identifiers = { a, isCos };
     return getSinCosPrimitiveQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { a, isCos } = identifiers;
+    const selectedFunction = isCos
+        ? new MultiplyNode(new NumberNode(a), new CosNode(new VariableNode("x")))
+        : new MultiplyNode(new NumberNode(a), new SinNode(new VariableNode("x")));
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${selectedFunction.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 export const getSinCosPrimitiveQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -42,6 +58,8 @@ export const getSinCosPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C", "sin", "cos"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -74,7 +92,7 @@ export const isSinCosPrimitiveAnswerValid = (ans, { isCos, a }) => {
 export const sinCosPrimitive = {
     id: "sinCosPrimitive",
     connector: "=",
-    label: "Primitive de sin et cos",
+    label: "Primitive de $\\sin$ et $\\cos$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getSinCosPrimitive, nb),
     qcmTimer: 60,
@@ -83,4 +101,5 @@ export const sinCosPrimitive = {
     isAnswerValid: isSinCosPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getSinCosPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/usualPrimitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usualPrimitives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/usualPrimitives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOT,MAAM,6BAA6B,CAAC;AA4BrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA+HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"usualPrimitives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/usualPrimitives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOT,MAAM,6BAA6B,CAAC;AA4BrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA+HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/primitive/usualPrimitives.js

@@ -131,4 +131,5 @@ export const usualPrimitives = {
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

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

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

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

@@ -0,0 +1,170 @@
+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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.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 { nodeIdsE, nodeIdsCoeff } = identifiers;
+    const [nodeEX, nodeEY, nodeCoeffX, nodeCoeffY] = [
+        ...nodeIdsE,
+        ...nodeIdsCoeff,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texE = `E(${add(multiply(nodeCoeffX, new VariableNode("X")), multiply(nodeCoeffY, new VariableNode("Y")))
+        .simplify({ towardsDistribute: true })
+        .toTex({})})`;
+    const nodeLinearCombinationForTex = add(multiply(nodeCoeffX, new VariableNode("E(X)")), multiply(nodeCoeffY, new VariableNode("E(Y)"))).simplify({ towardsDistribute: true });
+    const nodeLinearCombinationForResult = nodeCoeffY.evaluate() !== 0
+        ? add(multiply(nodeCoeffX, nodeEX), multiply(nodeCoeffY, nodeEY))
+        : multiply(nodeCoeffX, nodeEX);
+    return {
+        nodeEX,
+        nodeEY,
+        nodeCoeffX,
+        nodeCoeffY,
+        texE,
+        nodeLinearCombinationForTex,
+        nodeLinearCombinationForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeEX, nodeEY, texE } = getHydrated(identifiers);
+    return `Soient $X$ et $Y$ deux variables aléatoires dont les espérances sont données ci-dessous :
+
+$$
+E(X) = ${nodeEX.toTex()}
+$$
+
+$$
+E(Y) = ${nodeEY.toTex()}
+$$
+
+Que vaut $${texE}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeLinearCombinationForResult } = getHydrated(identifiers);
+    return nodeLinearCombinationForResult.simplify().toTex();
+};
+const getHint = () => {
+    return `Soit $a$ et $b$ deux réels :
+$$
+E(aX+bY) = a \\ E(X) + b \\ E(Y)
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { texE, nodeLinearCombinationForTex, nodeLinearCombinationForResult } = getHydrated(identifiers);
+    return `
+  
+${alignTex([
+        ["", texE],
+        ["=", nodeLinearCombinationForTex.toTex()],
+        ["=", nodeLinearCombinationForResult.toTex()],
+        ["=", nodeLinearCombinationForResult.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    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 [nodeEX, nodeEY] = [...Array(2).keys()].map(() => randfloat(-10, 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 = {
+        nodeIdsE: [nodeEX, nodeEY].map((node) => node.toIdentifiers()),
+        nodeIdsCoeff: [nodeCoeffX, nodeCoeffY].map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getExpectedValueOfLinearCombinationQuestion = (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 expectedValueOfLinearCombination = {
+    id: "expectedValueOfLinearCombination",
+    connector: "=",
+    label: "Calculer l'espérance d'une combination linéaire de variables aléatoires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpectedValueOfLinearCombinationQuestion(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/expectedValueOfSumFromDice.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"expectedValueOfSumFromDice.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/expectedValueOfSumFromDice.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAkLF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}