math-exercises 3.0.8 → 3.0.10

package/lib/exercises/math/calculLitteral/equation/equationType2Exercise.js

@@ -132,7 +132,7 @@ const isAnswerValid = (ans, { a, b }) => {
 const options = [
     {
         id: "aNumberType",
-        label: "Autoriser des fractions pour $a$",
+        label: "Type du coefficient $a$",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         defaultValue: ["Entier"],

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.d.ts

@@ -5,9 +5,10 @@ type Identifiers = {
     /** new */
     functionType: string;
     x: number;
-    y: number;
-    wrongY: number;
+    y?: number;
+    wrongY?: number;
     otherPoints: number[][];
+    functionCommand?: string;
 };
 type Options = {
     curveTypes: string[];

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,cAAc;IAMd,UAAU;IAMV,UAAU;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;CACzB,CAAC;AAoOF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}
+{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,cAAc;IAMd,UAAU;IAMV,UAAU;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AA0SF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBhE,CAAC"}

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.js

@@ -13,8 +13,11 @@ import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const rebuildIdentifiers = (oldIds) => {
     if (oldIds.splinePoints?.length) {
         const x = oldIds.x;
@@ -49,22 +52,44 @@ const rebuildIdentifiers = (oldIds) => {
     else
         return oldIds;
 };
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, opts) => {
     const { x } = identifiers;
-    return `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?`;
+    let instruction = `Quelle est l'image de $${x}$ par la fonction $f$ représentée ci dessous ?
+  
+On écrira "aucun" si l'image n'existe pas.`;
+    //   if (opts?.curveTypes?.includes("Avec valeur interdite (pas d'image)")) {
+    //     instruction += `
+    // On écrira "aucun" si l'image n'existe pas.`;
+    //   }
+    return instruction;
 };
 const getAnswer = (identifiers) => {
     const { y } = identifiers;
+    if (y === undefined)
+        return "\\text{Aucun}";
     return y.frenchify();
 };
 const getGGBOptions = (identifiers) => {
-    const { functionType, otherPoints, wrongY, x, y } = identifiers;
-    const allPoints = [...otherPoints, [x, y], [wrongY, x]].sort((a, b) => a[0] - b[0]);
+    const { functionType, otherPoints, wrongY, x, y, functionCommand } = identifiers;
+    const allPoints = [...otherPoints];
+    if (y !== undefined)
+        allPoints.push([x, y]);
+    if (wrongY !== undefined)
+        allPoints.push([wrongY, x]);
+    allPoints.sort((a, b) => a[0] - b[0]);
     let commands = [];
     switch (functionType) {
+        case "Avec valeur interdite (pas d'image)":
+            commands = [
+                `f(x) = ${functionCommand}`,
+                `SetColor(f, "${randomColor()}")`,
+                `SetCaption(f, "$f$")`,
+                `ShowLabel(f, true)`,
+            ];
+            break;
         case "Droites":
             const line = new Line(new Point("A", allPoints[0][0], allPoints[0][1]), new Point("B", allPoints[1][0], allPoints[1][1]));
-            commands = line.toGGBCommands(false);
+            commands = line.toGGBCommands(false, { showLabel: true, label: "$f$" });
             break;
         case "Tracés":
             //! on devrait plutôt build a spline et renvoyer toGgbCommand
@@ -74,6 +99,8 @@ const getGGBOptions = (identifiers) => {
                     .join(",")})`,
                 "SetFixed(S, true)",
                 `SetColor(S, "${randomColor()}")`,
+                `SetCaption(S, "$f$")`,
+                `ShowLabel(S, true)`,
             ];
             break;
         case "Paraboles":
@@ -82,7 +109,10 @@ const getGGBOptions = (identifiers) => {
                 new Point("B", allPoints[1][0], allPoints[1][1]),
                 new Point("C", allPoints[2][0], allPoints[2][1]),
             ]);
-            commands = parabola.toGGBCommands(false);
+            commands = parabola.toGGBCommands(false, {
+                showLabel: true,
+                label: "$f$",
+            });
             break;
         case "Polynômes":
         default:
@@ -93,6 +123,8 @@ const getGGBOptions = (identifiers) => {
                     .join(",")})`,
                 "SetFixed(P, true)",
                 `SetColor(P, "${randomColor()}")`,
+                `SetCaption(P, "$f$")`,
+                `ShowLabel(P, true)`,
             ];
             break;
     }
@@ -104,10 +136,19 @@ const getGGBOptions = (identifiers) => {
         // commands: spline.getCommands()
         commands,
     });
-    const xMin = allPoints[0][0];
-    const xMax = allPoints[allPoints.length - 1][0];
-    const yMin = Math.min(...allPoints.map((p) => p[1])) - 1;
-    const yMax = Math.max(...allPoints.map((p) => p[1])) + 1;
+    let xMin, xMax, yMin, yMax;
+    if (functionType === "Avec valeur interdite (pas d'image)") {
+        xMin = x - 3;
+        xMax = x + 3;
+        yMin = -7;
+        yMax = 7;
+    }
+    else {
+        xMin = allPoints[0][0];
+        xMax = allPoints[allPoints.length - 1][0];
+        yMin = Math.min(...allPoints.map((p) => p[1])) - 1;
+        yMax = Math.max(...allPoints.map((p) => p[1])) + 1;
+    }
     return ggb.getOptions({
         coords: ggb.getAdaptedCoords({
             forceShowAxes: true,
@@ -122,12 +163,20 @@ const getStartStatement = (identifiers) => {
     const { x } = identifiers;
     return `f(${x})`;
 };
+const getKeys = (identifiers, options) => {
+    // if (options?.curveTypes?.includes("Avec valeur interdite (pas d'image)")) {
+    //   return ["aucun"];
+    // } else {
+    //   return [];
+    // }
+    return ["aucun"];
+};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers, opts),
         startStatement: getStartStatement(identifiers, opts),
         answer: getAnswer(identifiers, opts),
-        keys: [],
+        keys: getKeys(identifiers, opts),
         ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "tex",
         identifiers,
@@ -135,13 +184,24 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     return question;
 };
 const getImageFunctionGeogebra = (opts) => {
-    const x = randint(-8, 9);
-    const y = randint(-8, 9);
-    const wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    let x = randint(-8, 9);
+    let y = randint(-8, 9);
+    let wrongY = y + randint(-3, 4, [0, x - y, 10 - y, -10 - y]);
+    let functionCommand = undefined;
     const functionType = random(opts?.curveTypes ?? ["Tracés", "Polynômes", "Droites", "Paraboles"]);
     let otherPoints = [];
     switch (functionType) {
+        case "Avec valeur interdite (pas d'image)":
+            y = undefined;
+            const k = randint(2, 6);
+            functionCommand = `${k}/(x-${x}) -x`;
+            break;
         case "Droites":
+            const isConstante = probaFlip(0.2);
+            if (isConstante) {
+                wrongY = undefined;
+                otherPoints.push([x + 1, y]);
+            }
             //nothing to add
             break;
         case "Tracés":
@@ -172,21 +232,34 @@ const getImageFunctionGeogebra = (opts) => {
         functionType,
         wrongY,
         otherPoints,
+        functionCommand,
     };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getPropositions = (n, { answer, x, y, wrongY }, opts) => {
+const getPropositions = (n, { answer, wrongY }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    //old questions have spline POint undefined
-    tryToAddWrongProp(propositions, wrongY + "");
+    if (wrongY !== undefined)
+        tryToAddWrongProp(propositions, wrongY + "");
+    tryToAddWrongProp(propositions, "\\text{Aucun}");
     while (propositions.length < n) {
-        const wrongAnswer = Number(answer) + randint(-10, 11, [0]);
+        const wrongAnswer = randint(-10, 11, [0]);
         tryToAddWrongProp(propositions, wrongAnswer + "");
     }
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }, opts) => {
+    if (answer === "\\text{Aucun}")
+        return ans === answer;
+    try {
+        const parsed = valueParser(ans);
+        if (parsed === false)
+            return false;
+        return Math.abs(parsed - answer.unfrenchify()) < 0.3;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
     return numberVEA(ans, answer);
 };
 const options = [
@@ -196,7 +269,13 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         defaultValue: ["Tracés", "Polynômes", "Droites", "Paraboles"],
-        values: ["Tracés", "Polynômes", "Droites", "Paraboles"],
+        values: [
+            "Tracés",
+            "Polynômes",
+            "Droites",
+            "Paraboles",
+            "Avec valeur interdite (pas d'image)",
+        ],
     },
 ];
 export const imageFunctionGeogebra = {
@@ -217,4 +296,6 @@ export const imageFunctionGeogebra = {
     getGGBOptions,
     rebuildIdentifiers,
     getQuestionFromIdentifiers,
+    getKeys,
+    getStartStatement,
 };

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.d.ts

@@ -1,10 +1,7 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
-    xValue: number;
     yValue: number;
-    affineCoeffs?: number[];
-    trinomCoeffs?: number[];
-    isAffine: boolean;
+    points: number[][];
 };
 export declare const inverseImageFunctionGeogebra: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA0IF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAmNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.js

@@ -1,94 +1,175 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { Affine } from "../../../../math/polynomials/affine.js";
-import { Polynomial } from "../../../../math/polynomials/polynomial.js";
-import { Trinom } from "../../../../math/polynomials/trinom.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { Parabola } from "../../../../math/geometry/parabola.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.points?.length)
+        return oldIds;
+    const [x, y] = [oldIds.xValue, oldIds.yValue];
+    let points = [[x, y]];
+    if (oldIds.isAffine) {
+        const affine = AffineConstructor.fromCoeffs(oldIds.affineCoeffs);
+        const x2 = x + 1;
+        const y2 = affine.calculate(x2);
+        points.push([x2, y2]);
+    }
+    else {
+        const trinom = TrinomConstructor.fromCoeffs(oldIds.trinomCoeffs);
+        const x2 = x - 1;
+        const x3 = x + 1;
+        const y2 = trinom.calculate(x2);
+        const y3 = trinom.calculate(x3);
+        points.push([x2, y2], [x3, y3]);
+    }
+    return {
+        points,
+        yValue: oldIds.yValue,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { yValue } = identifiers;
+    return `Avec la précision permise par le graphique, déterminer le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.
+  
+S'il n'y en a pas, on écrira "aucun".`;
+};
+const getAnswer = (identifiers) => {
+    const { points, yValue } = identifiers;
+    const validPoints = points.filter((p) => p[1] === yValue);
+    if (!validPoints.length) {
+        return "\\text{Aucun}";
+    }
+    return validPoints
+        .map((p) => round(p[0], 2).frenchify())
+        .join("\\text{ et }");
+};
+const getGGBOptions = (identifiers) => {
+    const { points } = identifiers;
+    let commands = [];
+    if (points.length === 2) {
+        const line = new Line(new Point("A", points[0][0], points[0][1]), new Point("B", points[1][0], points[1][1]));
+        commands = line.toGGBCommands(false);
+    }
+    else {
+        const parabola = new Parabola(points.map((p, i) => new Point(`A_${i}`, p[0], p[1])));
+        commands = parabola.toGGBCommands(false);
+    }
+    const Xs = points.map((p) => p[0]);
+    const Ys = points.map((p) => p[1]);
+    const xMin = Math.min(...Xs);
+    const xMax = Math.max(...Xs);
+    const yMin = Math.min(...Ys);
+    const yMax = Math.max(...Ys);
+    const ggb = new GeogebraConstructor({ commands });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+            forceShowAxes: true,
+        }),
+    });
+};
 const getInverseImageFunctionGeogebra = () => {
-    const isAffine = coinFlip();
-    const xValue = randint(-5, 6);
-    // const yValue = randint(-5, 6);
+    const isLine = coinFlip();
+    const hasAntecedent = probaFlip(0.8);
+    // const isLine = false;
+    // const hasAntecedent = true;
     let yValue;
-    let affine;
-    let trinom;
-    let answer = "";
-    let xMin = -1;
-    let xMax = 1;
-    let yMin = -1;
-    let yMax = 1;
-    let commands;
-    if (isAffine) {
-        do {
-            affine = new Affine(randint(-5, 6, [0]), randint(-9, 10));
-            yValue = affine.calculate(xValue);
-        } while (Math.abs(yValue) > 10);
-        answer = xValue.toString().replace(".", ",");
-        yMin = yValue;
-        yMax = yValue;
-        xMin = xValue;
-        xMax = xValue;
-        commands = [affine.toString()];
+    const points = [];
+    if (isLine) {
+        if (hasAntecedent) {
+            yValue = randint(-6, 7);
+            const xIsDecimal = probaFlip(0.3);
+            const xValue = xIsDecimal
+                ? randfloat(-6, 7, 2, [yValue])
+                : randint(-6, 7, [yValue]);
+            const wrongY = randint(-6, 7);
+            points.push([xValue, yValue], [yValue, wrongY]);
+        }
+        else {
+            yValue = randint(-6, 7, [0]);
+            const constante = randint(-6, 7, [yValue]);
+            points.push([0, constante], [1, constante]);
+        }
     }
     else {
-        let roots;
-        yValue = randint(-5, 6);
-        do {
-            trinom = new Trinom(randint(-4, 5, [0]), randint(-9, 10), randint(-9, 10) - yValue);
-            roots = trinom.getRoots();
-        } while (roots.some((root) => Math.abs(root) > 10));
-        answer = !roots.length
-            ? "\\text{Aucun}"
-            : roots
-                .map((r) => round(r, 1).toString().replace(".", ","))
-                .join("\\text{ et }");
-        const beta = trinom.getBeta() + yValue;
-        yMin = trinom.a > 0 ? beta : roots.length ? yValue : beta - 5;
-        yMax = trinom.a < 0 ? beta : roots.length ? yValue : beta + 5;
-        xMax = roots.length ? Math.max(...roots) : -10;
-        xMin = roots.length ? Math.min(...roots) : 10;
-        commands = [
-            `f(x) = ${yValue !== 0
-                ? trinom.add(new Polynomial([yValue])).toString()
-                : trinom.toString()}`,
-            `SetColor(f, "${randomColor()}")`,
-        ];
+        if (hasAntecedent) {
+            yValue = randint(-6, 7);
+            const xIsDecimal = coinFlip();
+            const xValue = xIsDecimal
+                ? randfloat(-6, 7, 2, [yValue])
+                : randint(-6, 7, [yValue]);
+            const hasTwoAntecedents = probaFlip(0.8);
+            if (hasTwoAntecedents) {
+                const wrongY = randint(-6, 7, [yValue]);
+                const secondAntecedentPoint = [
+                    randint(-6, 7, [xValue, yValue]),
+                    yValue,
+                ];
+                points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+            }
+            else {
+                //(x,y) is summit
+                const wrongY = randint(-6, 7, [yValue]);
+                points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+            }
+        }
+        else {
+            yValue = randint(-8, 9);
+            const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
+            const below = wrongY < yValue;
+            const summit = [
+                randint(-6, 7, [yValue]),
+                below
+                    ? randint(wrongY + 1, yValue, [wrongY])
+                    : randint(yValue + 1, wrongY, [wrongY]),
+            ];
+            const thirdPoint = [2 * summit[0] - yValue, wrongY];
+            //construire deux autrs points au pif avec y sous/audssu yValus
+            points.push([yValue, wrongY], summit, thirdPoint);
+        }
     }
-    const statement = `Lire graphiquement le ou les antécédents de $${yValue}$ par la fonction $f$ représentée ci dessous.`;
-    const ggb = new GeogebraConstructor({ commands });
+    points.sort((p1, p2) => p1[0] - p2[0]);
+    const identifiers = {
+        // xValue,
+        // affineCoeffs: isAffine ? affine!.coefficients : undefined,
+        // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
+        yValue,
+        points,
+        // isAffine,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: statement,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["et", "aucun"],
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            xValue,
-            affineCoeffs: isAffine ? affine.coefficients : undefined,
-            trinomCoeffs: isAffine ? undefined : trinom.coefficients,
-            yValue,
-            isAffine,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
+const getPropositions = (n, { answer, points, yValue }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     tryToAddWrongProp(propositions, "\\text{Aucun}");
-    if (isAffine) {
-        const affine = new Polynomial(affineCoeffs);
-        tryToAddWrongProp(propositions, affine.calculate(yValue).toString().replace(".", ","));
-    }
-    else {
-        const trinom = new Polynomial(trinomCoeffs);
-        tryToAddWrongProp(propositions, trinom.calculate(yValue).toString().replace(".", ","));
+    const wrongY = points.find((p) => p[0] === yValue)?.[1];
+    if (wrongY !== undefined) {
+        tryToAddWrongProp(propositions, wrongY.frenchify());
     }
     while (propositions.length < n) {
         const wrongAnswer = coinFlip()
@@ -98,26 +179,27 @@ const getPropositions = (n, { answer, xValue, affineCoeffs, trinomCoeffs, yValue
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer, xValue, affineCoeffs, trinomCoeffs, yValue, isAffine }) => {
-    const antecedents = [];
-    if (isAffine) {
-        antecedents.push(xValue);
+const isAnswerValid = (ans, { answer, points, yValue }) => {
+    if (ans === "\\text{Aucun}" || answer === "\\text{Aucun}")
+        return ans === answer;
+    const validPoints = points.filter((p) => p[1] === yValue);
+    const ansElements = ans.split("\\text{ et }");
+    if (validPoints.length !== ansElements.length)
+        return false;
+    let sorted = [];
+    for (const el of ansElements) {
+        const parsed = valueParser(el);
+        if (parsed === false)
+            return false;
+        sorted.push(parsed);
     }
-    else {
-        const trinom = new Polynomial(trinomCoeffs);
-        const roots = trinom.getRoots();
-        antecedents.push(...roots);
+    sorted.sort((a, b) => a - b);
+    for (let i = 0; i < sorted.length; i++) {
+        const validPointX = validPoints[i][0];
+        if (Math.abs(sorted[i] - validPointX) > 0.3)
+            return false;
     }
-    if (!antecedents.length)
-        return ans === `\\text{Aucun}`;
-    const studentNumbers = ans
-        .split("\\text{ et }")
-        .map((n) => Number(n.replace(",", ".")))
-        .filter((n) => !isNaN(n))
-        .sort((a, b) => a - b);
-    antecedents.sort((a, b) => a - b);
-    return (!!studentNumbers.length &&
-        studentNumbers.every((nb, index) => Math.abs(nb - antecedents[index]) < 0.2));
+    return true;
 };
 export const inverseImageFunctionGeogebra = {
     id: "inverseImageFunctionGeogebra",
@@ -133,4 +215,9 @@ export const inverseImageFunctionGeogebra = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getGGBOptions,
+    getQuestionFromIdentifiers,
+    rebuildIdentifiers,
 };

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts

@@ -7,5 +7,6 @@ export type ToGGBCommandsProps = {
     size?: number;
     color?: string;
     showLength?: boolean;
+    label?: string;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}

package/lib/index.d.ts

@@ -684,20 +684,18 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     functionType: string;
     x: number;
-    y: number;
-    wrongY: number;
+    y?: number;
+    wrongY?: number;
     otherPoints: number[][];
+    functionCommand?: string;
 }, {
     curveTypes: string[];
 }> | Exercise<{
     poly1: number[];
     xValue: number;
 }, {}> | Exercise<{
-    xValue: number;
     yValue: number;
-    affineCoeffs?: number[];
-    trinomCoeffs?: number[];
-    isAffine: boolean;
+    points: number[][];
 }, {}> | Exercise<{
     yValue: number;
     splinePoints: [number, number][];

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/geometry/line.d.ts

@@ -49,7 +49,7 @@ export declare class Line {
     };
     toTex(): string;
     toTexNoLeftRight(): string;
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, color, label, }?: ToGGBCommandsProps): string[];
     intersect(line: Line, intersectName?: string): Point;
 }
 //# sourceMappingURL=line.d.ts.map

package/lib/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;IAmC5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAG1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,OAAO,EAAO,MAAM,uCAAuC,CAAC;AAMrE,OAAO,EACL,aAAa,EAEd,MAAM,6CAA6C,CAAC;AAKrD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,EACjB,KAAiB,GAClB,GAAE,kBAAuB;IA2C5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}

package/lib/math/geometry/line.js

@@ -1,4 +1,5 @@
 import { randomSegmentName } from "../../exercises/utils/geometry/randomSegmentName.js";
+import { randomColor } from "../../geogebra/colors.js";
 import { EqualNode } from "../../tree/nodes/equations/equalNode.js";
 import { opposite } from "../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
@@ -176,7 +177,7 @@ export class Line {
     toTexNoLeftRight() {
         return this.name.replace("\\left", "").replace("\\right", "");
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, color = undefined, label = undefined, } = {}) {
         const commands = [];
         if (shouldBuildPoints) {
             const ACommands = this.pointA.toGGBCommand({
@@ -196,6 +197,15 @@ export class Line {
             `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
             `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
         ]);
+        if (label) {
+            commands.push(`SetCaption(${this.ggbName}, "${label}")`);
+        }
+        if (color) {
+            commands.push(`SetColor(${this.ggbName},"${color}")`);
+        }
+        else {
+            commands.push(`SetColor(${this.ggbName},"${randomColor()}")`);
+        }
         return commands;
     }
     intersect(line, intersectName) {

package/lib/math/geometry/parabola.d.ts

@@ -6,6 +6,6 @@ export declare class Parabola {
     unformatedName: string;
     ggbName: string;
     constructor(points: Point[], name?: string);
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, label, }?: ToGGBCommandsProps): string[];
 }
 //# sourceMappingURL=parabola.d.ts.map

package/lib/math/geometry/parabola.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parabola.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parabola.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;IAS1C,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CA+B7B"}
+{"version":3,"file":"parabola.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/parabola.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAC1F,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,CAAC,EAAE,MAAM;IAS1C,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,EAC3B,KAAiB,GAClB,GAAE,kBAAuB;CAkC7B"}

package/lib/math/geometry/parabola.js

@@ -11,7 +11,7 @@ export class Parabola {
         this.name = name ?? `\\mathcal{P}_${points.map((p) => p.name)}`;
         this.ggbName = name ?? `parabola_{${points.map((p) => p.name)}}`;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, label = undefined, } = {}) {
         const commands = [];
         if (shouldBuildPoints) {
             const pointsCommands = this.points.map((p) => p.toGGBCommand({
@@ -23,6 +23,9 @@ export class Parabola {
         else {
             commands.push(`${this.ggbName}=Polynomial(${this.points[0].toMathString()},${this.points[1].toMathString()},${this.points[2].toMathString()})`);
         }
+        if (label) {
+            commands.push(`SetCaption(${this.ggbName}, "${label}")`);
+        }
         commands.push(...[
             `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
             `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,

package/package.json

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