math-exercises 3.0.157 → 3.0.158

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.js

@@ -0,0 +1,437 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { EmptySet } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { zip } from "../../../../../utils/arrays/arrayZip.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { InequationSolutionNode } from "../../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+import { InequationSymbol, InequationSymbolConstructor, } from "../../../../../math/inequations/inequation.js";
+import { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { inequationSolutionFormat } from "../../../../../exercises/options/inequationSolutionFormat.js";
+import { unionIntervalParser } from "../../../../../tree/parsers/unionIntervalParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+//reuse other exercises:  (unfortunately breaks exosTest)
+// import { reuseSecondDegreeInequation } from "../../../../../exercises/math/functions/trinoms/equation/secondDegreeInequation.js";
+// import { reuseFirstDegreeInequationsType3 } from "../../../../../exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.js";
+import { intervalParser } from "../../../../../tree/parsers/intervalParser.js";
+import { inequationParser } from "../../../../../tree/parsers/inequationParser.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { UnionIntervalNode } from "../../../../../tree/nodes/sets/unionIntervalNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const reuseSecondDegreeInequation = {
+    getAnswerNode: (identifiers) => {
+        const { a, b, c, ineqType } = identifiers;
+        const ineq = new InequationSymbol(ineqType);
+        const trinom = new Trinom(a, b, c);
+        const roots = trinom.getRootsNode();
+        const aPositive = a > 0;
+        const insideInterval = new IntervalNode(roots[0], roots[1], ineq.isStrict ? ClosureType.OO : ClosureType.FF);
+        const outsideUnion = new UnionIntervalNode([
+            new IntervalNode(MinusInfinityNode, roots[0], ineq.isStrict ? ClosureType.OO : ClosureType.OF),
+            new IntervalNode(roots[1], PlusInfinityNode, ineq.isStrict ? ClosureType.OO : ClosureType.FO),
+        ]);
+        const tree = ineq.isSup
+            ? aPositive
+                ? outsideUnion
+                : insideInterval
+            : aPositive
+                ? insideInterval
+                : outsideUnion;
+        return new InequationSolutionNode(tree);
+    },
+};
+const reuseFirstDegreeInequationsType3 = {
+    getAnswerNode: (identifiers, opts) => {
+        const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+        const { ineqType, a, b, c, d, coeff } = identifiers;
+        const affine1 = new Affine(a, b);
+        const affine2 = new Affine(c, d);
+        const result = new Rational(affine2.b - affine1.b, affine1.a - affine2.a)
+            .simplify()
+            .toTree();
+        const invIneqType = new InequationSymbol(ineqType).reversed();
+        const ineq = new InequationNode(["x".toTree(), result], coeff > 0 ? ineqType : invIneqType);
+        const node = isInterval
+            ? new InequationSolutionNode(ineq.toInterval())
+            : ineq;
+        return node;
+    },
+};
+const texXDomain = `\\mathbb{R}`;
+const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+const texbbR = intervalbbR.toTex();
+const createNodeForCoeffs = (coeffs) => {
+    //because Error: n-th coeff must be not null at new Polynomial
+    const [a, b, c] = coeffs.toReversed();
+    if (a !== 0) {
+        return new Polynomial(coeffs).toTree();
+    }
+    else if (b !== 0) {
+        return AffineConstructor.fromCoeffs(coeffs).toTree();
+    }
+    else {
+        return c.toTree();
+    }
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    const statementTree = new InequationNode([exp(nodeF), exp(nodeG)], ineqType);
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const { inequationSolutionFormat } = opts;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isZero = [a, b, c].every((k) => k === 0);
+    if (isZero) {
+        switch (ineqType) {
+            case "<":
+            case ">":
+                return new EquationSolutionNode(EmptySet);
+            case "\\le":
+            case "\\ge": {
+                const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+                return new InequationSolutionNode(intervalbbR);
+            }
+        }
+    }
+    else {
+        if (a !== 0) {
+            return reuseSecondDegreeInequation.getAnswerNode({ a, b, c, ineqType });
+        }
+        else if (b !== 0) {
+            const [b, a] = coeffsF;
+            const [d, c] = coeffsG;
+            return reuseFirstDegreeInequationsType3.getAnswerNode({ a, b, c, d, ineqType, coeff: a - c }, { inequationSolutionFormat });
+        }
+        else {
+            //a==0,b==0,c!==0
+            return new EquationSolutionNode(EmptySet);
+        }
+    }
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isCoeffsZero = [a, b, c].every((k) => k === 0);
+    if (isCoeffsZero) {
+        switch (ineqType) {
+            case "<":
+            case ">": {
+                if (opts.inequationSolutionFormat === "Inégalité (x>a)") {
+                    return `x\\in\\varnothing`;
+                }
+                else {
+                    return `S=\\varnothing`;
+                }
+            }
+            case "\\le":
+            case "\\ge": {
+                if (opts.inequationSolutionFormat === "Inégalité (x>a)") {
+                    return `x\\in${texbbR}`;
+                }
+                else {
+                    return `S=${texbbR}`;
+                }
+            }
+        }
+    }
+    else {
+        return getAnswerNode(identifiers, opts).toTex();
+    }
+};
+const getHint = () => {
+    return `Essaye de transformer l'équation originale en une équation du type $e^{h(x)}=1$, puis résous cette équation.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    //that would be nice, but:
+    //Error: should-throw Too many iterations in simplify
+    // const nodeFMinusGSimplified = substract(nodeF, nodeG).simplify({
+    //   towardsDistribute: true,
+    // });
+    //workaround:
+    const coeffsFMinusG = zip(coeffsF, coeffsG).map(([kF, kG]) => kF - kG);
+    const nodeFMinusGSimplified = createNodeForCoeffs(coeffsFMinusG);
+    return `On va transformer l'équation originale pour se ramener à quelque chose que l'on connaît mieux.
+
+L'ensemble image de la fonction exponentielle est $\\mathbb{R}^{+*}$ donc on peut tout diviser par le membre de droite sans changer le sens de l'inégalité.
+  
+${alignTex([
+        ["", "", getStatementNode(identifiers).toTex()],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([frac(exp(nodeF), exp(nodeG)), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([exp(substract(nodeF, nodeG)), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([exp(nodeFMinusGSimplified), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([nodeFMinusGSimplified, (0).toTree()], ineqType).toTex(),
+        ],
+    ])}
+
+On résout l'inéquation : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    //random coeff signs for f and g
+    {
+        function getArrSign() {
+            return getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1])).filter((arrS) => !arrS.every((s) => s === 1));
+        }
+        getCartesiansProducts([getArrSign(), getArrSign()]).forEach(([arrSignF, arrSignG]) => {
+            try {
+                const coeffsFWrong = zip(arrSignF, coeffsF).map(([s, k]) => s * k);
+                const coeffsGWrong = zip(arrSignG, coeffsG).map(([s, k]) => s * k);
+                const identifiersWrong = {
+                    coeffsF: coeffsFWrong,
+                    coeffsG: coeffsGWrong,
+                    ineqType,
+                };
+                const texWrong = getAnswer(identifiersWrong, opts);
+                tryToAddWrongProp(propositions, texWrong);
+            }
+            catch (_) {
+                (() => { })();
+            }
+        });
+    }
+    //random ineqType
+    {
+        ["<", ">", "\\le", "\\ge"].forEach((inequalitySymbol) => {
+            try {
+                const identifiersWrong = {
+                    coeffsF,
+                    coeffsG,
+                    ineqType: inequalitySymbol,
+                };
+                const texWrong = getAnswer(identifiersWrong, opts);
+                tryToAddWrongProp(propositions, texWrong);
+            }
+            catch (_) {
+                (() => { })();
+            }
+        });
+    }
+    const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+    propWhile(propositions, n, () => {
+        const wrongRes = randint(-10, 11).toTree();
+        const wrongSymb = coinFlip()
+            ? ineqType
+            : InequationSymbolConstructor.reverse(ineqType);
+        const wrongIneq = new InequationNode(["x".toTree(), wrongRes], wrongSymb);
+        tryToAddWrongProp(propositions, isInterval
+            ? new InequationSolutionNode(wrongIneq.toInterval()).toTex()
+            : wrongIneq.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_identifiers, opts) => {
+    const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+    if (isInterval)
+        return [
+            "S",
+            "equal",
+            "lbracket",
+            "semicolon",
+            "rbracket",
+            "infty",
+            "varnothing",
+        ];
+    return [
+        "x",
+        "inf",
+        "sup",
+        "leq",
+        "geq",
+        "belongs",
+        "varnothing",
+        "lbracket",
+        "semicolon",
+        "rbracket",
+        "infty",
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    if (ans === answer) {
+        return true;
+    }
+    const { coeffsF, coeffsG } = identifiers;
+    const [a, _b, _c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    if (a !== 0) {
+        try {
+            const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+            if (isInterval) {
+                const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+                if (!parsed)
+                    return false;
+                return "S=\\ " + parsed.simplify().toTex() === answer;
+            }
+            else {
+                const parsed = inequationParser(ans);
+                if (!parsed)
+                    return false;
+                return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+            }
+        }
+        catch (err) {
+            return handleVEAError(err);
+        }
+    }
+    else {
+        try {
+            const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+            if (isInterval) {
+                const parsed = intervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+                if (!parsed)
+                    return false;
+                return ("S=\\ " + parsed.simplify({ decimalToFractions: true }).toTex() ===
+                    answer);
+            }
+            else {
+                const parsed = inequationParser(ans);
+                if (!parsed)
+                    return false;
+                return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+            }
+        }
+        catch (err) {
+            return handleVEAError(err);
+        }
+    }
+};
+const getExpOfFEqualsExpOfGInequationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { functionTypeF, functionTypeG } = opts;
+    function degreeForFunctionType(functionType) {
+        switch (functionType) {
+            case "constante":
+                return 0;
+            case "degré $1$":
+                return 1;
+            case "degré $2$":
+                return 2;
+            default:
+                throw new Error("Unsupported functionType: " + functionType);
+        }
+    }
+    const [degreeF, degreeG] = [functionTypeF, functionTypeG].map(degreeForFunctionType);
+    function createCoeffs(degree) {
+        const c = randint(-10, 11, [0]);
+        const b = degree >= 1 ? randint(-10, 11, [0]) : 0;
+        const a = degree >= 2 ? randint(-10, 11, [0]) : 0;
+        return [c, b, a];
+    }
+    const [coeffsF, coeffsG] = [degreeF, degreeG].map(createCoeffs);
+    const ineqType = InequationSymbolConstructor.randomSymbol();
+    const identifiers = { coeffsF, coeffsG, ineqType };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const optsDefault = {
+    inequationSolutionFormat: inequationSolutionFormat.defaultValue,
+    functionTypeF: "degré $1$",
+    functionTypeG: "degré $1$",
+};
+const options = [
+    inequationSolutionFormat,
+    {
+        id: "functionTypeF",
+        label: "Fonction $f$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeF,
+    },
+    {
+        id: "functionTypeG",
+        label: "Fonction $g$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeG,
+    },
+];
+export const expOfFEqualsExpOfGInequation = {
+    id: "expOfFEqualsExpOfGInequation",
+    connector: "\\iff",
+    label: "Résoudre une inéquation du type $e^{f(x)}<e^{g(x)}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfFEqualsExpOfGInequationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/calculLitteral/inequations/exp/index.d.ts

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

package/lib/exercises/math/calculLitteral/inequations/exp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/inequations/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/exp/index.js

@@ -0,0 +1 @@
+export * from "./expOfFEqualsExpOfGInequation.js";

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.js

@@ -8,6 +8,32 @@ import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
 import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getHint = () => {
+    return `Utilise la formule de dérivation suivante : 
+  
+$$
+\\left(e^{u}\\right)' = u' \\times e^{u}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Polynomial([b, a]);
+    return `On utilise la formule de dérivation suivante : 
+  
+$$
+\\left(e^{u}\\right)' = u' \\times e^{u}
+$$
+
+Ici, $u(x) = ${affine.toTree().toTex()}$. 
+
+Donc $u'(x) = ${a}$.
+
+Ainsi, 
+
+$$
+f'(x) = ${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { a, b } = identifiers;
     const affine = new Polynomial([b, a]);
@@ -40,6 +66,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "epower", "exp"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -87,4 +115,5 @@ export const expDerivativeOne = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/exp/expDerivativeThree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"expDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeThree.js

@@ -2,12 +2,42 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../e
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { exp, ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHint = () => {
+    return `La fonction proposée est un produit. On peut donc utiliser la formule de dérivation : 
+  
+$$
+(uv)' = u'v+uv'
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Polynomial([b, a]).toTree();
+    const expo = exp("x");
+    return `$f(x)$ est de la forme $u(x)\\times v(x)$, avec $u(x) = ${affine.toTex()}$, et $v(x) = ${expo.toTex()}$.
+  
+On a donc $u'(x) = ${a}$, et $v'(x) = ${expo.toTex()}$.
+
+On utilise alors la formule de dérivation d'un produit : 
+
+$$
+(uv)' = u'v+uv'
+$$
+
+Cela donne : 
+
+${alignTex([
+        ["f'(x)", "=", add(multiply(a, expo), multiply(affine, expo)).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { a, b } = identifiers;
     const myfunction = new MultiplyNode(new Polynomial([b, a]).toTree(), new ExpNode(new VariableNode("x")));
@@ -33,6 +63,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "epower", "exp"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +115,5 @@ export const expDerivativeThree = {
     getInstruction,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/exp/expDerivativeTwo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeTwo.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeTwo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"expDerivativeTwo.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeTwo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeTwo.js

@@ -8,6 +8,22 @@ import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.j
 import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getHint = () => {
+    return `La fonction exponentielle est égale à sa dérivée.`;
+};
+const getCorrection = (identifiers) => {
+    return `On sait que la fonction exponentielle est égale à sa dérivée, c'est à dire : 
+  
+$$
+\\left(e^x\\right)' = e^x
+$$
+
+On a donc : 
+
+$$
+f'(x) = ${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { a, b } = identifiers;
     const myfunction = new AddNode(new MultiplyNode(new NumberNode(a), new ExpNode(new VariableNode("x"))), new NumberNode(b));
@@ -37,6 +53,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "epower", "exp"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +95,5 @@ export const expDerivativeTwo = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/exp/expOverExpDerivative.d.ts

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

package/lib/exercises/math/derivation/derivative/exp/expOverExpDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expOverExpDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expOverExpDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAqCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmUF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}