math-exercises 3.0.8 → 3.0.9

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;
+    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;AAsBrC,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,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAgRF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}

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

@@ -49,19 +49,33 @@ 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 ?`;
+    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 { functionType, otherPoints, wrongY, x, y, functionCommand } = identifiers;
     const allPoints = [...otherPoints, [x, y], [wrongY, x]].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()}")`,
+            ];
+            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);
@@ -104,10 +118,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 +145,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 [];
+    }
+};
 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,12 +166,18 @@ 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":
             //nothing to add
             break;
@@ -172,10 +209,11 @@ 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
@@ -196,7 +234,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 = {

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

@@ -684,20 +684,18 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     functionType: string;
     x: number;
-    y: 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/package.json

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