math-exercises 3.0.15 → 3.0.17

package/lib/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.d.ts

@@ -1,6 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     a: number;
+    c: number;
     coin: number;
     racine1: number;
     racine2: number;

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

@@ -1 +1 @@
-{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsIF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}

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

@@ -13,21 +13,21 @@ import { unionIntervalParser } from "../../../../tree/parsers/unionIntervalParse
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getThirdDegreeFunctionVariation = () => {
-    const a = randint(-3, 4, [0]);
-    const c = randint(-2, 3);
-    const racine1 = randint(-5, 4);
-    const racine2 = randint(racine1 + 1, 6);
-    const coefs = [
-        c,
-        a * racine1 * racine2,
-        (-a * (racine1 + racine2)) / 2,
-        a / 3,
-    ];
-    const polynome = new Polynomial(coefs);
-    const coin = coinFlip() ? -1 : 1;
-    const instruction = `Soit $f$ la fonction représentée ci-dessous. Sur quel intervalle la dérivée de $f$ est-elle ` +
-        (coin < 0 ? "négative ?" : "positive ?");
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.c !== undefined)
+        return oldIds;
+    return {
+        ...oldIds,
+        c: randint(-2, 3),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
+    return (`Soit $f$ la fonction représentée ci-dessous. Sur quel intervalle la dérivée de $f$ est-elle ` +
+        (coin < 0 ? "négative ?" : "positive ?"));
+};
+const getAnswer = (identifiers) => {
+    const { a, coin, racine1, racine2 } = identifiers;
     const racine1Tree = new NumberNode(racine1);
     const racine2Tree = new NumberNode(racine2);
     const answer = coin * a < 0
@@ -36,12 +36,23 @@ const getThirdDegreeFunctionVariation = () => {
             new IntervalNode(MinusInfinityNode, racine1Tree, ClosureType.OF),
             new IntervalNode(racine2Tree, PlusInfinityNode, ClosureType.FO),
         ]).toTex();
-    const commands = [
-        `f(x) = ${polynome.toString()}`,
-        `SetColor(f, "${randomColor()}")`,
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, coin, racine1, racine2, c } = identifiers;
+    const coefs = [
+        c,
+        a * racine1 * racine2,
+        (-a * (racine1 + racine2)) / 2,
+        a / 3,
     ];
+    const polynome = new Polynomial(coefs);
     const y1 = polynome.calculate(racine1);
     const y2 = polynome.calculate(racine2);
+    const commands = [
+        `f(x) = ${polynome.toMathString()}`,
+        `SetColor(f, "${randomColor()}")`,
+    ];
     const yMax = Math.max(y1, y2);
     const yMin = Math.min(y1, y2);
     const xMax = Math.max(racine1, racine2);
@@ -51,16 +62,25 @@ const getThirdDegreeFunctionVariation = () => {
         lockedAxesRatio: false,
         gridDistance: false,
     });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getThirdDegreeFunctionVariation = () => {
+    const a = randint(-3, 4, [0]);
+    const c = randint(-2, 3);
+    const racine1 = randint(-5, 4);
+    const racine2 = randint(racine1 + 1, 6);
+    const coin = coinFlip() ? -1 : 1;
+    const identifiers = { racine1, racine2, coin, a, c };
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "S",
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["lbracket", "rbracket", "semicolon", "infty", "cup"],
         answerFormat: "tex",
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
-        }),
-        identifiers: { racine1, racine2, coin, a },
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
     };
     return question;
 };
@@ -108,4 +128,8 @@ export const thirdDegreeFunctionVariation = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     A: number[];
     B: number[];
+    coeffs: number[];
 };
 export declare const derivativeNumberReading: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeNumberReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeNumberReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA2FF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"derivativeNumberReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeNumberReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}

package/lib/exercises/math/derivation/tangent/derivativeNumberReading.js

@@ -8,11 +8,53 @@ import { Polynomial } from "../../../../math/polynomials/polynomial.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getDerivativeNumberReading = () => {
-    let xA, yA, xB, yB;
-    [xA, yA] = [1, 2].map((el) => randint(-5, 6));
-    xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
-    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds?.coeffs?.length)
+        return oldIds;
+    const { A, B } = oldIds;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteValue = pente.value;
+    const [a, b] = [
+        (3 * randint(-100, 100, [0])) / 100,
+        (2 * randint(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    return {
+        A,
+        B,
+        coeffs: [d, c, b / 2, a / 3],
+    };
+};
+const getInstruction = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    return `Ci-dessous sont tracées la courbe $\\mathcal C_f$ de la fonction $f$ et la tangente à cette courbe au point d'abscisse $${xA}$.$\\\\$ Déterminer $f'(${xA})$.`;
+};
+const getAnswer = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteTree = pente.toTree();
+    const answer = penteTree.toTex();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
     const pente = new Rational(yB - yA, xB - xA).simplify();
     const origin = pente
         .opposite()
@@ -22,18 +64,9 @@ const getDerivativeNumberReading = () => {
     const originTree = origin.toTree();
     const penteString = penteTree.toMathString();
     const originString = originTree.toMathString();
-    const penteValue = pente.value;
-    const originValue = origin.value;
-    const [a, b] = [
-        (3 * randint(-100, 100, [0])) / 100,
-        (2 * randint(-4, 5)) / 100,
-    ];
-    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
-    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
-    const polynome = new Polynomial([d, c, b / 2, a / 3]);
-    const instruction = `Ci-dessous sont tracées la courbe $\\mathcal C_f$ de la fonction $f$ et la tangente à cette courbe au point d'abscisse $${xA}$.$\\\\$ Déterminer $f'(${xA})$.`;
+    const polynome = new Polynomial(identifiers.coeffs);
     const commands = [
-        `f(x) = ${polynome.toString()}`,
+        `f(x) = ${polynome.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
         `SetCaption(f, "$\\mathcal C_f$")`,
         `ShowLabel(f, true)`,
@@ -50,17 +83,36 @@ const getDerivativeNumberReading = () => {
     const ggb = new GeogebraConstructor({
         commands,
     });
-    const answer = penteTree.toTex();
+    return ggb.getOptions({
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+    });
+};
+const getDerivativeNumberReading = () => {
+    let xA, yA, xB, yB;
+    [xA, yA] = [1, 2].map((el) => randint(-5, 6));
+    xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteValue = pente.value;
+    const [a, b] = [
+        (3 * randint(-100, 100, [0])) / 100,
+        (2 * randint(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    const identifiers = {
+        A: [xA, yA],
+        B: [xB, yB],
+        coeffs: [d, c, b / 2, a / 3],
+    };
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "a",
-        answer,
-        ggbOptions: ggb.getOptions({
-            coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
-        }),
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         keys: [],
-        identifiers: { A: [xA, yA], B: [xB, yB] },
+        identifiers,
     };
     return question;
 };
@@ -96,4 +148,8 @@ export const derivativeNumberReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    rebuildIdentifiers,
 };

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqDF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}

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

@@ -4,25 +4,39 @@ import { randomColor } from "../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-const getRootsReadingQuestion = () => {
-    const trinom = TrinomConstructor.randomNiceRoots(randint(1, 3));
+const getInstruction = (identifiers) => {
+    return `Déterminer graphiquement le ou les racine(s) du polynôme du second degré représenté ci-dessous : `;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const roots = trinom.getRoots();
+    const answer = roots.length === 1 ? roots[0].toString() : roots.join("\\text{ et }");
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const commands = [
-        `f(x) = ${trinom.toString()}`,
+        `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${randomColor()}")`,
     ];
     const ggb = new GeogebraConstructor({
         commands,
         lockedAxesRatio: false,
     });
-    const answer = roots.length === 1 ? roots[0].toString() : roots.join("\\text{ et }");
+    return ggb.getOptions({ coords: trinom.getCoords() });
+};
+const getRootsReadingQuestion = () => {
+    const trinom = TrinomConstructor.randomNiceRoots(randint(1, 3));
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
-        answer,
-        instruction: `Déterminer graphiquement le ou les racine(s) du polynôme du second degré représenté ci-dessous : `,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["et", "aucun"],
         answerFormat: "tex",
-        ggbOptions: ggb.getOptions({ coords: trinom.getCoords() }),
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
     };
     return question;
 };
@@ -60,4 +74,7 @@ export const rootsReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"summitReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuDF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}
+{"version":3,"file":"summitReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/summitReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAgB/C,CAAC"}

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

@@ -5,26 +5,40 @@ import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor
 import { Point } from "../../../../../math/geometry/point.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-const getSummitReadingQuestion = () => {
-    const trinom = TrinomConstructor.randomCanonical();
+const getInstruction = (identifiers) => {
+    return `Déterminer les coordonnées du sommet de la parabole représentée ci-dessous :`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const answer = trinom.getSommet().toCoords();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
     const commands = [
-        `f(x) = ${trinom.toString()}`,
+        `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${randomColor()}")`,
     ];
     const ggb = new GeogebraConstructor({
         commands,
         isGridSimple: true,
     });
-    const answer = trinom.getSommet().toCoords();
+    return ggb.getOptions({
+        coords: trinom.getCoords(),
+    });
+};
+const getSummitReadingQuestion = () => {
+    const trinom = TrinomConstructor.randomCanonical();
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
-        answer,
-        instruction: `Déterminer les coordonnées du sommet de la parabole représentée ci-dessous :`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["leftParenthesis", "semicolon", "rightParenthesis"],
-        ggbOptions: ggb.getOptions({
-            coords: trinom.getCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        identifiers,
     };
     return question;
 };
@@ -56,4 +70,7 @@ export const summitReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA8JF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA+KF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.js

@@ -32,35 +32,41 @@ function generateEvenInflexionPoint() {
     } while (inflexionPointX % 10 !== 0);
     return inflexionPointX;
 }
-const getConvexityQuadrinomialsGeoQuestion = () => {
-    const inflexionPointX = generateEvenInflexionPoint() * 0.1;
-    const quadrinomial = generatePolynomialWithIntegerInflexionPoint(3, inflexionPointX);
-    const quadcoeffs = quadrinomial.coefficients;
-    const trinomial = quadrinomial.derivate();
-    const criticalPoints = trinomial.getRoots();
-    const yValues = criticalPoints.map((x) => quadrinomial.calculate(x));
-    const xMin = Math.min(...criticalPoints) - 5;
-    const xMax = Math.max(...criticalPoints) + 5;
-    const yMin = Math.min(...yValues, 0) - 5;
-    const yMax = Math.max(...yValues, 0) + 5;
-    const askConvex = coinFlip();
+const getInstruction = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
+    const questionType = askConvex ? "convexe" : "concave";
+    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
     let interval;
     if (askConvex) {
         interval =
             quadcoeffs[3] > 0
-                ? new IntervalNode(inflexionPointX.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
-                : new IntervalNode(MinusInfinityNode, inflexionPointX.toTree(), ClosureType.OO).toTex();
+                ? new IntervalNode(inflexionPoint.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint.toTree(), ClosureType.OO).toTex();
     }
     else {
         interval =
             quadcoeffs[3] <= 0
-                ? new IntervalNode(inflexionPointX.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
-                : new IntervalNode(MinusInfinityNode, inflexionPointX.toTree(), ClosureType.OO).toTex();
+                ? new IntervalNode(inflexionPoint.toTree(), PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint.toTree(), ClosureType.OO).toTex();
     }
-    const questionType = askConvex ? "convexe" : "concave";
-    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
+    return interval;
+};
+const getGGBOptions = (identifiers) => {
+    const { askConvex, inflexionPoint, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const trinomial = quadrinomial.derivate();
+    const criticalPoints = trinomial.getRoots();
+    const yValues = criticalPoints.map((x) => quadrinomial.calculate(x));
+    const xMin = Math.min(...criticalPoints) - 5;
+    const xMax = Math.max(...criticalPoints) + 5;
+    const yMin = Math.min(...yValues, 0) - 5;
+    const yMax = Math.max(...yValues, 0) + 5;
     const commands = [
-        `f(x) = ${quadrinomial.toString()}`,
+        `f(x) = ${quadrinomial.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
         `SetCaption(f, "$\\mathcal C_f$")`,
         `ShowLabel(f, true)`,
@@ -69,15 +75,27 @@ const getConvexityQuadrinomialsGeoQuestion = () => {
         commands,
         lockedAxesRatio: false,
     });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const getConvexityQuadrinomialsGeoQuestion = () => {
+    const inflexionPointX = generateEvenInflexionPoint() * 0.1;
+    const quadrinomial = generatePolynomialWithIntegerInflexionPoint(3, inflexionPointX);
+    const quadcoeffs = quadrinomial.coefficients;
+    const askConvex = coinFlip();
+    const identifiers = {
+        askConvex,
+        quadcoeffs,
+        inflexionPoint: inflexionPointX,
+    };
     const question = {
-        answer: interval,
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: [xMin, xMax, yMin, yMax],
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
         answerFormat: "tex",
-        identifiers: { askConvex, quadcoeffs, inflexionPoint: inflexionPointX },
+        identifiers,
     };
     return question;
 };
@@ -118,4 +136,7 @@ export const convexityQuadrinomialsGeo = {
     isAnswerValid,
     subject: "Mathématiques",
     hasGeogebra: true,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/exercises/math/geometry/convexity/convexityTrinomialsGeo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convexityTrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityTrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAkDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"convexityTrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityTrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/geometry/convexity/convexityTrinomialsGeo.js

@@ -2,13 +2,20 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { blueMain } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { Trinom, TrinomConstructor } from "../../../../math/polynomials/trinom.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getConvexityTrinomialsGeoQuestion = () => {
-    const trinom = TrinomConstructor.random();
-    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur $\\mathbb{R}$, la fonction $f$ est :`;
+const getInstruction = (identifiers) => {
+    return `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur $\\mathbb{R}$, la fonction $f$ est :`;
+};
+const getAnswer = (identifiers) => {
+    const trinom = new Trinom(identifiers.trinom[0], identifiers.trinom[1], identifiers.trinom[2]);
+    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return isConvex;
+};
+const getGGBOptions = (identifiers) => {
+    const trinom = new Trinom(identifiers.trinom[0], identifiers.trinom[1], identifiers.trinom[2]);
     const commands = [
-        `f(x) = ${trinom.toString()}`,
+        `f(x) = ${trinom.toMathString()}`,
         `SetColor(f, "${blueMain}")`,
         `SetCaption(f, "$\\mathcal C_f$")`,
         `ShowLabel(f, true)`,
@@ -17,16 +24,20 @@ const getConvexityTrinomialsGeoQuestion = () => {
         commands,
         lockedAxesRatio: false,
     });
-    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return ggb.getOptions({
+        coords: trinom.getCoords(),
+    });
+};
+const getConvexityTrinomialsGeoQuestion = () => {
+    const trinom = TrinomConstructor.random();
+    const identifiers = { trinom: [trinom.a, trinom.b, trinom.c] };
     const question = {
-        answer: isConvex,
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: trinom.getCoords(),
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: { trinom: [trinom.a, trinom.b, trinom.c] },
+        identifiers,
     };
     return question;
 };
@@ -57,4 +68,7 @@ export const convexityTrinomialsGeo = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
 };

package/lib/index.d.ts

@@ -539,6 +539,7 @@ declare const mathExercises: (Exercise<{
     coefficients: number[];
 }, {}> | Exercise<{
     a: number;
+    c: number;
     coin: number;
     racine1: number;
     racine2: number;
@@ -592,6 +593,7 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    coeffs: number[];
 }, {}> | Exercise<{
     xA: number;
     yA: number;
@@ -1886,6 +1888,7 @@ declare const pcExercises: (Exercise<{
 }, {}> | Exercise<{
     A: number[];
     B: number[];
+    coeffs: number[];
 }, {}> | Exercise<{
     a: number;
 }, {}> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/polynomials/polynomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAa1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAkCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IA0Bf,YAAY,IAAI,MAAM;CAGvB"}
+{"version":3,"file":"polynomial.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/polynomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAcpE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAa5D,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IActD;;;;;;OAMG;IACH,MAAM,CAAC,gBAAgB,CACrB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAoBxB,MAAM,CAAC,4BAA4B,CACjC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAY;IAqBxB,MAAM,CAAC,UAAU,CACf,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,UAAU,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,GAAE,MAAY;CAmCzB;AAED,qBAAa,UAAU;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;;;OAIG;gBACS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,GAAE,MAAY;IAa1D,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAM9B,QAAQ,IAAI,MAAM,EAAE;IAmCpB,GAAG,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,UAAU;IAyBvC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU;IAQ7B,QAAQ,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU;IAuBnC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU;IAqBnC,QAAQ,IAAI,UAAU;IAOtB,QAAQ,IAAI,UAAU;IAWtB,cAAc,IAAI,UAAU;IAiB5B,eAAe,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BlC,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAO5B,QAAQ,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM;IAiB7C,YAAY,CAAC,EAAE,EAAE,UAAU,GAAG,UAAU;IAiBxC,MAAM,CAAC,IAAI,CAAC,EAAE,WAAW;IAuCzB,KAAK,IAAI,MAAM;IA0Bf,YAAY,IAAI,MAAM;CAGvB"}

package/lib/math/polynomials/trinom.js

@@ -249,7 +249,7 @@ export class Trinom extends Polynomial {
         return `${aString}${bString}${cString}`;
     }
     toGGBCommands({ name, color, label } = { name: "f", color: blueMain, label: "" }) {
-        const cmds = [`${name} = ${this.toString()}`];
+        const cmds = [`${name} = ${this.toMathString()}`];
         if (color) {
             cmds.push(`SetColor(${name}, "${color}")`);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.15",
+  "version": "3.0.17",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [