math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/dataRepresentations/index.js

@@ -2,9 +2,19 @@ export * from "./tableReading.js";
 export * from "./barChartReading.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
+export * from "./histogramReading.js";
 export * from "./boxPlotReadingPercentages.js";
 export * from "./boxPlotReading.js";
 export * from "./compareBoxPlot.js";
+export * from "./barChartInterpreting.js";
+export * from "./dataToGraphGraphToData.js";
+export * from "./cartesianGraphExtremaReading.js";
+export * from "./scatterPlotCommenting.js";
+export * from "./boxPlotInterpreting.js";
+export * from "./graphReading.js";
+export * from "./plausibleGraph.js";
+export * from "./halfPieChartReading.js";
+export * from "./halfPieChartCommenting.js";
 // export * from "./testGen.js";
 // export * from "./testGenGGB.js";
 // export * from "./testGenStudentGGB.js";

package/lib/exercises/math/dataRepresentations/plausibleGraph.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    indexSituation: number;
+    bigNumber: number;
+    values: number[];
+};
+export declare const plausibleGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibleGraph.d.ts.map

package/lib/exercises/math/dataRepresentations/plausibleGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/plausibleGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA4JF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/dataRepresentations/plausibleGraph.js

@@ -0,0 +1,145 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { random } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+const getProportions = (values) => {
+    const total = values.reduce((acc, x) => acc + x, 0);
+    return values.map((value) => frac(value, total));
+};
+const situations = [
+    {
+        createValues: (n) => {
+            return [n, n, n];
+        },
+        hint: (n) => {
+            return `$${n}$ est le tiers de $${n * 3}$.`;
+        },
+        tex: `Tous les secteurs du diagramme représentent strictement moins de $50\\%$ des effectifs`,
+    },
+    {
+        createValues: (n) => {
+            return [2.5 * n, n, 1.5 * n];
+        },
+        hint: (n) => {
+            return `$${n}$ est le cinquième de $${n * 5}$.`;
+        },
+        tex: `Un secteur représente une portion égale à $50\\%$ et un autre une portion égale à $20\\%$`,
+    },
+    {
+        createValues: (n) => {
+            return [2.5 * n, 1.25 * n, 1.25 * n];
+        },
+        hint: (n) => {
+            return `$${1.25 * n}$ est le quart de $${n * 5}$.`;
+        },
+        tex: `Un secteur représente une portion égale à $50\\%$ et un autre une portion égale à $25\\%$`,
+    },
+    {
+        createValues: (n) => {
+            return [6 * n, 3 * n, n];
+        },
+        hint: (n) => {
+            return `$${n}$ est le dixième de $${n * 10}$.`;
+        },
+        tex: `Un secteur représente une portion strictement supérieure à $50\\%$`,
+    },
+];
+const getInstruction = (identifiers) => {
+    const { values } = identifiers;
+    const total = values.reduce((acc, x) => acc + x, 0);
+    return `Sur $${total.frenchify()}$ personnes, on distingue $3$ groupes :
+
+groupe A : $${values[0].frenchify()}$ personnes
+
+groupe B : $${values[1].frenchify()}$ personnes
+
+groupe C : les autres.
+  
+Parmi les propositions ci-dessous, laquelle décrit cette situation représentée par un diagramme circulaire ?`;
+};
+const getPropositions = (_, { ...identifiers }) => {
+    const { indexSituation } = identifiers;
+    const propositions = [];
+    situations.forEach((situation, i) => {
+        if (i === indexSituation) {
+            addValidProp(propositions, situation.tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, situation.tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getHint = (identifiers) => {
+    const { indexSituation, bigNumber } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.hint(bigNumber);
+};
+const getCorrection = (identifiers) => {
+    const { values } = identifiers;
+    const proportions = getProportions(values);
+    const approxs = proportions.map((proportion) => {
+        const simplified = proportion.simplify();
+        const times100 = multiply(100, simplified).simplify().evaluate();
+        const isApprox = !Number.isInteger(times100);
+        const percentage = round(times100, 0);
+        return {
+            isApprox,
+            percentage,
+        };
+    });
+    return ` 
+Les proportions sont:
+
+${["A", "B", "C"]
+        .map((letter, i) => `
+groupe ${letter} :
+
+$$
+${proportions[i].toTex()} = ${proportions[i].simplify().toTex()} ${approxs[i].isApprox ? `\\approx` : "="}  ${approxs[i].percentage}\\%
+$$
+
+`)
+        .join(``)}`;
+};
+const getPlausibleGraphQuestion = () => {
+    const indexSituation = randint(0, situations.length);
+    const bigNumber = random([
+        100, 200, 300, 400, 500, 1_000, 2_000, 3_000, 4_000, 5_000, 10_000, 20_000,
+    ]);
+    const situation = situations[indexSituation];
+    const values = shuffle(situation.createValues(bigNumber));
+    return getQuestionFromIdentifiers({
+        indexSituation,
+        bigNumber,
+        values,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const plausibleGraph = {
+    id: "plausibleGraph",
+    label: "Repérer le diagramme vraisemblable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/math/dataRepresentations/scatterPlotCommenting.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { CloudPointsIdentifiers } from "../../../math/geometry/CloudPoints.js";
+type Identifiers = {
+    cloudPointsIdentifiers: CloudPointsIdentifiers;
+    evolutionType: string;
+};
+export declare const scatterPlotCommenting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotCommenting.d.ts.map

package/lib/exercises/math/dataRepresentations/scatterPlotCommenting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotCommenting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/scatterPlotCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkZF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/dataRepresentations/scatterPlotCommenting.js

@@ -0,0 +1,308 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { CloudPoints, CloudPointsConstructor, } from "../../../math/geometry/CloudPoints.js";
+import { Point, PointConstructor } from "../../../math/geometry/point.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+const countries = [
+    "Lusitalie",
+    "Franemagne",
+    "Esprèce",
+    "Belgarie",
+    "Slovégal",
+    "Finlange",
+    "Suénemark",
+    "Cromanie",
+    "Polgique",
+    "Maltonie",
+];
+const getInstruction = () => {
+    return `Observe ce nuage de points.
+  
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return `Regarde si les points semblent respecter une règle ou bien pas du tout.`;
+};
+const getCorrection = (identifiers) => {
+    const { evolutionType, cloudPointsIdentifiers } = identifiers;
+    const allValidProps = propsForEvolutionType[evolutionType];
+    const cloudPoints = CloudPointsConstructor.fromIdentifiers(cloudPointsIdentifiers);
+    return `Voici tout ce que l'on peut dire sur ce nuage de points : 
+  
+${allValidProps.join(`
+  
+`)}
+
+${(() => {
+        switch (evolutionType) {
+            case "increasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une faible croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une forte croissance du PIB.`;
+            }
+            case "decreasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une forte croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une faible croissance du PIB.`;
+            }
+            case "unpredictible": {
+                return `En effet, 
+il y a des pays avec un taux de chômage faible et une croissance faible,
+il y a des pays avec un taux de chômage faible et une croissance forte,
+il y a des pays avec un taux de chômage fort et une croissance faible,
+il y a des pays avec un taux de chômage fort et une croissance forte.
+`;
+            }
+            case "increasingThenDecreasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une faible croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une faible croissance du PIB.`;
+            }
+            case "decreasingThenIncreasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une forte croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une forte croissance du PIB.`;
+            }
+            default:
+                return ``;
+        }
+    })()}`;
+};
+const propsForEvolutionType = {
+    increasing: [
+        `Plus le taux de chômage est élevé et plus la croissance du PIB est élevée.`,
+        `Si le taux de chômage est faible alors la croissance du PIB est faible.`,
+        `Si le taux de chômage est élevé alors la croissance du PIB est élevée.`,
+    ],
+    decreasing: [
+        `Plus le taux de chômage est élevé et plus la croissance du PIB est faible.`,
+        `Si le taux de chômage est faible alors la croissance du PIB est élevée.`,
+        `Si le taux de chômage est élevé alors la croissance du PIB est faible.`,
+    ],
+    unpredictible: [
+        `Il n'y a aucun lien entre le taux de chômage et la croissance du PIB.`,
+    ],
+    increasingThenDecreasing: [
+        `Si le taux de chômage est faible alors la croissance du PIB est faible.`,
+        `Si le taux de chômage est élevé alors la croissance du PIB est faible.`,
+    ],
+    decreasingThenIncreasing: [
+        `Si le taux de chômage est faible alors la croissance du PIB est élevée.`,
+        `Si le taux de chômage est élevé alors la croissance du PIB est élevée.`,
+    ],
+};
+const getPropositions = (n, { evolutionType }) => {
+    const propositions = [];
+    const allValidProps = propsForEvolutionType[evolutionType];
+    const validPropsPicked = randomMany(propsForEvolutionType[evolutionType], randint(1, propsForEvolutionType[evolutionType].length + 1));
+    validPropsPicked.forEach((str) => {
+        addValidProp(propositions, str, "raw");
+    });
+    const invalidProps = [
+        ...Object.values(propsForEvolutionType).flatMap((props) => props),
+    ]
+        .filter((prop) => !allValidProps.includes(prop))
+        //prevent confusion
+        .filter((prop) => evolutionType === "increasingThenDecreasing" ||
+        evolutionType === "decreasingThenIncreasing"
+        ? prop !==
+            `Il n'y a aucun lien entre le taux de chômage et la croissance du PIB.`
+        : true);
+    invalidProps.forEach((str) => {
+        tryToAddWrongProp(propositions, str, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getGGBOptions = (identifiers) => {
+    const { cloudPointsIdentifiers } = identifiers;
+    const cloudPoints = new CloudPoints(cloudPointsIdentifiers.pointsIdentifiers.map((i) => PointConstructor.fromIdentifiers(i)));
+    const commands = cloudPoints.points.flatMap((point, i) => {
+        return [
+            `${point.name}=Point({${point.getXnumber()},${point.getYnumber()}})`,
+            `SetFixed(${point.name},true)`,
+            `Lbl_{${i}} = Text("\\tiny ${point.name}", (${point.x.toMathString()},${point.y.evaluate() + 0.7}), true, true, 0, 0)`,
+            `SetFixed(Lbl_{${i}},true)`,
+        ];
+    });
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: false,
+        hideGrid: false,
+        xAxis: {
+            steps: 1,
+            label: "Chômage (%)",
+        },
+        yAxis: {
+            steps: 0.5,
+            label: "Croissance du PIB (%)",
+        },
+        fontSize: 15,
+    });
+    const xValues = cloudPoints.points.map((element) => {
+        return element.getXnumber();
+    });
+    const yValues = cloudPoints.points.map((element) => {
+        return element.getYnumber();
+    });
+    const xMin = Math.min(...xValues);
+    const xMax = Math.max(...xValues);
+    const yMin = Math.min(...yValues);
+    const yMax = Math.max(...yValues);
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getScatterPlotCommentingQuestion = () => {
+    const nbCountries = 6;
+    const countriesPicked = randomMany(countries, nbCountries);
+    const boxFull = { xMin: 3, xMax: 13, yMin: 0, yMax: 4 };
+    const evolutionType = random([
+        "increasing",
+        "decreasing",
+        "unpredictible",
+        "increasingThenDecreasing",
+        "decreasingThenIncreasing",
+    ]);
+    let cloudPointsWithEvoBoxed;
+    switch (evolutionType) {
+        case "increasing":
+        case "decreasing":
+            {
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountries, evolutionType), boxFull);
+            }
+            break;
+        case "unpredictible":
+        default:
+            {
+                const nbCountriesTop = Math.floor(nbCountries / 2);
+                const nbCountriesBottom = nbCountries - nbCountriesTop;
+                const cloudPointsTop = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesTop, "scatter"), {
+                    xMin: 0,
+                    xMax: 1,
+                    yMin: 0.7,
+                    yMax: 1,
+                });
+                const cloudPointsBottom = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesBottom, "scatter"), {
+                    xMin: 0,
+                    xMax: 1,
+                    yMin: 0,
+                    yMax: 0.3,
+                });
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
+                        ...cloudPointsTop.points,
+                        ...cloudPointsBottom.points,
+                    ]), boxFull);
+            }
+            break;
+        case "increasingThenDecreasing":
+            {
+                const nbCountriesIncr = Math.floor(nbCountries / 2);
+                const nbCountriesDecr = nbCountries - nbCountriesIncr;
+                const cloudPointsIncr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesIncr, "increasing"), {
+                    xMin: 0,
+                    xMax: 0.5,
+                    yMin: 0,
+                    yMax: 1,
+                });
+                const cloudPointsDecr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesDecr, "decreasing"), {
+                    xMin: 0.5,
+                    xMax: 1,
+                    yMin: 0,
+                    yMax: 1,
+                });
+                const boxLow = {
+                    xMin: boxFull.xMin,
+                    xMax: boxFull.xMax,
+                    yMin: boxFull.yMin,
+                    yMax: ((boxFull.yMin + boxFull.yMax) * 1) / 3,
+                };
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
+                        ...cloudPointsIncr.points,
+                        ...cloudPointsDecr.points,
+                    ]), boxLow);
+            }
+            break;
+        case "decreasingThenIncreasing":
+            {
+                const nbCountriesDecr = Math.floor(nbCountries / 2);
+                const nbCountriesIncr = nbCountries - nbCountriesDecr;
+                const cloudPointsDecr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesDecr, "decreasing"), {
+                    xMin: 0,
+                    xMax: 0.5,
+                    yMin: 0,
+                    yMax: 1,
+                });
+                const cloudPointsIncr = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesIncr, "increasing"), {
+                    xMin: 0.5,
+                    xMax: 1,
+                    yMin: 0,
+                    yMax: 1,
+                });
+                const boxHigh = {
+                    xMin: boxFull.xMin,
+                    xMax: boxFull.xMax,
+                    yMin: ((boxFull.yMin + boxFull.yMax) * 2) / 3,
+                    yMax: boxFull.yMax,
+                };
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
+                        ...cloudPointsIncr.points,
+                        ...cloudPointsDecr.points,
+                    ]), boxHigh);
+            }
+            break;
+    }
+    const namedPoints = cloudPointsWithEvoBoxed.points.map((point, i) => new Point(countriesPicked[i], point.x, point.y));
+    const cloudPointsNamed = new CloudPoints(namedPoints);
+    const identifiers = {
+        cloudPointsIdentifiers: cloudPointsNamed.toIdentifiers(),
+        evolutionType,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const scatterPlotCommenting = {
+    id: "scatterPlotCommenting",
+    label: "Commenter un nuage de points",
+    isSingleStep: true,
+    hasGeogebra: true,
+    generator: (nb) => getDistinctQuestions(getScatterPlotCommentingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getHint,
+    getCorrection,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAmFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAyFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.js

@@ -3,6 +3,7 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
 import { ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
 import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
@@ -18,12 +19,15 @@ f(x) = ${fct.toTex()}
 $$`;
 };
 const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getAnswerNode = (identifiers) => {
     const { affine1Coeffs, affine2Coeffs } = identifiers;
     const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
     const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
     const exp = new ExpNode(affine2.toTree());
     const deriv = new MultiplyNode(new Affine(affine2.a * affine1.a, affine1.a + affine2.a * affine1.b).toTree(), exp);
-    return deriv.simplify().toTex();
+    return deriv.simplify();
 };
 const getExpDerivativeFourQuestion = () => {
     const affine1 = AffineConstructor.random();
@@ -53,12 +57,13 @@ const getPropositions = (n, { answer }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
-        const parsed = parseAlgebraic(ans);
-        if (!parsed)
+        const ansNode = parseAlgebraic(ans);
+        if (!ansNode)
             return false;
-        return parsed.simplify().toTex() === answer;
+        const answerNode = getAnswerNode(identifiers);
+        return substract(ansNode, answerNode).simplify().evaluate() === 0;
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindX.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffs: number[];
+    yValue: number;
+};
+export declare const coordsOfPointOnAffineFindX: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=coordsOfPointOnAffineFindX.d.ts.map

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordsOfPointOnAffineFindX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/coordsOfPointOnAffineFindX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindX.js

@@ -0,0 +1,103 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+const getInstruction = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const affine = AffineConstructor.fromCoeffs(coeffs);
+    return `Le point $M$ d'ordonnée $${yValue}$ appartient à la courbe d'équation 
+
+$$
+y=${affine.toTex()} 
+$$
+
+Quelles sont les coordonnées de $M$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const polynome = AffineConstructor.fromCoeffs(coeffs);
+    const xValue = polynome.solve(yValue);
+    const answer = `(${xValue.toTex()};${yValue.frenchify()})`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const affine = new Affine(coeffs[1], coeffs[0], "x_{M}");
+    return `Les coordonnées de $M$ vérifient:
+
+$$
+${affine.toTex()} = y_{M} 
+$$
+  
+  On doit donc résoudre l'équation : 
+  
+$$
+${affine.toTex()} = ${yValue} 
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { yValue, coeffs } = identifiers;
+    const affine = new Affine(coeffs[1], coeffs[0], "x_{M}");
+    const answer = getAnswer(identifiers);
+    return `On résout l'équation : 
+  
+$$
+${affine.toTex()} = ${yValue} 
+$$
+
+On obtient : 
+
+$$
+${equationResolutionTex(coeffs[1].toTree(), coeffs[0].toTree(), (0).toTree(), yValue.toTree(), "x_{M}")}
+$$
+
+Les coordonnées de $M$ sont donc $${answer}$.`;
+};
+const getPropositions = (n, { answer, coeffs, yValue }) => {
+    const [p, m] = coeffs;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const poly = AffineConstructor.fromCoeffs(coeffs);
+    tryToAddWrongProp(propositions, `(${yValue.frenchify()}, ${poly.calculate(yValue).frenchify()})`);
+    tryToAddWrongProp(propositions, `(${yValue}, ${AffineConstructor.fromCoeffs([p, -m])
+        .calculate(yValue)
+        .frenchify()})`);
+    tryToAddWrongProp(propositions, `(${frac(add(yValue, p), m).simplify().toTex()}, ${yValue.frenchify()})`);
+    return shuffleProps(propositions, n);
+};
+const getCoordsOfPointOnAffineFindXQuestion = () => {
+    const polynome1 = new Polynomial([randint(-9, 10), randint(-5, 6, [0])]);
+    const xValue = randint(-9, 10);
+    const y = polynome1.calculate(xValue);
+    const identifiers = { coeffs: polynome1.coefficients, yValue: y };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const coordsOfPointOnAffineFindX = {
+    id: "coordsOfPointOnAffineFindX",
+    getPropositions,
+    label: "Déterminer les coordonnées d'un point appartenant à une courbe et dont on connaît l'ordonnée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCoordsOfPointOnAffineFindXQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/affines/coordsOfPointOnAffineFindY.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffs: number[];
+    xValue: number;
+};
+export declare const coordsOfPointOnAffineFindY: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=coordsOfPointOnAffineFindY.d.ts.map