math-exercises 3.0.157 → 3.0.159

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

@@ -0,0 +1,366 @@
+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 = (identifiers) => {
+    const { s } = identifiers;
+    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).
+
+La pente de la tangente vaut environ $${round(s, 2).frenchify()}$.
+
+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
+$$
+
+`;
+};
+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$
+
+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$
+
+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 } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeT = NodeConstructor.fromIdentifiers(nodeIdsT);
+    const [xMin, xMax, yMin, yMax] = coordsFrame;
+    const commands = [
+        `Cf = ${nodeF.toMathString()}`,
+        `SetColor(Cf, "${red}")`,
+        `Ct = ${nodeT.toMathString()}`,
+        `SetColor(Ct, "${blueLight}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        xAxis: {
+            hidden: 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/exponential/expFactorization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expFactorization.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;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkKF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}
+{"version":3,"file":"expFactorization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/expFactorization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8KF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

package/lib/exercises/math/functions/exponential/expFactorization.js

@@ -10,16 +10,23 @@ import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
-const getPropositions = (n, { answer, ...identifiers }) => {
-    const propositions = [];
-    const { uA } = identifiers;
-    addValidProp(propositions, answer);
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstructionNode = (identifiers) => {
+    const { a, b, c, d, e, f, uA } = identifiers;
     const expNode = exp(multiply(uA, "x"));
-    propWhile(propositions, n, () => {
-        const affine = AffineConstructor.random();
-        tryToAddWrongProp(propositions, multiply(affine.toTree(), expNode).toTex());
-    });
-    return shuffleProps(propositions, n);
+    return add(multiply(a, multiply(add(multiply(b, "x"), c).simplify({
+        forbidFactorize: true,
+    }), expNode)), multiply(d, multiply(add(multiply(e, "x"), f).simplify({
+        forbidFactorize: true,
+    }), expNode)));
+};
+const getInstruction = (identifiers) => {
+    const node = getInstructionNode(identifiers);
+    return `Factoriser l'expression suivante :
+  
+$$
+${node.toTex()}
+$$`;
 };
 const getAnswerNode = (identifiers) => {
     const { a, b, c, d, e, f, uA } = identifiers;
@@ -41,40 +48,45 @@ const getAnswerNode = (identifiers) => {
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
-const getInstruction = (identifiers) => {
+const getHint = () => {
+    return `Y a-t-il un facteur commun entre les deux termes ?`;
+};
+const getCorrection = (identifiers) => {
     const { a, b, c, d, e, f, uA } = identifiers;
     const expNode = exp(multiply(uA, "x"));
-    const node = add(multiply(a, multiply(add(multiply(b, "x"), c).simplify({
+    const firstTerm = multiply(a, add(multiply(b, "x"), c)).simplify({
+        towardsDistribute: true,
         forbidFactorize: true,
-    }), expNode)), multiply(d, multiply(add(multiply(e, "x"), f).simplify({
+    });
+    const secondTerm = multiply(d, add(multiply(e, "x"), f)).simplify({
+        towardsDistribute: true,
         forbidFactorize: true,
-    }), expNode)));
-    return `Factoriser l'expression suivante :
+    });
+    return `On peut choisir $${expNode.toTex()}$ comme facteur commun.
+
+${alignTex([
+        ["", "", `${getInstructionNode(identifiers).toTex()}`],
+        [
+            "",
+            "=",
+            `${expNode.toTex()}((${firstTerm.toTex()}) + (${secondTerm.toTex()}))`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}`],
+    ])}
   
-$$
-${node.toTex()}
-$$`;
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { uA } = identifiers;
+    addValidProp(propositions, answer);
+    const expNode = exp(multiply(uA, "x"));
+    propWhile(propositions, n, () => {
+        const affine = AffineConstructor.random();
+        tryToAddWrongProp(propositions, multiply(affine.toTree(), expNode).toTex());
+    });
+    return shuffleProps(propositions, n);
 };
-// const getHint: GetHint<Identifiers> = () => {
-//   return `Pour factoriser une expression avec des exponentielles :
-//   1) Repérer le facteur exponentiel commun
-//   2) Mettre en facteur $e^{u(x)}$
-//   3) Factoriser l'expression entre parenthèses`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const operator = isAdd ? "+" : "-";
-//   const step1 = `(${a}x${b >= 0 ? "+" : ""}${b})e^{${u}} ${operator} (${c}x${
-//     d >= 0 ? "+" : ""
-//   }${d})e^{${u}}`;
-//   const step2 = `e^{${u}}((${a}x${b >= 0 ? "+" : ""}${b}) ${operator} (${c}x${
-//     d >= 0 ? "+" : ""
-//   }${d}))`;
-//   return `${alignTex([
-//     ["", step1],
-//     ["=", step2],
-//   ])}
-// On a mis en facteur $e^{${u}}$ qui est le terme exponentiel commun.`;
-// };
 const getKeys = () => {
     return ["epower", "x"];
 };
@@ -129,8 +141,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -146,9 +158,9 @@ export const expFactorization = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getAnswer,
-    // hasHintAndCorrection: true,
+    hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

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

@@ -1,4 +1,6 @@
 export * from "./expEquation.js";
 export * from "./expSimplifiying.js";
 export * from "./expFactorization.js";
+export * from "./algebraic/index.js";
+export * from "./definition/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC"}

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

@@ -1,3 +1,5 @@
 export * from "./expEquation.js";
 export * from "./expSimplifiying.js";
 export * from "./expFactorization.js";
+export * from "./algebraic/index.js";
+export * from "./definition/index.js";

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/equation/secondDegreeInequation.js

@@ -132,3 +132,6 @@ export const secondDegreeInequation = {
     pdfOptions: { shouldSpreadPropositions: true },
     getQuestionFromIdentifiers,
 };
+// export const reuseSecondDegreeInequation = {
+//   getAnswerNode,
+// };

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"}