math-exercises 3.0.183 → 3.0.185

package/lib/exercises/math/functions/composition/functionComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA8D7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AA4NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/composition/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgE7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAgNF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/functions/composition/functionComposition.js

@@ -8,6 +8,8 @@ import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { isOperatorNode } from "../../../../tree/nodes/operators/operatorNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../tree/utilities/nodeRewriter.js";
 import { random } from "../../../../utils/alea/random.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 const nodeBySubstitutingX = (node, strVar) => {
@@ -99,28 +101,15 @@ const getAnswer = (identifiers) => {
 const isAnswerValid = (ans, { answer }) => {
     const nodeAns = parseAlgebraic(ans);
     const nodeAnswer = parseAlgebraic(answer);
-    //  Une façon de savoir que expr1(x) et expr2(x) sont équivalentes:
-    //  x|->expr1(expr2(x)) doit être la même fonction que x|->expr2(expr1(x))
-    /*!! ROBIN
-    Fix à l'arrache car les tests pétent
-    */
-    // const nodeAnsOfAnswer = nodeBySubstitutingX(
-    //   nodeAns.simplify(),
-    //   nodeAnswer.simplify().toTex(),
-    // ).simplify();
-    // const nodeAnswerOfAns = nodeBySubstitutingX(
-    //   nodeAnswer.simplify(),
-    //   nodeAns.simplify().toTex(),
-    // ).simplify();
-    // return [0, 1, 1000].every((x) => {
-    //   return (
-    //     substract(
-    //       nodeAnsOfAnswer.evaluate({ x }),
-    //       nodeAnswerOfAns.evaluate({ x }),
-    //     ).evaluate() === 0
-    //   );
-    // });
-    return nodeAns.simplify().toTex() === nodeAnswer.simplify().toTex();
+    const isEquivalentFound = () => {
+        const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+        return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+            const isEqual = NodeComparator.isEqualViaSub(nodeAns, nodeAnswerRefined);
+            return isEqual;
+        });
+    };
+    const isValid = isEquivalentFound();
+    return isValid;
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
     const { nodeIds } = identifiers;

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

@@ -1 +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;AAmXF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}
+{"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;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,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;AA8cF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

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

@@ -1,7 +1,6 @@
 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";
@@ -13,7 +12,8 @@ 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 { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { probaFlip } from "../../../../../utils/alea/probaFlip.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
@@ -152,8 +152,8 @@ $$
     }
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
-    const { nodeIdsA, nodeIdsB, expARounded, expBRounded, precision } = identifiers;
-    const [nodeA, nodeB] = [nodeIdsA, nodeIdsB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const { nodeIdsA, nodeIdsB, nodeIdsAOpB, expARounded, expBRounded, precision, } = identifiers;
+    const [nodeA, nodeB, nodeAOpB] = [nodeIdsA, nodeIdsB, nodeIdsAOpB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     const propositions = [];
     addValidProp(propositions, answer);
     //exp(a)+exp(b)
@@ -188,6 +188,22 @@ const getPropositions = (n, { answer, ...identifiers }) => {
             }
         });
     }
+    //terror: student computes round(exp(aOpB),precision) with their calculator
+    {
+        const nodeAOpBSubstituted = [
+            ["a", nodeA],
+            ["b", nodeB],
+        ]
+            .reduce((acc, [varName, nodeInjected]) => {
+            return nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName));
+        }, nodeAOpB)
+            .simplify({ fractionsToDecimal: true });
+        const nodeWrong = round(nodeAOpBSubstituted.evaluate(), 0).toTree();
+        const tex = nodeWrong.toTex();
+        if (tex !== "NaN") {
+            tryToAddWrongProp(propositions, tex);
+        }
+    }
     //filler
     if (propositions.length < n) {
         //exp(b)-exp(a)
@@ -220,33 +236,35 @@ const getPropositions = (n, { answer, ...identifiers }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const createRandomIdentifiers = () => {
+    const precision = randint(0);
+    const a = randint(0, 6);
+    const nodeA = a.toTree();
+    const expARounded = round(exp(nodeA).evaluate(), precision);
+    const nodeB = random([
+        // //-1
+        // (-1).toTree(),
+        //1/2
+        frac(1, 2),
+        //int
+        (() => randint(a, a + 5, [nodeA.evaluate()]).toTree())(),
+    ]);
+    const expBRounded = round(exp(nodeB).evaluate(), precision);
+    const nodeAOpB = parseAlgebraic(probaFlip(0.8) ? "a+b" : "a-b");
+    const identifiers = {
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsB: nodeB.toIdentifiers(),
+        nodeIdsAOpB: nodeAOpB.toIdentifiers(),
+        expARounded,
+        expBRounded,
+        precision,
+        nodeA,
+        nodeB,
+        nodeAOpB,
+    };
+    return identifiers;
+};
 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;
@@ -254,21 +272,56 @@ const getApproxExpAPlusBQuestion = () => {
         counter++;
         const identifiersCandidate = createRandomIdentifiers();
         isValid = (() => {
-            const { nodeA, nodeB } = identifiersCandidate;
-            return multiply(nodeA, nodeB).evaluate() < 15;
+            const { nodeA, nodeB, nodeAOpB, expARounded, expBRounded } = identifiersCandidate;
+            const nodeAOpBSubstituted = [
+                ["a", nodeA],
+                ["b", nodeB],
+            ]
+                .reduce((acc, [varName, nodeInjected]) => {
+                return nodeBySubstitutingVar(acc, nodeInjected, new VariableNode(varName));
+            }, nodeAOpB)
+                .simplify({ fractionsToDecimal: true });
+            const isAOpBEqualToAorB = () => {
+                return (NodeComparator.isEqualViaSub(nodeB, nodeAOpBSubstituted) ||
+                    NodeComparator.isEqualViaSub(nodeA, nodeAOpBSubstituted));
+            };
+            const isMentallyCalculable = () => {
+                function countDigits(num) {
+                    if (!Number.isFinite(num)) {
+                        throw new Error("Input must be a finite number.");
+                    }
+                    // Remove sign and decimal part
+                    const integerPart = Math.abs(Math.trunc(num));
+                    // Special case for 0
+                    if (integerPart === 0)
+                        return 1;
+                    return integerPart.toString().length;
+                }
+                const product = expARounded * expBRounded;
+                return countDigits(product) <= 4 && product < 5555;
+            };
+            return !isAOpBEqualToAorB() && isMentallyCalculable();
         })();
         if (isValid) {
-            identifiers = identifiersCandidate;
+            const { nodeIdsA, nodeIdsB, nodeIdsAOpB, expARounded, expBRounded, precision, } = identifiersCandidate;
+            identifiers = {
+                nodeIdsA,
+                nodeIdsB,
+                nodeIdsAOpB,
+                expARounded,
+                expBRounded,
+                precision,
+            };
         }
     }
     if (!isValid) {
         const identifiersDefault = {
             nodeIdsA: (2).toTree().toIdentifiers(),
-            nodeIdsB: frac(1, 3).toIdentifiers(),
+            nodeIdsB: (3).toTree().toIdentifiers(),
             nodeIdsAOpB: parseAlgebraic("a+b").toIdentifiers(),
-            precision: 2,
-            expARounded: round(exp(2).evaluate(), 2),
-            expBRounded: round(exp(frac(1, 3)).evaluate(), 2),
+            precision: 0,
+            expARounded: round(exp(2).evaluate(), 0),
+            expBRounded: round(exp(3).evaluate(), 0),
         };
         identifiers = identifiersDefault;
     }
@@ -287,7 +340,7 @@ const getQuestionFromIdentifiers = (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)$",
+    label: "Déterminer une valeur approchée de $\\exp⁡(a \\pm b)$ à partir de valeurs approchées de $\\exp(a)$ et de $\\exp(b)$",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getApproxExpAPlusBQuestion(opts), nb),
     qcmTimer: 60,

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

@@ -1 +1 @@
-{"version":3,"file":"rewriteExpUsingExpA.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/rewriteExpUsingExpA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgB7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4XF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAcF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB9D,CAAC"}
+{"version":3,"file":"rewriteExpUsingExpA.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/rewriteExpUsingExpA.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkB7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiZF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAcF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB9D,CAAC"}

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

@@ -12,6 +12,8 @@ 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 { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { NodeRewriter } from "../../../../../tree/utilities/nodeRewriter.js";
 import { random } from "../../../../../utils/alea/random.js";
 const myExpFunc = (opts) => {
     return (nodeChild) => new ExpNode(nodeChild, { useExpNotation: opts.isUseExpNotation });
@@ -170,13 +172,18 @@ $$
 const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;
     const myExp = myExpFunc(opts);
+    const nodeAnswer = getAnswerNode(identifiers, opts);
+    const nodeAnswerSameOrEquivalent = random(NodeRewriter.getArrNodeEquivalent(nodeAnswer));
     const { nodeIdsA, nodeIdsB } = identifiers;
     const [nodeA, nodeB] = [nodeIdsA, nodeIdsB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     const propositions = [];
-    addValidProp(propositions, answer);
+    addValidProp(propositions, nodeAnswerSameOrEquivalent.toTex());
     [0, 1, 2].forEach((rand) => {
         const identifiersWrong = Object.assign({}, identifiers, { rand });
-        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+        const nodeWrong = getAnswerNode(identifiersWrong, opts);
+        if (!NodeComparator.isEqualViaSub(nodeWrong, nodeAnswerSameOrEquivalent)) {
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+        }
     });
     //exp(a)+exp(b)
     {
@@ -225,7 +232,15 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         }
     }
     const nodeAnswer = parseAlgebraic(answer);
-    return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    const isEquivalentFound = () => {
+        const arrNodeAnswerEquivalent = NodeRewriter.getArrNodeEquivalent(nodeAnswer);
+        return arrNodeAnswerEquivalent.some((nodeAnswerRefined) => {
+            const isEqual = NodeComparator.isEqualViaSub(nodeAns, nodeAnswerRefined);
+            return isEqual;
+        });
+    };
+    const isValid = isEquivalentFound();
+    return isValid;
 };
 const getRewriteExpUsingExpAQuestion = (optsIn) => {
     const opts = optsIn ?? optsDefault;

package/lib/exercises/math/functions/exponential/expKT/derivativeOfAExpKT.d.ts

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

package/lib/exercises/math/functions/exponential/expKT/derivativeOfAExpKT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeOfAExpKT.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/expKT/derivativeOfAExpKT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IAEjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/functions/exponential/expKT/derivativeOfAExpKT.js

@@ -0,0 +1,108 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, a, k }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, multiply(a, exp(multiply(k, "t"))).toTex());
+    tryToAddWrongProp(propositions, multiply(a, exp("t")).toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, multiply(randint(-10, 10, [0]), exp(multiply(k, "t"))).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, k } = identifiers;
+    return multiply(multiply(a, k), exp(multiply(k, "t")))
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, k } = identifiers;
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(t) = ${multiply(a, exp(multiply(k, "t"))).toTex()}
+$$
+
+Calculer la dérivée $f'$ de $f$.`;
+};
+const getHint = () => {
+    return `Pour tout $k$ réel, on a :
+  
+$$
+\\left(e^{kt}\\right)' = ke^{kt}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, k } = identifiers;
+    return `Pour tout $k$ réel, on a :
+  
+$$
+\\left(e^{kt}\\right)' = ke^{kt}
+$$
+
+Ici, on a donc pour tout $t$ réel : 
+
+${alignTex([
+        ["f'(t)", "=", multiply(a, multiply(k, exp(multiply(k, "t")))).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getKeys = () => {
+    return ["epower", "t"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDerivativeOfAExpKtQuestion = () => {
+    const a = randint(-10, 10, [0, 1]);
+    const k = randint(-10, 10, [0, 1]);
+    const identifiers = {
+        a,
+        k,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const derivativeOfAExpKT = {
+    id: "derivativeOfAExpKT",
+    connector: "=",
+    label: "Dérivée du type $ae^{kt}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeOfAExpKtQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponential/expKT/drugConcentrationMaximum.d.ts

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

package/lib/exercises/math/functions/exponential/expKT/drugConcentrationMaximum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drugConcentrationMaximum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/expKT/drugConcentrationMaximum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAyIF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAmB1D,CAAC"}

package/lib/exercises/math/functions/exponential/expKT/drugConcentrationMaximum.js

@@ -0,0 +1,144 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.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 { 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";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0.1, 4, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //t = 1/k
+    return round(frac(1, identifiers.k).evaluate(), 2).frenchify();
+};
+const getFunc = (identifiers) => {
+    const { a, k } = identifiers;
+    return multiply(a, multiply("t", exp(multiply(-k, "t")))).simplify();
+};
+const getInstruction = (identifiers) => {
+    return `On fait absorber un médicament, sous forme de compriné, à un patient. On modélise la quantité de médicament présente dans le sang du patient, exprimé en $\\textrm{mg}$, par la fonction $f$ définie sur l'intervalle $[0; +\\infty[$ par :
+
+$$
+f(t)=${getFunc(identifiers).toTex()}
+$$
+
+où $t$ définit le temps, exprimé en heure, écoulé depuis
+la prise du comprimé.
+
+Au bout de combien de temps la quantité de médicament présente dans le sang du patient sera-t-elle maximale ?
+
+Donner une valeur arrondie au centième.`;
+};
+const getHint = () => {
+    return `Dérive la fonction $f$, puis étudie le signe de $f'(x)$. Tu pourras alors en déduire les variations de $f$, et ainsi déterminer la valeur de $t$ pour laquelle la quantité de médicament dans le sang du patient sera maximale.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, k } = identifiers;
+    //atexp(-kt)
+    //f' = aexp(-kt) + at(-kexp(-kt))
+    //f' = exp(-kt)(a-kat)
+    //f' = (aexp(-kt)(1-kt)
+    //t = 1/k
+    const expo = exp(multiply(-k, "t"));
+    return `On calcule $f'(t)$. Pour cela, on utilise les deux propriétés suivantes :
+  
+$$
+(uv)' = u'v+uv'
+$$
+
+et 
+
+$$
+\\left(e^{kx}\\right)' = ke^{kx}
+$$
+  
+
+On a donc : 
+
+${alignTex([
+        [
+            "f'(t)",
+            "=",
+            substract(multiply(a, expo), multiply(multiply(a, "t"), multiply(-k, expo))).toTex(),
+        ],
+        [
+            "",
+            "=",
+            multiply(multiply(a, expo), substract(1, multiply(k, "t"))).toTex(),
+        ],
+    ])}
+
+On étudie alors le signe de $f'(t)$ : 
+
+- $${multiply(a, expo).toTex()}$ est positif sur $\\mathbb{R}$ car l'exponentielle est strictement positive sur $\\mathbb{R}$.
+
+- $${substract(1, multiply(k, "t")).toTex()}\\geq 0 \\iff t\\leq ${frac(1, k).toTex()}$
+
+La fonction $f$ admet donc un maximum pour $t\\approx ${getAnswer(identifiers)}$.
+
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { k }) => {
+    try {
+        return rationalVEA(ans, frac(1, k).toTex(), {
+            allowDecimal: true,
+            decimalPrecision: 2,
+        });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDrugConcentrationMaximumQuestion = () => {
+    const a = 0.5 * randint(1, 20);
+    const k = randfloat(0.1, 3, 1, [1]);
+    const identifiers = {
+        a,
+        k,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const drugConcentrationMaximum = {
+    id: "drugConcentrationMaximum",
+    connector: "=",
+    label: "Déterminer la concentration maximale d'un médicament dans le sang pour une fonction avec exponentielle du type $f(t) = ate^{-kt}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDrugConcentrationMaximumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/exponential/expKT/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./drugConcentrationMaximum.js";
+export * from "./derivativeOfAExpKT.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/exponential/expKT/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/expKT/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/functions/exponential/expKT/index.js

@@ -0,0 +1,2 @@
+export * from "./drugConcentrationMaximum.js";
+export * from "./derivativeOfAExpKT.js";

package/lib/exercises/math/functions/exponential/expSimplifiying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAmKF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"expSimplifiying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expSimplifiying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA0PF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}