math-exercises 3.0.157 → 3.0.159

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

@@ -0,0 +1,305 @@
+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);
+            }
+        });
+    }
+    //filler
+    if (propositions.length < n) {
+        //exp(b)-exp(a)
+        {
+            const nodeWrong = round(substract(expBRounded, expARounded).evaluate(), precision).toTree();
+            const tex = nodeWrong.toTex();
+            if (tex !== "NaN") {
+                tryToAddWrongProp(propositions, tex);
+            }
+        }
+        //exp(a)/exp(b)
+        {
+            const nodeWrong = round(frac(expARounded, expBRounded).evaluate(), precision).toTree();
+            const tex = nodeWrong.toTex();
+            if (tex !== "NaN") {
+                tryToAddWrongProp(propositions, tex);
+            }
+        }
+        //(exp(a)+exp(b))/2
+        {
+            const nodeWrong = round(frac(add(expARounded, expBRounded), 2).evaluate(), precision).toTree();
+            const tex = nodeWrong.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 \\pm b)$ à partir de $\\exp(a)$ et $\\exp(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;AAMrC,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;AAqPF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAkB7C,CAAC"}

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

@@ -0,0 +1,216 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 { random } from "../../../../../utils/alea/random.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsA, nodeIdsK, expARounded, precision } = identifiers;
+    const [nodeA, nodeK] = [nodeIdsA, nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, _] = [nodeA, nodeK].map((node) => node.toTex({ roundTo: 2 }));
+    const nodeKA = multiply(nodeK, nodeA).simplify({ fractionsToDecimal: true });
+    const texKA = nodeKA.toTex();
+    return `Sachant que :
+  
+$$
+\\exp(${texA})\\approx ${expARounded.frenchify()}
+$$
+
+donner une valeur approchée de $\\exp(${texKA})$ 
+
+avec $${precision}$ décimale${precision > 1 ? "s" : ""}.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsK, expARounded, precision } = identifiers;
+    const [nodeK] = [nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return round(power(expARounded, nodeK).evaluate(), precision).toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsA, nodeIdsK } = identifiers;
+    const [nodeA, nodeK] = [nodeIdsA, nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, texK] = [nodeA, nodeK].map((node) => node.toTex({ roundTo: 2 }));
+    return `Utilise la propriété : 
+  
+$$
+\\exp(${texA} \\times ${texK}) = {\\exp(${texA})}^{${texK}}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsA, nodeIdsK, expARounded } = identifiers;
+    const [nodeA, nodeK] = [nodeIdsA, nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texA, texK] = [nodeA, nodeK].map((node) => node.toTex({ roundTo: 2 }));
+    const nodeKA = multiply(nodeK, nodeA).simplify();
+    const texKA = nodeKA.toTex();
+    return `On a : 
+    
+$$
+\\exp(${texKA}) = \\exp(${texA} \\times ${texK}) = {\\exp(${texA})}^{${texK}}
+$$
+
+On utilise l'approximation fournie : 
+
+$$
+\\exp(${texA}) \\approx ${expARounded.frenchify()}
+$$
+
+On a donc : 
+
+$$
+\\exp(${texKA}) = (\\exp(${texA}))^{${texK}} \\approx ({${expARounded.frenchify()}})^{${texK}}
+$$
+
+$$
+\\exp(${texKA}) \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsA, nodeIdsK, expARounded, precision } = identifiers;
+    const [nodeA, nodeK] = [nodeIdsA, nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //k*exp(a)
+    {
+        const nodeWrong = round(multiply(expARounded, nodeK).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a)^{k-1}
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            nodeIdsK: substract(nodeK, 1).toIdentifiers(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //exp(a)^{k+1}
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            nodeIdsK: add(nodeK, 1).toIdentifiers(),
+        });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //terror: student uses exp(a) instead of given approx value
+    {
+        function getTerrorNode(identifiers) {
+            const { nodeIdsA, nodeIdsK, precision } = identifiers;
+            const [nodeA, nodeK] = [nodeIdsA, nodeIdsK].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return round(power(exp(nodeA), nodeK).evaluate(), precision).toTree();
+        }
+        const arrNode = [
+            getTerrorNode(identifiers),
+            round(multiply(exp(nodeA), nodeK).evaluate(), precision).toTree(),
+            getTerrorNode(Object.assign({}, identifiers, {
+                nodeIdsK: substract(nodeK, 1).toIdentifiers(),
+            })),
+            getTerrorNode(Object.assign({}, identifiers, {
+                nodeIdsK: add(nodeK, 1).toIdentifiers(),
+            })),
+        ];
+        shuffle(arrNode)
+            .slice(0, randint(0, 3))
+            .forEach((node) => {
+            tryToAddWrongProp(propositions, node.toTex());
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getApproxExpKaQuestion = () => {
+    function createRandomIdentifiers() {
+        const dot1Pool = [...Array(30).keys()]
+            .map((i) => i + 1)
+            .map((i) => i * 0.1);
+        const dot25Pool = [...Array(12).keys()]
+            .map((i) => i + 1)
+            .map((i) => i * 0.25);
+        const nodeA = random(random([dot1Pool, dot25Pool])).toTree();
+        const precision = randint(1, 6);
+        const expARounded = round(exp(nodeA).evaluate(), precision);
+        const nodeK = random([
+            //-1
+            (-1).toTree(),
+            //1/2
+            frac(1, 2),
+            //int
+            (() => randint(2, 11).toTree())(),
+        ]);
+        const identifiers = {
+            nodeIdsA: nodeA.toIdentifiers(),
+            nodeIdsK: nodeK.toIdentifiers(),
+            expARounded,
+            precision,
+            nodeA,
+            nodeK,
+        };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = (() => {
+            const { nodeA, nodeK } = identifiersCandidate;
+            return multiply(nodeA, nodeK).evaluate() < 15;
+        })();
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            nodeIdsA: (2).toTree().toIdentifiers(),
+            nodeIdsK: frac(1, 2).toIdentifiers(),
+            precision: 2,
+            expARounded: round(exp(2).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 approxExpKa = {
+    id: "approxExpKa",
+    label: "Déterminer une valeur approchée de $\\exp(ka)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getApproxExpKaQuestion(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/approxExpN.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpN.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/approxExpN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgJF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAkB5C,CAAC"}

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

@@ -0,0 +1,142 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { a, exp1Rounded, precision } = identifiers;
+    return `Sachant que :
+  
+$$
+\\exp(1)\\approx ${exp1Rounded.frenchify()}
+$$
+
+donner une valeur approchée de $\\exp(${a.frenchify()})$ 
+
+avec $${precision}$ décimale${precision > 1 ? "s" : ""}.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, exp1Rounded, precision } = identifiers;
+    return round(power(exp1Rounded, a).evaluate(), precision).toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Utilise la propriété : 
+  
+$$
+e = e^${1} = \\exp(1)
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { a, exp1Rounded } = identifiers;
+    return `On a : 
+    
+$$
+\\exp(${a}) = e^${a} = {\\exp(1)}^${a}
+$$
+
+On utilise l'approximation fournie : 
+
+$$
+e = \\exp(1) \\approx ${exp1Rounded.frenchify()}
+$$
+
+On a donc : 
+
+$$
+\\exp(${a}) = e^${a} \\approx {${exp1Rounded.frenchify()}}^${a}
+$$
+
+$$
+e^${a} \\approx ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { a, exp1Rounded, precision } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //a*exp(1)
+    {
+        const nodeWrong = round(multiply(exp1Rounded, a).evaluate(), precision).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //exp(a-1)
+    {
+        const identifiersWrong = Object.assign({}, identifiers, { a: a - 1 });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //exp(a+1)
+    {
+        const identifiersWrong = Object.assign({}, identifiers, { a: a + 1 });
+        const texWrong = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //terror: student uses exp(1) instead of given approx value
+    {
+        function getTerrorNode(identifiers) {
+            const { a, precision } = identifiers;
+            return round(power(exp(1), a).evaluate(), precision).toTree();
+        }
+        const arrNode = [
+            getTerrorNode(identifiers),
+            round(multiply(exp(1), a).evaluate(), precision).toTree(),
+            getTerrorNode(Object.assign({}, identifiers, { a: a - 1 })),
+            getTerrorNode(Object.assign({}, identifiers, { a: a + 1 })),
+        ];
+        shuffle(arrNode)
+            .slice(0, randint(0, 3))
+            .forEach((node) => {
+            tryToAddWrongProp(propositions, node.toTex());
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getApproxExpNQuestion = () => {
+    const a = randint(2, 15);
+    const precision = randint(1, 6);
+    const exp1Rounded = round(exp(1).evaluate(), precision);
+    const identifiers = { a, exp1Rounded, precision };
+    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 approxExpN = {
+    id: "approxExpN",
+    label: "Déterminer une valeur approchée de $\\exp(n)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getApproxExpNQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};