math-exercises 3.0.157 → 3.0.158

package/lib/exercises/math/functions/exponential/definition/isPlausibleExpFromGraph.js

@@ -0,0 +1,375 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { blueLight, orange, red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.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 { 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";
+const getCenteredScaledFrame = (coords, scaleFactor) => {
+    const [xMin, xMax, yMin, yMax] = coords;
+    const xCenter = (xMax + xMin) / 2.0;
+    const yCenter = (yMax + yMin) / 2.0;
+    return [
+        xCenter + (xMin - xCenter) * scaleFactor,
+        xCenter + (xMax - xCenter) * scaleFactor,
+        yCenter + (yMin - yCenter) * scaleFactor,
+        yCenter + (yMax - yCenter) * scaleFactor,
+    ];
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { rand } = identifiers;
+    const isPlausible = rand < 2;
+    return ["Oui", "Non"][isPlausible ? 0 : 1];
+};
+const getInstruction = () => {
+    return `La figure ci-dessous montre une portion 
+de la courbe représentative d'une fonction $f$ (en rouge) 
+et une de ses tangentes (en bleu).
+
+En considérant ce qui est représenté de $f$, peut-il s'agir de la fonction exponentielle ?`;
+};
+const getHint = () => {
+    return `La fonction exponentielle vérifie pour tout $x$ réel :
+
+$$
+\\exp'(x)=\\exp(x) > 0
+$$
+
+Sa courbe représentative est toujours au-dessus de ses tangentes.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { rand } = identifiers;
+    switch (rand) {
+        case 0:
+            return `La fonction $f$ représentée est telle que, 
+
+pour l'abscisse $x_{0}$ où est tracée la tangente :
+      
+- $f'(x_{0})=f(x_{0})$
+
+- $f'(x_{0})>0$
+
+- la tangente est en dessous de la courbe.
+
+Il peut donc s'agir de la fonction exponentielle.
+
+(Et en effet, ici, $f=\\exp$).
+
+`;
+        case 1:
+            return `La fonction $f$ représentée est telle que, 
+
+pour l'abscisse $x_{0}$ où est tracée la tangente :
+      
+- $f'(x_{0})=f(x_{0})$
+
+- $f'(x_{0})>0$
+
+- la tangente est en dessous de la courbe.
+
+Il peut donc s'agir de la fonction exponentielle.
+
+(En fait, ici, $f$ est une parabole).
+
+`;
+        case 2:
+            return `La fonction $f$ représentée est telle que, 
+
+pour l'abscisse $x$ où est tracée la tangente :
+      
+- $f'(x) \\neq f(x)$
+
+Il ne peut donc pas s'agir de la fonction exponentielle.
+
+(En fait, ici, $f$ est une parabole).
+
+`;
+        case 3:
+            return `La fonction $f$ représentée est telle que, 
+
+pour l'abscisse $x_{0}$ où est tracée la tangente :
+      
+- $f'(x_{0})<0$
+
+Il ne peut donc pas s'agir de la fonction exponentielle.
+
+(En fait, ici, $f$ est une parabole).
+
+`;
+        case 4:
+        case 5:
+        case 6:
+            return `La fonction $f$ représentée est telle que, 
+      
+pour l'abscisse $x$ où est tracée la tangente :
+      
+- la tangente est au-dessus de la courbe.
+
+Il ne peut donc pas s'agir de la fonction exponentielle.
+
+(En fait, ici, $f$ est une parabole).
+
+`;
+        default:
+            throw new Error("Unsupported rand: " + rand);
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsT, coordsFrame } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeT = NodeConstructor.fromIdentifiers(nodeIdsT);
+    const [xMinFrame, xMaxFrame, yMinFrame, yMaxFrame] = coordsFrame;
+    const [xMin, xMax, yMin, yMax] = getCenteredScaledFrame(coordsFrame, 5);
+    const commands = [
+        `Cf = ${nodeF.toMathString()}`,
+        `SetColor(Cf, "${red}")`,
+        `Ct = ${nodeT.toMathString()}`,
+        `SetColor(Ct, "${blueLight}")`,
+        //show instruction frame
+        `Rframe = Polygon((${xMinFrame},${yMaxFrame}),(${xMaxFrame},${yMaxFrame}),(${xMaxFrame},${yMinFrame}),(${xMinFrame},${yMinFrame}))`,
+        `SetColor(Rframe, "${orange}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        lockedAxesRatio: (xMaxFrame - xMinFrame) / (yMaxFrame - yMinFrame),
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsF, nodeIdsT, coordsFrame, s } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeT = NodeConstructor.fromIdentifiers(nodeIdsT);
+    const [xMin, xMax, yMin, yMax] = coordsFrame;
+    const xCenter = (xMin + xMax) / 2.0;
+    const yCenter = (yMin + yMax) / 2.0;
+    const commands = [
+        `Cf = ${nodeF.toMathString()}`,
+        `SetColor(Cf, "${red}")`,
+        `Ct = ${nodeT.toMathString()}`,
+        `SetColor(Ct, "${blueLight}")`,
+        //label with slope
+        `Lbl = Text("$\\large \\text{pente}\\approx${round(s, 2).frenchify()}$", (${xCenter},${yCenter}), false, true, 0, 0)`,
+        `SetFixed(Lbl, true, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        xAxis: {
+            hidden: true,
+        },
+        hideGrid: true,
+        lockedAxesRatio: (xMax - xMin) / (yMax - yMin),
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getIsPlausibleExpFromGraphQuestion = () => {
+    let x;
+    let nodeF;
+    const rand = random([random([0, 1]), random([2, 3, 4, 5, 6])]);
+    switch (rand) {
+        case 0:
+            {
+                nodeF = exp("x");
+                x = randint(-5, 10);
+            }
+            break;
+        case 1:
+            {
+                //1: ax^2 + b  //plausible (convex, y==y', y' > 0)
+                //a!=0, y=y' => ax^2+b=2ax <=> x=1+-sqrt(a(a-b))/a
+                const a = randint(10, 50);
+                const b = randint(-10, a);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xPlus = 1 + Math.sqrt(a * (a - b)) / a;
+                x = xPlus;
+            }
+            break;
+        case 2:
+            {
+                //2: ax^2 + b  //impossible (convex, y!=y', y' > 0)
+                const a = randint(10, 50);
+                const b = randint(-10, a);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xPlus = 1 + Math.sqrt(a * (a - b)) / a;
+                const offset = 30;
+                x = xPlus + offset;
+            }
+            break;
+        case 3:
+            {
+                //3: ax^2 + b  //impossible (convex, y==y', y' < 0)
+                const a = randint(10, 50);
+                const b = randint(-300, -100);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xMinus = 1 - Math.sqrt(a * (a - b)) / a;
+                x = xMinus;
+            }
+            break;
+        case 4:
+            {
+                //4: ax^2 + b  //impossible (concave, y==y', y' > 0)
+                const a = -randint(10, 50);
+                const b = randint(10, -a);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xMinus = 1 + Math.sqrt(a * (a - b)) / a;
+                x = xMinus;
+            }
+            break;
+        case 5:
+            {
+                //5: ax^2 + b  //impossible (concave, y!=y', y' > 0)
+                const a = -randint(10, 50);
+                const b = randint(10, -a);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xMinus = 1 + Math.sqrt(a * (a - b)) / a;
+                const offset = -30;
+                x = xMinus + offset;
+            }
+            break;
+        case 6:
+            {
+                //6: ax^2 + b  //impossible (concave, y==y', y' < 0)
+                const a = -randint(10, 50);
+                const b = randint(10, -a);
+                nodeF = add(multiply(a, power("x", 2)), b);
+                const xPlus = 1 - Math.sqrt(a * (a - b)) / a;
+                x = xPlus;
+            }
+            break;
+        default:
+            throw new Error("Unsupported rand: " + rand);
+    }
+    const s = nodeF.derivative().evaluate({ x: x });
+    const nodeT = (() => {
+        const x0 = x;
+        const y0 = nodeF.evaluate({ x: x0 });
+        let outNode;
+        try {
+            //parfois le simplify pète (too many iterations)
+            outNode = add(multiply(s, substract("x", x0)), y0).simplify({
+                towardsDistribute: true,
+            });
+        }
+        catch (_) {
+            outNode = add(multiply(s, substract("x", x0)), y0);
+        }
+        return outNode;
+    })();
+    function findX(xMin, xMax, funcCheck, counter, maxCounter) {
+        if (counter < maxCounter) {
+            const x = (xMin + xMax) / 2.0;
+            const chk = funcCheck(x);
+            if (chk === 0) {
+                return x;
+            }
+            else {
+                if (chk === 1) {
+                    //too much
+                    return findX(xMin, x, funcCheck, counter + 1, maxCounter);
+                }
+                else {
+                    //not enough
+                    return findX(x, xMax, funcCheck, counter + 1, maxCounter);
+                }
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    function getPrettyCoordsFrameAroundX(nodeF, x) {
+        const x0 = x;
+        const y0 = nodeF.evaluate({ x: x0 });
+        function funcCheck(isRightSide) {
+            return (x) => {
+                const yF = nodeF.evaluate({ x });
+                const yT = nodeT.evaluate({ x });
+                const deltaMin = 0.1;
+                const deltaMax = 0.2;
+                const delta = Math.abs((yF - yT) / (y0 - yT));
+                const factorSide = isRightSide ? 1 : -1;
+                if (deltaMin < delta && delta < deltaMax) {
+                    return 0;
+                }
+                else {
+                    if (deltaMax < delta) {
+                        return factorSide;
+                    }
+                    else {
+                        return -factorSide;
+                    }
+                }
+            };
+        }
+        const xGuessMinus = x0 - 20;
+        const xGuessPlus = x0 + 20;
+        const xMin = findX(xGuessMinus, x0, funcCheck(false), 0, 100);
+        const xMax = findX(x0, xGuessPlus, funcCheck(true), 0, 100);
+        const [yMin, yMax] = [xMin, xMax]
+            .map((x) => nodeF.evaluate({ x }))
+            .toSorted((v1, v2) => v1 - v2);
+        return [xMin, xMax, yMin, yMax];
+    }
+    const coordsFrame = getPrettyCoordsFrameAroundX(nodeF, x);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsT: nodeT.toIdentifiers(),
+        x: x,
+        s,
+        coordsFrame,
+        rand,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const isPlausibleExpFromGraph = {
+    id: "isPlausibleExpFromGraph",
+    label: "Reconnaître une courbe vraisemblable de fonction exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsPlausibleExpFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/devForm/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAqKF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

package/lib/exercises/math/functions/trinoms/devForm/coefficientsIdentification.js

@@ -3,13 +3,39 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
 import { TrinomNode } from "../../../../../tree/nodes/polynomials/trinomNode.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { NodeConstructor, reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
 import { isFractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { square } from "../../../../../tree/nodes/operators/powerNode.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+const getHint = () => {
+    return `Une fonction polynôme du second degré a pour forme développée : 
+  
+$$
+f(x) = ax^2 +bx + c
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIdentifiers, bIdentifiers, cIdentifiers, isAsking } = identifiers;
+    const a = reifyAlgebraic(aIdentifiers);
+    const b = reifyAlgebraic(bIdentifiers);
+    const c = reifyAlgebraic(cIdentifiers);
+    const monom1 = multiply(a, "x^2");
+    const monom2 = multiply(b, "x");
+    return `On a : 
+  
+$$
+f(x) = ${add(monom1, add(monom2, c)).toTex({
+        forceTimesSign: true,
+        forceNoSimplification: true,
+    })} 
+$$
+
+Le coefficient $${isAsking}$ de $f$ est donc $${getAnswer(identifiers)}$.`;
+};
 const getPropositions = (n, { answer, aIdentifiers, bIdentifiers, cIdentifiers, isAsking }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -112,8 +138,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -129,4 +155,5 @@ export const coefficientsIdentification = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/equation/deltaTrinom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deltaTrinom.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/deltaTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0DF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"deltaTrinom.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/equation/deltaTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAc7C,CAAC"}

package/lib/exercises/math/functions/trinoms/equation/deltaTrinom.js

@@ -2,10 +2,14 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exer
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const trinom = new Trinom(identifiers.a, identifiers.b, identifiers.c);
-    return `Soit $f$ la fonction polynôme du second degré définie par 
+    return `Soit $f$ la fonction polynôme du second degré définie par :
   
 $$
 f(x) = ${trinom.toTree().toTex()}
@@ -13,6 +17,33 @@ $$
 
 Calculer le discriminant $\\Delta$ de $f$.`;
 };
+const getHint = () => {
+    return `Si $f$ est une fonction polynôme du second degré définie par :
+  
+$$
+f(x) = ax^2 + bx + c
+$$
+
+alors son discriminant $\\Delta$ vaut : 
+
+$$
+\\Delta = b^2 - 4ac
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const deltaNode = substract(square(b), multiply(4, multiply(a, c)));
+    return `La fonction $f$ est une fonction polynôme du second degré avec $a = ${a}$, $b = ${b}$ et $c = ${c}$. 
+  
+Le discriminant $\\Delta$ vaut donc : 
+
+${alignTex([
+        ["\\Delta", "=", "b^2 -4ac"],
+        ["", "=", deltaNode.toTex()],
+        ["", "=", deltaNode.simplify({ forbidAdditions: true }).toTex()],
+        ["", "=", deltaNode.simplify().toTex()],
+    ])}`;
+};
 const getAnswer = (identifiers) => {
     const trinom = new Trinom(identifiers.a, identifiers.b, identifiers.c);
     const answer = trinom.getDelta() + "";
@@ -25,6 +56,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -62,4 +95,5 @@ export const deltaTrinom = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/parabole/paraboleExpressionReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paraboleExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/paraboleExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CAIpB,CAAC;AAgTF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"paraboleExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/parabole/paraboleExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CAIpB,CAAC;AAgTF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}

package/lib/exercises/math/functions/trinoms/parabole/paraboleExpressionReading.js

@@ -274,7 +274,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const paraboleExpressionReading = {
     id: "paraboleExpressionReading",
     connector: "\\iff",
-    label: "Associer une expression algébrique à une parabole",
+    label: "Associer une expression algébrique à une parabole en lisant les racines",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getParaboleExpressionReadingQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/functions/trinoms/summitAndCanonical/alphaBetaInCanonicalForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alphaBetaInCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/alphaBetaInCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+EF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"alphaBetaInCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/alphaBetaInCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAqGF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/alphaBetaInCanonicalForm.js

@@ -6,10 +6,29 @@ import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.j
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
 import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getHint = () => {
+    return `La forme canonique d'une fonction polynôme du second degré est : 
+  
+$$
+f(x) = a(x-\\alpha)^2 + \\beta
+$$
+
+où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, alpha, beta } = identifiers;
+    return `La forme canonique d'une fonction polynôme du second degré est : 
+  
+$$
+f(x) = a(x-\\alpha)^2 + \\beta
+$$
+
+Ici, on a donc $a = ${a}$, $\\alpha = ${alpha}$ et $\\beta = ${beta}$.`;
+};
 const getInstruction = (identifiers) => {
     const { param, a, alpha, beta } = identifiers;
     const trinom = TrinomConstructor.fromAlphaBeta({ a, alpha, beta });
-    return `Soit $f$ la fonction définie par 
+    return `Soit $f$ la fonction polynôme du second degré  définie par sa forme canonique : 
   
 $$
 f(x) = ${trinom.getCanonicalForm().toTex()}
@@ -32,6 +51,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         startStatement: getStartStatement(identifiers),
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +98,5 @@ export const alphaBetaInCanonicalForm = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/summitAndCanonical/extremumFromCanonicalForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extremumFromCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/extremumFromCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"extremumFromCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/extremumFromCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiGF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/extremumFromCanonicalForm.js

@@ -4,6 +4,32 @@ import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trino
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { PointNode } from "../../../../../tree/nodes/geometry/pointNode.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getHint = () => {
+    return `La forme canonique d'une fonction polynôme du second degré est : 
+  
+$$
+f(x) = a(x-\\alpha)^2 + \\beta
+$$
+
+où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const alpha = trinom.getAlphaNode();
+    const beta = trinom.getBetaNode();
+    return `La forme canonique d'une fonction polynôme du second degré est : 
+  
+$$
+f(x) = a(x-\\alpha)^2 + \\beta
+$$
+
+où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée.
+
+Ici, on a donc $a = ${a}$, $\\alpha = ${alpha.toTex()}$ et $\\beta = ${beta.toTex()}$.
+
+Les coordonnées du sommet de la parabole représentant $f$ sont donc $(${alpha.toTex()};${beta.toTex()})$.`;
+};
 const getInstruction = (identifiers) => {
     const trinom = new Trinom(identifiers.a, identifiers.b, identifiers.c);
     return `Soit $f$ la fonction définie par 
@@ -26,6 +52,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["S", "semicolon"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -67,4 +95,5 @@ export const extremumFromCanonicalForm = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/variations/exp/index.d.ts

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

package/lib/exercises/math/functions/variations/exp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/variations/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/functions/variations/exp/index.js

@@ -0,0 +1,2 @@
+export * from "./varOfAEXPlusB.js";
+export * from "./varOfAEXPlusBOverCEXPlusD.js";

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.d.ts

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

package/lib/exercises/math/functions/variations/exp/varOfAEXPlusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varOfAEXPlusB.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/variations/exp/varOfAEXPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAwFF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}