math-exercises 3.0.163 → 3.0.165

package/lib/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.js

@@ -0,0 +1,252 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.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 { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }, opts) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, getAnswer(generateIdentifiers(), opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers, options) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    const facto = multiply(a, partialTrinom).simplify({ forbidFactorize: true });
+    if (options?.expectedForm === "Forme développée")
+        return facto.simplify({ towardsDistribute: true, forbidFactorize: true });
+    return facto;
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    return `Soit $f$ une fonction polynôme du second degré, dont la parabole passe par le point $${point.toTexWithCoords()}$, et qui a ${roots.length === 1
+        ? `pour seule racine : $${roots[0].toTex()}$`
+        : `deux racines : $${roots[0].toTex()}$ et $${roots[1].toTex()}$`}
+  
+Déterminer la forme ${opts?.expectedForm === "Forme développée" ? "développée" : "factorisée"} de $f(x)$.
+`;
+};
+const getHint = () => {
+    return `Si $f$ est une fonction polynôme du second degré ayant deux racines $x_1$ et $x_2$, alors sa forme factorisée est : 
+  
+$$
+f(x) = a(x-x_1)(x-x_2)
+$$
+
+Si elle n'admet qu'une racine $x_0$, alors sa forme factorisée est :
+
+$$
+f(x) = a(x-x_0)^2 
+$$
+
+Sers-toi ensuite du fait que $A$ appartient à la courbe de $f$ pour déterminer $a$.
+`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    if (roots.length === 1) {
+        return `Puisque $f$ a une seule racine $${roots[0].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", square(substract("x", roots[0]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", square(substract(point.x, roots[0]))).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+            ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+                ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom.simplify({
+                        towardsDistribute: true,
+                        forbidFactorize: true,
+                    })).toTex(),
+                ],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom)
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+`
+            : ""}
+`;
+    }
+    return `Puisque $f$ a deux racines $${roots[0].toTex()}$ et $${roots[1].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", multiply(substract(point.x, roots[0]).simplify(), substract(point.x, roots[1]).simplify())).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+        ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+            ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom.simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })).toTex(),
+            ],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`
+        : ""}`;
+};
+const getKeys = () => {
+    return ["xsquare", "x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const generateIdentifiers = (_options) => {
+    const uniqueRoot = coinFlip();
+    const roots = uniqueRoot
+        ? [randint(-9, 10, [0])]
+        : randTupleInt(2, {
+            from: -9,
+            to: 10,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+    const a = randint(-9, 10, [0]);
+    const pointX = randint(-9, 10, roots);
+    const pointY = multiply(a, uniqueRoot
+        ? square(substract(pointX, roots[0]))
+        : multiply(substract(pointX, roots[0]), substract(pointX, roots[1]))).simplify();
+    const point = new Point("A", pointX, pointY);
+    return {
+        pointIds: point.toIdentifiers(),
+        rootsIds: roots.map((r) => r.toTree().toIdentifiers()),
+    };
+};
+const getTrinomAlgebraicFormFromRootsAndPointQuestion = (opts) => {
+    return getQuestionFromIdentifiers(generateIdentifiers(opts), opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme factorisée"],
+        defaultValue: "Forme factorisée",
+    },
+];
+export const trinomAlgebraicFormFromRootsAndPoint = {
+    id: "trinomAlgebraicFormFromRootsAndPoint",
+    connector: "=",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant ses racines et un point de la parabole",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomAlgebraicFormFromRootsAndPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/functions/trinoms/sign/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./trinomSignFromRoots.js";
 export * from "./trinomSignFromFacto.js";
+export * from "./trinomSignTableFromAlgebraicForm.js";
+export * from "./parabolaSignTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/trinoms/sign/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uCAAuC,CAAC;AACtD,cAAc,wBAAwB,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/index.js

@@ -1,2 +1,4 @@
 export * from "./trinomSignFromRoots.js";
 export * from "./trinomSignFromFacto.js";
+export * from "./trinomSignTableFromAlgebraicForm.js";
+export * from "./parabolaSignTable.js";

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.d.ts

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

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parabolaSignTable.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/parabolaSignTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/parabolaSignTable.js

@@ -0,0 +1,123 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = () => {
+    return `Ci-dessous est tracée la parabole qui représente graphiquement une fonction polynôme du second degré $f$ définie sur $\\mathbb{R}$.
+  
+Dresser le tableau de signes de $f$.`;
+};
+const getHint = () => {
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+  
+Repère ensuite les points de la courbe à l'intersection de l'axe des abscisses. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, le signe de $f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const sign = a > 0 ? "positive" : "négative";
+    const oppSign = a > 0 ? "négative" : "positive";
+    return `On lit graphiquement que les racines de $f$ sont $${roots[0].toTex()}$ et $${roots[1].toTex()}$.
+
+Entre ces racines, c'est à dire sur l'intervalle $\\left[${roots[0].toTex()};${roots[1].toTex()}\\right]$, $f(x)$ est ${oppSign}.
+
+Pour les valeurs de l'intervalle $\\left]-\\infty;${roots[0].toTex()}\\right]$ et de l'intervalle $\\left[${roots[1].toTex()};+\\infty \\right[$, $f(x)$ est ${sign}.
+  `;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRoots();
+    const beta = trinom.getBeta();
+    const ggb = new GeogebraConstructor({
+        commands: [`f(x) = ${a}*x^2 + ${b}*x + ${c}`],
+        lockedAxesRatio: false,
+        gridDistance: false,
+        xAxis: {
+            steps: 1,
+        },
+    });
+    const xMin = roots[0] - 2;
+    const xMax = roots[1] + 2;
+    const yMin = a > 0 ? beta : -5;
+    const yMax = a < 0 ? beta : 5;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const getAnswerTable = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const opp = a > 0 ? "-" : "+";
+    const sign = a > 0 ? "+" : "-";
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            roots[0].toTex(),
+            "\\ ",
+            roots[1].toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        ["$f(x)$", "\\ ", sign, "0", opp, "0", sign, "\\ "],
+    ];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignTableFromGraphQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRoots(2);
+    const identifiers = {
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+export const parabolaSignTable = {
+    id: "parabolaSignTable",
+    label: "Dresser le tableau de signes d'une parabole représentée graphiquement",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignTableFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswerTable,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "signTable",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    form: "dev" | "cano" | "facto";
+};
+type Options = {
+    givenForm: string;
+};
+export declare const trinomSignTableFromAlgebraicForm: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trinomSignTableFromAlgebraicForm.d.ts.map

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trinomSignTableFromAlgebraicForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;CAChC,CAAC;AAwMF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAWF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBzE,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/trinomSignTableFromAlgebraicForm.js

@@ -0,0 +1,209 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const sign = a > 0 ? "+" : "-";
+    if (!roots.length) {
+        return [
+            ["$x$", "-\\infty", "\\ ", "+\\infty"],
+            ["$f(x)$", "\\ ", sign, "\\ "],
+        ];
+    }
+    if (roots.length === 1) {
+        const sign = a > 0 ? "+" : "-";
+        return [
+            ["$x$", "-\\infty", "\\ ", roots[0].toTex(), "\\ ", "+\\infty"],
+            ["$f(x)$", "\\ ", sign, "0", sign, "\\ "],
+        ];
+    }
+    const opp = a > 0 ? "-" : "+";
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            roots[0].toTex(),
+            "\\ ",
+            roots[1].toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        ["$f(x)$", "\\ ", sign, "0", opp, "0", sign, "\\ "],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, form } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const eq = form === "dev"
+        ? trinom.toTree()
+        : form === "cano"
+            ? trinom.getCanonicalForm()
+            : trinom.toFactorized();
+    return `Soit $f$ la fonction polynôme du second degré définie sur $\\mathbb{R}$ par : 
+
+$$
+f(x)=${eq.toTex()}
+$$
+
+Dresser le tableau de signes de $f$.
+`;
+};
+const getHint = () => {
+    return `Un trinôme est du signe de son coefficient $a$, sauf entre ses éventuelles racines. 
+  
+Il faut donc commencer par déterminer les solutions de l'équation $f(x) = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, form } = identifiers;
+    const aSign = a > 0 ? "positive" : "négative";
+    const aInvSign = a > 0 ? "négative" : "positive";
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    let rootsTex = ``;
+    if (form === "dev") {
+        const delta = trinom.getDeltaNode();
+        rootsTex = `On calcule le discriminant : 
+     
+$$
+\\Delta = b^2 - 4ac= ${delta.toTex()}
+$$
+
+Puisque $\\Delta>0$, $f$ possède deux racines : 
+
+$$
+x_1 = \\frac{-b-\\sqrt{\\Delta}}{2a} = ${frac(substract(opposite(b), sqrt(delta)), multiply(2, a))
+            .simplify()
+            .toTex()}
+$$
+
+$$
+x_2 = \\frac{-b+\\sqrt{\\Delta}}{2a} = ${frac(add(opposite(b), sqrt(delta)), multiply(2, a))
+            .simplify()
+            .toTex()}
+$$`;
+    }
+    else if (form === "cano") {
+        const alpha = trinom.getAlphaNode();
+        const beta = trinom.getBetaNode();
+        const cano = trinom.getCanonicalForm();
+        rootsTex = `On a : 
+
+$$
+${cano.toTex()}=0 \\iff ${square(substract("x", alpha).simplify()).toTex()} = ${frac(opposite(beta), a).simplify().toTex()} 
+$$
+
+Cela donne deux équations à résoudre : 
+
+$$
+${substract("x", alpha).simplify().toTex()} = ${sqrt(frac(opposite(beta), a).simplify()).toTex()}
+$$
+
+d'où $x = ${substract(sqrt(frac(opposite(beta), a)), alpha)
+            .simplify()
+            .toTex()}$, et :
+
+$$
+${substract("x", alpha).simplify().toTex()} = ${opposite(sqrt(frac(opposite(beta), a).simplify())).toTex()}
+$$
+
+d'où $x = ${substract(opposite(sqrt(frac(opposite(beta), a))), alpha)
+            .simplify()
+            .toTex()}$.
+
+`;
+    }
+    else {
+        rootsTex = `Puisque $f$ est donnée sous forme factorisée, on peut facilement déterminer ses racines : ce sont $${roots[0].toTex()}$ et $${roots[1].toTex()}$.`;
+    }
+    return `Un trinôme est du signe de son coefficient $a$, sauf entre ses éventuelles racines. Ici, $f$ est donc ${aSign} sauf entre ses racines (si elle en a) où elle est ${aInvSign}.
+  
+On commence donc par déterminer les racines de $f$. 
+  
+${rootsTex}
+
+On en conclut donc que $f$ est ${aSign} sur $\\left]-\\infty; ${roots[0].toTex()}\\right]$ et sur $\\left[${roots[1].toTex()}; +\\infty\\right[$, et ${aInvSign} sur $\\left[${roots[0].toTex()}; ${roots[1].toTex()}\\right]$.
+`;
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrinomSignTableFromAlgebraicFormQuestion = (opts) => {
+    const form = opts?.givenForm === "Forme canonique"
+        ? "cano"
+        : opts?.givenForm === "Forme factorisée"
+            ? "facto"
+            : "dev";
+    let trinom;
+    if (form === "cano") {
+        trinom = TrinomConstructor.randomNiceRootsAndSummit(2);
+    }
+    else {
+        trinom = TrinomConstructor.randomNiceRoots(2);
+    }
+    const identifiers = {
+        form,
+        a: trinom.a,
+        b: trinom.b,
+        c: trinom.c,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answerTable: getAnswerTable(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        answerFormat: "tex",
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+const options = [
+    {
+        id: "givenForm",
+        label: "Forme donnée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme factorisée", "Forme canonique"],
+        defaultValue: "Forme développée",
+    },
+];
+export const trinomSignTableFromAlgebraicForm = {
+    id: "trinomSignTableFromAlgebraicForm",
+    label: "Dresser le tableau de signes d'un trinôme donné sous forme algébrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomSignTableFromAlgebraicFormQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+    options,
+    isAnswerTableValid,
+    getKeys,
+};

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     summitIds: PointIdentifiers;
     pointIds: PointIdentifiers;
 };
-export declare const devFormFromSummitAndPoint: Exercise<Identifiers>;
+type Options = {
+    expectedForm: string;
+};
+export declare const devFormFromSummitAndPoint: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=devFormFromSummitAndPoint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyLF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}
+{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAaF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}