math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.js

@@ -0,0 +1,142 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    const { x } = identifiers;
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+Calcule donc d'abord $f(${x})$, et $f(${x}+h)$ en fonction de $h$.
+
+Puis, détermine la limite de ce nombre lorsque $h$ se rapproche de $0$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs, x } = identifiers;
+    const trinom = new Polynomial(coeffs).toTree();
+    const fx = trinom.toDetailedEvaluation({ x: x.toTree() });
+    const fxSimp = fx.simplify();
+    const fxh = trinom.toDetailedEvaluation({ x: add(x, "h") });
+    const fxhSimp = fxh.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const answer = getAnswer(identifiers);
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+On calcule donc $f(${x})$ :
+
+${alignTex([
+        [`f(${x})`, "=", fx.toTex()],
+        ["", "=", fxSimp.toTex()],
+    ])}
+
+Puis $f(${x}+h)$ :
+
+${alignTex([
+        [`f(${x}+h)`, "=", fxh.toTex()],
+        ["", "=", fxhSimp.toTex()],
+    ])}
+
+Le taux d'accroissement vaut donc : 
+
+${alignTex([
+        [
+            frac(substract(`f(${x}+h)`, `f(${x})`), `h`).toTex(),
+            "=",
+            frac(substract(fxhSimp, fxSimp).simplify({ forbidFactorize: true }), "h").toTex(),
+        ],
+        [
+            "",
+            "=",
+            frac(substract(fxhSimp, fxSimp), "h")
+                .simplify({ forbidFactorize: true, forceDistributeFractions: true })
+                .toTex(),
+        ],
+    ])}
+
+Lorsque $h$ tend vers $0$, ce nombre se rapproche donc de $${answer}$. 
+La limite du taux d'accroissement en $0$ est donc $${answer}$. 
+
+Le nombre dérivé $f'(${x})$ vaut donc $${answer}$.
+`;
+};
+const getInstruction = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const instruction = `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+En revenant à la définition du nombre dérivé, calculer $f'(${identifiers.x})$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const answer = trinom.derivate().calculate(identifiers.x) + "";
+    return answer;
+};
+const getDerivativeNumberCalculQuestion = () => {
+    const x = randint(-9, 10);
+    const trinom = PolynomialConstructor.randomWithOrder(2);
+    const identifiers = { x, coeffs: trinom.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(-20, 20) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const derivativeNumberCalcul = {
+    id: "derivativeNumberCalcul",
+    connector: "=",
+    label: "Calculer un nombre dérivé via la définition",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getDerivativeNumberCalculQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}

package/lib/exercises/math/derivation/derivativeNumber/index.js

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+// export * from "./averageRateOfChangeAlgebraicExpression.js";

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

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

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

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

package/lib/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawAffineFromPointAndLeadingCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,YAAY,EAAE,eAAe,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA4FF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"drawAffineFromPointAndLeadingCoeff.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,YAAY,EAAE,eAAe,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAyJF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA4FF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/functions/affines/drawAffineFromPointAndLeadingCoeff.js

@@ -27,6 +27,7 @@ const getCorrection = (identifiers) => {
     const offsetVert = coeff.leftChild.evaluate();
     const isUp = Math.sign(offsetVert) >= 0;
     const offsetHoriz = coeff.rightChild.evaluate();
+    const [vAbsOffsetHoriz, vAbsOffsetVert] = [offsetHoriz, offsetVert].map((v) => Math.abs(v));
     return `La fonction $${funcName}$ est une fonction affine.
 Sa représentation graphique est une droite, que l'on va nommer $d$.
 
@@ -37,12 +38,12 @@ Comme le coefficient directeur est égal à $${texCoeff} = ${coeff.toTex({
         allowMinusAnywhereInFraction: true,
         explicitNumberWriting: true,
     })}$ 
-alors à partir de $A$, on se déplace verticalement de $${Math.abs(offsetVert).frenchify()}$ carreaux vers le ${isUp ? `haut` : `bas`} 
-quand on se déplace horizontalement de $${offsetHoriz.frenchify()}$ carreaux vers la droite.
+alors à partir de $A$, on se déplace verticalement de $${vAbsOffsetVert.frenchify()}$ carreau${vAbsOffsetVert > 1 ? "x" : ""} vers le ${isUp ? `haut` : `bas`} 
+quand on se déplace horizontalement de $${vAbsOffsetHoriz.frenchify()}$ carreau${vAbsOffsetHoriz > 1 ? "x" : ""} vers la droite.
 
 C'est-à-dire que le point $B$ de coordonnées $(${pointB.x.toTex()}; ${pointB.y.toTex()})$ appartient à $d$.
 
-On trace donc la droite passant $A(${pointA.x.toTex()}; ${pointA.y.toTex()})$ et $B(${pointB.x
+On trace donc la droite passant par $A(${pointA.x.toTex()}; ${pointA.y.toTex()})$ et par $B(${pointB.x
         .evaluate()
         .frenchify()}; ${pointB.y.evaluate().frenchify()})$.`;
 };
@@ -51,7 +52,7 @@ const getInstruction = (identifiers) => {
     const pointA = PointConstructor.fromIdentifiers(pointIdsA);
     const coeff = NodeConstructor.fromIdentifiers(leadingCoeff);
     const texCoeff = numberType === "Fraction" ? coeff.toTex() : coeff.evaluate().frenchify();
-    return `La fonction affine $${funcName}$ a pour représentation graphique une droite de  coefficient directeur $${texCoeff}$ et qui passe par le point de coordonnées $\\left(${pointA.x.toTex()}; ${pointA.y.toTex()}\\right)$.
+    return `La fonction affine $${funcName}$ a pour représentation graphique une droite de coefficient directeur $${texCoeff}$ et qui passe par le point de coordonnées $\\left(${pointA.x.toTex()}; ${pointA.y.toTex()}\\right)$.
 
 Dans le repère, tracer la représentation graphique de la fonction $${funcName}$.`;
 };

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+    nodeIdsAOpB: NodeIdentifiers;
+    expARounded: number;
+    expBRounded: number;
+    precision: number;
+};
+export declare const approxExpAPlusB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=approxExpAPlusB.d.ts.map

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpAPlusB.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/approxExpAPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4UF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.js

@@ -0,0 +1,278 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.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 { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.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 { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsA, nodeIdsB, nodeIdsAOpB, expARounded, expBRounded, precision, } = identifiers;
+    const [nodeA, nodeB, nodeAOpB] = [nodeIdsA, nodeIdsB, nodeIdsAOpB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, texB] = [nodeA, nodeB].map((node) => node.toTex());
+    const nodeAOpBSubstituted = [
+        ["a", nodeA],
+        ["b", nodeB],
+    ]
+        .reduce((acc, [varName, nodeInjected]) => {
+        return nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName));
+    }, nodeAOpB)
+        .simplify({ fractionsToDecimal: true });
+    const texAOpBSubstituted = nodeAOpBSubstituted.toTex();
+    return `Sachant que :
+  
+$$
+\\exp(${texA})\\approx${expARounded.frenchify()}
+$$
+
+$$
+\\exp(${texB})\\approx${expBRounded.frenchify()}
+$$
+
+donner une valeur approchée de $\\exp(${texAOpBSubstituted})$ 
+
+avec $${precision}$ décimale${precision > 1 ? "s" : ""}.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsAOpB, expARounded, expBRounded, precision } = identifiers;
+    const nodeAOpB = NodeConstructor.fromIdentifiers(nodeIdsAOpB);
+    const texAOpB = nodeAOpB.toTex();
+    switch (texAOpB) {
+        case "a+b":
+            return round(multiply(expARounded, expBRounded).evaluate(), precision).toTree();
+        case "a-b":
+            return round(frac(expARounded, expBRounded).evaluate(), precision).toTree();
+        default:
+            throw new Error("Unsupported texAOpB: " + texAOpB);
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsAOpB } = identifiers;
+    const nodeAOpB = NodeConstructor.fromIdentifiers(nodeIdsAOpB);
+    const texAOpB = nodeAOpB.toTex();
+    switch (texAOpB) {
+        case "a+b":
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+\\exp(a+b) = \\exp(a) \\times \\exp(b)
+$$
+
+`;
+        case "a-b":
+            return `Utilise la propriété : 
+
+Si $a$ et $b$ sont deux nombres réels, alors :
+  
+$$
+\\exp(a-b) = \\frac{\\exp(a)}{\\exp(b)}
+$$
+
+`;
+        default:
+            throw new Error("Unsupported texAOpB: " + texAOpB);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsA, nodeIdsB, nodeIdsAOpB, expARounded, expBRounded } = identifiers;
+    const [nodeA, nodeB, nodeAOpB] = [nodeIdsA, nodeIdsB, nodeIdsAOpB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, texB, texAOpB] = [nodeA, nodeB, nodeAOpB].map((node) => node.toTex());
+    const texBPretty = texB[0] === "-" ? `(${texB})` : texB;
+    const nodeAOpBSubstituted = [
+        ["a", nodeA],
+        ["b", nodeB],
+    ]
+        .reduce((acc, [varName, nodeInjected]) => {
+        return nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName));
+    }, nodeAOpB)
+        .simplify({ fractionsToDecimal: true });
+    const texAOpBSubstituted = nodeAOpBSubstituted.toTex();
+    switch (texAOpB) {
+        case "a+b":
+            return `On a : 
+  
+$$
+\\exp(${texAOpBSubstituted}) = \\exp(${texA} + ${texBPretty})
+$$
+
+Ainsi :
+
+$$
+\\exp(${texAOpBSubstituted}) = \\exp(${texA}) \\times \\exp(${texB}) 
+$$
+
+$$
+\\exp(${texAOpBSubstituted}) \\approx ${expARounded.frenchify()} \\times ${expBRounded.frenchify()}
+$$
+
+$$
+\\exp(${texAOpBSubstituted}) \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+        case "a-b":
+            return `On a : 
+  
+$$
+\\exp(${texAOpBSubstituted}) = \\exp(${texA} - ${texBPretty})
+$$
+
+Ainsi :
+
+$$
+\\exp(${texAOpBSubstituted}) = \\frac{\\exp(${texA})}{\\exp(${texB})}
+$$
+
+$$
+\\exp(${texAOpBSubstituted}) \\approx \\frac{${expARounded.frenchify()}}{${expBRounded.frenchify()}}
+$$
+
+$$
+\\exp(${texAOpBSubstituted}) \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+        default:
+            throw new Error("Unsupported texAOpB: " + texAOpB);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsA, nodeIdsB, expARounded, expBRounded, precision } = identifiers;
+    const [nodeA, nodeB] = [nodeIdsA, nodeIdsB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //exp(a)+exp(b)
+    {
+        const nodeWrong = round(add(expARounded, expBRounded).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)-exp(b)
+    {
+        const nodeWrong = round(substract(expARounded, expBRounded).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)^exp(b)
+    {
+        const nodeWrong = round(power(expARounded, expBRounded).evaluate(), precision).toTree();
+        const tex = nodeWrong.toTex();
+        if (tex !== "NaN") {
+            tryToAddWrongProp(propositions, tex);
+        }
+    }
+    //terror: student uses exp(a) and exp(b) instead of given approx values
+    {
+        const arrNode = [
+            round(add(exp(nodeA), exp(nodeB)).evaluate(), precision).toTree(),
+            round(substract(exp(nodeA), exp(nodeB)).evaluate(), precision).toTree(),
+            round(power(exp(nodeA), exp(nodeB)).evaluate(), precision).toTree(),
+        ];
+        shuffle(arrNode).forEach((node) => {
+            const tex = node.toTex();
+            if (tex !== "NaN") {
+                tryToAddWrongProp(propositions, tex);
+            }
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getApproxExpAPlusBQuestion = () => {
+    function createRandomIdentifiers() {
+        const precision = randint(1, 6);
+        const nodeA = randfloat(0, 3, 2, [0]).toTree();
+        const expARounded = round(exp(nodeA).evaluate(), precision);
+        const nodeB = random([
+            //-1
+            (-1).toTree(),
+            //1/2
+            frac(1, 2),
+            //int
+            (() => randint(2, 11).toTree())(),
+        ]);
+        const expBRounded = round(exp(nodeB).evaluate(), precision);
+        const nodeAOpB = parseAlgebraic(coinFlip() ? "a+b" : "a-b");
+        const identifiers = {
+            nodeIdsA: nodeA.toIdentifiers(),
+            nodeIdsB: nodeB.toIdentifiers(),
+            nodeIdsAOpB: nodeAOpB.toIdentifiers(),
+            expARounded,
+            expBRounded,
+            precision,
+            nodeA,
+            nodeB,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = (() => {
+            const { nodeA, nodeB } = identifiersCandidate;
+            return multiply(nodeA, nodeB).evaluate() < 15;
+        })();
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            nodeIdsA: (2).toTree().toIdentifiers(),
+            nodeIdsB: frac(1, 3).toIdentifiers(),
+            nodeIdsAOpB: parseAlgebraic("a+b").toIdentifiers(),
+            precision: 2,
+            expARounded: round(exp(2).evaluate(), 2),
+            expBRounded: round(exp(frac(1, 3)).evaluate(), 2),
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const approxExpAPlusB = {
+    id: "approxExpAPlusB",
+    label: "Déterminer une valeur approchée de $\\exp(a+b)$ ou de $\\exp(a-b)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getApproxExpAPlusBQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

package/lib/exercises/math/functions/exponential/algebraic/approxExpKa.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsK: NodeIdentifiers;
+    expARounded: number;
+    precision: number;
+};
+export declare const approxExpKa: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=approxExpKa.d.ts.map

package/lib/exercises/math/functions/exponential/algebraic/approxExpKa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpKa.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/approxExpKa.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+OF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}