math-exercises 3.0.157 → 3.0.158

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

@@ -0,0 +1,282 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp, ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { add, AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac, FractionNode, isFractionNode, } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } 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";
+const getInstructionNode = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const nodeNum = add(multiply(a, exp("x".toTree())), b);
+    const nodeDen = add(multiply(c, exp("x".toTree())), d);
+    return frac(nodeNum, nodeDen);
+};
+const getPrettyFractionNode = (nodeFraction) => {
+    const nodeNum = nodeFraction.leftChild.simplify({ towardsDistribute: true });
+    const nodeDen = nodeFraction.rightChild;
+    return frac(nodeNum, nodeDen);
+};
+const getInstruction = (identifiers) => {
+    const nodeF = getInstructionNode(identifiers);
+    return `Déterminer la dérivée de la fonction $f$ définie par :
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const nodeRaw = getInstructionNode(identifiers).derivative();
+    if (isFractionNode(nodeRaw)) {
+        const nodeFraction = nodeRaw;
+        return getPrettyFractionNode(nodeFraction);
+    }
+    else {
+        return nodeRaw;
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, pour $x$ tel que $v(x)\\neq0$, on a : 
+
+$$
+(\\frac{u}{v})'(x) = \\frac{u'(x)v(x)-u(x)v'(x)}{{v(x)}^2}
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const nodeInstruction = getInstructionNode(identifiers);
+    const [nodeU, nodeV] = [
+        nodeInstruction.leftChild,
+        nodeInstruction.rightChild,
+    ];
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    return `On doit calculer la dérivée d'un quotient.
+  
+Ici, on a : 
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule : 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+$$
+(\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)), power(nodeV, 2)).toTex()}
+$$
+
+$$
+(\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV).simplify({ towardsDistribute: true }), multiply(nodeU, nodeVPrime).simplify({ towardsDistribute: true })), power(nodeV, 2)).toTex()}
+$$
+
+$$
+f'(x) = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, c, d } = identifiers;
+    //student: (u/v)' = u'/v'
+    {
+        tryToAddWrongProp(propositions, frac(a, c).simplify({ decimalToFractions: true }).toTex());
+    }
+    //student: (u/v)' = (u'v+uv')/v²
+    {
+        class WrongFractionNode extends FractionNode {
+            derivative(varName) {
+                const numNode = add(multiply(this.leftChild.derivative(varName), this.rightChild), multiply(this.leftChild, this.rightChild.derivative(varName)));
+                const denNode = power(this.rightChild, 2);
+                return frac(numNode, denNode);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            const nodeNum = add(multiply(a, exp("x".toTree())), b);
+            const nodeDen = add(multiply(c, exp("x".toTree())), d);
+            return new WrongFractionNode(nodeNum, nodeDen);
+        })();
+        const nodeRaw = wrongInstructionNode.derivative();
+        let nodeWrong;
+        if (isFractionNode(nodeRaw)) {
+            nodeWrong = getPrettyFractionNode(nodeRaw);
+        }
+        else {
+            nodeWrong = nodeRaw;
+        }
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: (u/v)' = -u'/v²
+    {
+        class WrongFractionNode extends FractionNode {
+            derivative(varName) {
+                const numNode = multiply(-1, this.leftChild).derivative(varName);
+                const denNode = power(this.rightChild, 2);
+                return frac(numNode, denNode);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            const nodeNum = add(multiply(a, exp("x".toTree())), b);
+            const nodeDen = add(multiply(c, exp("x".toTree())), d);
+            return new WrongFractionNode(nodeNum, nodeDen);
+        })();
+        const nodeRaw = wrongInstructionNode.derivative();
+        let nodeWrong;
+        if (isFractionNode(nodeRaw)) {
+            nodeWrong = getPrettyFractionNode(nodeRaw);
+        }
+        else {
+            nodeWrong = nodeRaw;
+        }
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: exp(x)' = x.exp(x)
+    {
+        class MyAddNode extends AddNode {
+            simplify(opts, log) {
+                if (this.leftChild.evaluate() === 0 ||
+                    this.rightChild.evaluate() === 0) {
+                    return (0).toTree();
+                }
+                else {
+                    return super.simplify(opts, log);
+                }
+            }
+        }
+        class MyMultiplyNode extends MultiplyNode {
+            derivative(varName) {
+                return new MyAddNode(new MyMultiplyNode(this.leftChild.derivative(varName).simplify(), this.rightChild), new MyMultiplyNode(this.leftChild, this.rightChild.derivative(varName).simplify())).simplify();
+            }
+            simplify(opts, log) {
+                if (this.leftChild.evaluate() === 0 ||
+                    this.rightChild.evaluate() === 0) {
+                    return (0).toTree();
+                }
+                else {
+                    return super.simplify(opts, log);
+                }
+            }
+        }
+        class WrongExpNode extends ExpNode {
+            derivative(varName = "x") {
+                const derivateSuper = new MyMultiplyNode(this.child.derivative(varName), exp(this.child));
+                return new MyMultiplyNode(varName.toTree(), derivateSuper);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            const nodeNum = add(new MyMultiplyNode(a.toTree(), new WrongExpNode("x".toTree())), b);
+            const nodeDen = add(new MyMultiplyNode(c.toTree(), new WrongExpNode("x".toTree())), d);
+            return frac(nodeNum, nodeDen);
+        })();
+        const nodeRaw = wrongInstructionNode.derivative();
+        let nodeWrong;
+        if (isFractionNode(nodeRaw)) {
+            const nodeFraction = nodeRaw;
+            const nodeNum = nodeFraction.leftChild.simplify({});
+            const nodeDen = nodeFraction.rightChild;
+            nodeWrong = frac(nodeNum, nodeDen);
+        }
+        else {
+            nodeWrong = nodeRaw;
+        }
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    return [0, 1, 2, 10].every((x) => {
+        return (substract(nodeAns.evaluate({ x }), nodeAnswer.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getExpOverExpDerivativeQuestion = () => {
+    function createRandomIdentifiers() {
+        const a = randint(-9, 10, [0]);
+        const b = randint(-9, 10, [0]);
+        const c = randint(9, 10, [0]);
+        const d = randint(-9, 10, [c, -c, 0]);
+        const identifiers = { a, b, c, d };
+        return identifiers;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        try {
+            const nodeAnswer = getAnswerNode(identifiersCandidate);
+            if (nodeAnswer && isFractionNode(nodeAnswer)) {
+                const nodeFraction = nodeAnswer;
+                const isZero = nodeFraction.leftChild.evaluate() === 0;
+                isValid = !isZero;
+                if (isValid) {
+                    identifiers = identifiersCandidate;
+                }
+            }
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            a: 1,
+            b: 2,
+            c: 2,
+            d: 3,
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: "f'(x)",
+        answer: getAnswer(identifiers),
+        keys: ["x", "epower"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const expOverExpDerivative = {
+    id: "expOverExpDerivative",
+    connector: "=",
+    label: "Dérivée de $\\frac{a e^x + b}{c e^x + d}$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getExpOverExpDerivativeQuestion, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/inverseFunctionDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/inverseFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+DF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"inverseFunctionDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/inverseFunctionDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/derivation/derivative/inverseFunctionDerivative.js

@@ -3,6 +3,31 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.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 `On rappelle que : 
+  
+$$
+\\left(\\frac{1}{x}\\right)' = -\\frac{1}{x^2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a } = identifiers;
+    return `On a : 
+  
+$$
+f(x) = ${a}\\times \\frac{1}{x}
+$$
+
+donc 
+
+${alignTex([
+        ["f'(x)", "=", `${a}\\times \\left(\\frac{1}{x}\\right)'`],
+        ["", "=", `${a}\\times \\left(-\\frac{1}{x^2}\\right)`],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
 const getInstruction = (identifiers) => {
     const { a } = identifiers;
     return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par :
@@ -17,7 +42,7 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getInverseFunctionDerivative = () => {
-    const a = randint(-19, 20, [0]);
+    const a = randint(-19, 20, [0, 1]);
     const identifiers = { a };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -29,6 +54,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -59,7 +86,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const inverseFunctionDerivative = {
     id: "inverseFunctionDerivative",
     connector: "=",
-    label: "Dérivée d'une fonction inverse",
+    label: "Dérivée d'une fonction inverse du type $f(x) = \\frac{k}{x}$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getInverseFunctionDerivative, nb),
     qcmTimer: 60,
@@ -70,4 +97,5 @@ export const inverseFunctionDerivative = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/productDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"productDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/productDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAuFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"productDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/productDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA2JF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/derivation/derivative/productDerivative.js

@@ -1,9 +1,73 @@
 import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.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 { 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 $f$ est un produit de la forme : 
+  
+$$
+f(x) = u(x)\\times v(x)
+$$
+
+On peut alors utiliser la formule de la dérivée d'un produit : 
+
+$$
+(uv)' = u'v+uv'
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { poly1Coeffs, poly2Coeffs } = identifiers;
+    const u = new Polynomial(poly1Coeffs);
+    const uTree = u.toTree();
+    const uprime = u.derivate();
+    const uprimeTree = uprime.toTree();
+    const v = new Polynomial(poly2Coeffs);
+    const vTree = v.toTree();
+    const vprime = v.derivate();
+    const vprimeTree = vprime.toTree();
+    return `La fonction $f$ est un produit de la forme $u(x)\\times v(x)$, avec : 
+
+$$
+u(x) = ${uTree.toTex()}
+$$
+
+et 
+
+$$
+v(x) = ${vTree.toTex()}
+$$
+
+On a donc $u'(x) = ${uprimeTree.toTex()}$ et $v'(x) = ${vprimeTree.toTex()}$. 
+
+La fonction dérivée de $f$ est donc : 
+
+${alignTex([
+        ["f'(x)", "=", "u'v+uv'"],
+        [
+            "",
+            "=",
+            add(multiply(uprimeTree, vTree), multiply(uTree, vprimeTree)).toTex(),
+        ],
+        [
+            "",
+            "=",
+            add(multiply(uprimeTree, vTree).simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            }), multiply(uTree, vprimeTree).simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            })).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+
+  `;
+};
 const getInstruction = (identifiers) => {
     const { poly1Coeffs, poly2Coeffs } = identifiers;
     const poly1 = new Polynomial(poly1Coeffs);
@@ -37,6 +101,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "xsquare", "xcube"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +149,5 @@ export const productDerivative = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/quotientDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quotientDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/quotientDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA6GF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"quotientDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/quotientDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAsJF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/derivation/derivative/quotientDerivative.js

@@ -1,10 +1,43 @@
 import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
-import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { frac, FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square, SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.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 $f$ est un quotient. Utilise donc la formule de dérivation d'un quotient : 
+  
+$$
+\\left(\\frac{u}{v}\\right)' = \\frac{u'v - uv'}{v^2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const poly1 = new Polynomial(identifiers.poly1Coeffs);
+    const poly1Tree = poly1.toTree();
+    const poly1Prime = poly1.derivate().toTree();
+    const poly2 = new Polynomial(identifiers.poly2Coeffs);
+    const poly2Tree = poly2.toTree();
+    const poly2Prime = poly2.derivate().toTree();
+    return `La fonction $f$ est un quotient de la forme $\\frac{u}{v}$, avec $u(x) = ${poly1Tree.toTex()}$ et $v(x) = ${poly2Tree.toTex()}$.
+  
+On a donc $u'(x) = ${poly1Prime.toTex()}$ et $v'(x) = ${poly2Prime.toTex()}$.
+
+On utilise donc la formule de la dérivée d'un quotient :
+
+${alignTex([
+        ["f'(x)", "=", `\\frac{u'v - uv'}{v^2}`],
+        [
+            "",
+            "=",
+            frac(substract(multiply(poly1Prime, poly2Tree), multiply(poly1Tree, poly2Prime)), square(poly2Tree)).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const poly1 = new Polynomial(identifiers.poly1Coeffs);
     const poly2 = new Polynomial(identifiers.poly2Coeffs);
@@ -14,7 +47,7 @@ $$
 f(x) = ${new FractionNode(poly1.toTree(), poly2.toTree()).toTex()}
 $$`;
 };
-const getAnwer = (identifiers) => {
+const getAnswer = (identifiers) => {
     const poly1 = new Polynomial(identifiers.poly1Coeffs);
     const poly2 = new Polynomial(identifiers.poly2Coeffs);
     const answerNum = poly1
@@ -49,11 +82,13 @@ const getProductDerivativeQuestion = () => {
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: getAnwer(identifiers),
+        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: ["x", "xsquare", "xcube"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -103,4 +138,5 @@ export const quotientDerivative = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"sqrtCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAuHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.js

@@ -2,11 +2,35 @@ import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../..
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { SqrtNode } from "../../../../../tree/nodes/functions/sqrtNode.js";
-import { FractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { sqrt, SqrtNode } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { frac, FractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, 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(\\sqrt{u}\\right)' = \\frac{u'}{2 \\times \\sqrt{u}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    return `On utilise la formule de dérivation suivante : 
+  
+$$
+\\left(\\sqrt{u}\\right)' = \\frac{u'}{2 \\times \\sqrt{u}}
+$$
+
+Ici, $u(x) = ${affine.toTree().toTex()}$, donc $u'(x) = ${affineA}$.
+
+Ainsi, 
+
+$$
+f'(x) = ${frac(affineA, multiply(2, sqrt(affine.toTree()))).toSimplificationTex()}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { affineA, affineB } = identifiers;
     const affine = new Affine(affineA, affineB);
@@ -36,6 +60,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -78,4 +104,5 @@ export const sqrtCompositionDerivation = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageRateOfChangeAlgebraicExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/averageRateOfChangeAlgebraicExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAyEF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAuCF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAyBR,CAAC"}