math-exercises 3.0.111 → 3.0.113

package/lib/exercises/math/calcul/mentalCaluls/mentalPercentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalPercentage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalPercentage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuJF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}
+{"version":3,"file":"mentalPercentage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalPercentage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0JF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalPercentage.js

@@ -1,6 +1,6 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -119,7 +119,10 @@ const getPropositions = (n, { answer, rand }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (studentAns, { answer }) => {
-    return numberVEA(studentAns, answer);
+    return rationalVEA(studentAns, answer, {
+        allowNonIrreductible: true,
+        allowDecimal: true,
+    });
 };
 export const mentalPercentage = {
     id: "mentalPercentage",

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type QuartileIndex = 0 | 1 | 2 | 3 | 4;
+type Identifiers = {
+    quartileIndex: QuartileIndex;
+    quartiles: number[];
+};
+export declare const boxPlotReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=boxPlotReading.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxPlotReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/boxPlotReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA0IF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}

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

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../math/utils/random/randint.js";
+const getPropositions = (n, { answer, quartiles }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [0, 1, 2, 3, 4].forEach((qIndex) => {
+        tryToAddWrongProp(propositions, quartiles[qIndex].frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { quartileIndex, quartiles } = identifiers;
+    return quartiles[quartileIndex].frenchify();
+};
+const getFrenchStringForOfQuartile = (quartileIndex) => {
+    switch (quartileIndex) {
+        case 0:
+            return "du minimum";
+        case 1:
+            return "du premier quartile";
+        case 2:
+            return "de la médiane";
+        case 3:
+            return "du troisième quartile";
+        case 4:
+            return "du maximum";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { quartileIndex } = identifiers;
+    return `On a représenté une série statistique à une variable sous forme d'une boîte à moustaches.
+
+Quelle est la valeur ${getFrenchStringForOfQuartile(quartileIndex)} ?
+  `;
+};
+const getHint = () => {
+    return `Une boîte à moustaches permet de lire les indicateurs statistiques d'une série. Chaque trait vertical représente un indicateur. Ces indicateurs sont rangés dans l'ordre : minimum, premier quartile, médiane, troisième quartile, maximum.`;
+};
+const getCorrection = (identifiers) => {
+    const { quartileIndex, quartiles } = identifiers;
+    //https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/boxplot.png
+    return `Une boîte à moustache permet de lire les indicateurs statistiques d'une série : 
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/boxplot.png)
+  
+La valeur ${getFrenchStringForOfQuartile(quartileIndex)} est donc ici $ ${quartiles[quartileIndex]} $.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { quartiles } = identifiers;
+    const [q0, q1, q2, q3, q4] = quartiles;
+    const yOffset = 2;
+    const yScale = 0.8;
+    const commands = [
+        `BM = BoxPlot(${yOffset}, ${yScale}, ${q0}, ${q1}, ${q2}, ${q3}, ${q4})`,
+        `ShowLabel(BM, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: q0,
+            xMax: q4,
+            yMin: -2,
+            yMax: 5,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getBoxPlotReadingQuestion = () => {
+    const [q0, q1] = [0, 1]
+        .map((_) => randint(0, 8))
+        .toSorted((i1, i2) => i1 - i2);
+    const [q3, q4] = [0, 1]
+        .map((_) => randint(12, 20))
+        .toSorted((i1, i2) => i1 - i2);
+    const q2 = randint(q1, q3, [q1]); //we prevent q2 from being equal to q1 or q3
+    const quartiles = [q0, q1, q2, q3, q4];
+    const quartileIndex = randint(0, 5);
+    const identifiers = { quartileIndex, quartiles };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const boxPlotReading = {
+    id: "boxPlotReading",
+    label: "Lire les indicateurs statistiques sur une boîte à moustaches",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoxPlotReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type QuartileIndex = 0 | 1 | 2 | 3 | 4;
+type QuestionType = "below" | "between" | "above";
+type Identifiers = {
+    quartiles: number[];
+    arrQuartileIndex: QuartileIndex[];
+    typeQ: QuestionType;
+};
+export declare const boxPlotReadingPercentages: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=boxPlotReadingPercentages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boxPlotReadingPercentages.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/boxPlotReadingPercentages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC,KAAK,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;AAElD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,aAAa,EAAE,CAAC;IAClC,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AA0NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}

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

@@ -0,0 +1,198 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { probaLawFlip } from "../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [0, 25, 50, 75, 100].forEach((percentage) => {
+        tryToAddWrongProp(propositions, percentage.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { arrQuartileIndex } = identifiers;
+    return multiply(substract(arrQuartileIndex[1], arrQuartileIndex[0]), 25)
+        .simplify()
+        .toTex();
+};
+const getFrenchStringForDuQuartile = (quartileIndex) => {
+    switch (quartileIndex) {
+        case 0:
+            return "du minimum";
+        case 1:
+            return "du premier quartile";
+        case 2:
+            return "de la médiane";
+        case 3:
+            return "du troisième quartile";
+        case 4:
+            return "du maximum";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { quartiles, arrQuartileIndex, typeQ } = identifiers;
+    const vMin = quartiles[arrQuartileIndex[0]];
+    const vMax = quartiles[arrQuartileIndex[1]];
+    return `On a représenté une série statistique à une variable sous forme d'une boîte à moustaches.
+${(() => {
+        switch (typeQ) {
+            case "below":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont inférieures ou égales à $${vMax}$ ?`;
+            case "between":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont comprises entre $${vMin}$ et $${vMax}$ ?`;
+            case "above":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont supérieures ou égales à $${vMin}$ ?`;
+        }
+    })()}
+`;
+};
+const getHint = () => {
+    return `$25\\%$ des données sont inférieures ou égales au premier quartile ($Q_1$).
+
+$50\\%$ des données sont inférieures ou égales à la médiane ($Q_2$).
+
+$75\\%$ des données sont inférieures ou égales au troisième quartile ($Q_3$).`;
+};
+const getCorrection = (identifiers) => {
+    const { quartiles, arrQuartileIndex, typeQ } = identifiers;
+    const texPercentage = getAnswer(identifiers);
+    switch (typeQ) {
+        case "below":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[1]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[1])}.
+
+La proportion de valeurs inférieures ou égales à $ ${quartiles[arrQuartileIndex[1]]} $ est donc $${texPercentage}\\%$.`;
+        case "between":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[0]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[0])} , et $ ${quartiles[arrQuartileIndex[1]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[1])}.
+
+La proportion de valeurs comprises entre $ ${quartiles[arrQuartileIndex[0]]} $ et $ ${quartiles[arrQuartileIndex[1]]} $ est donc $${texPercentage}\\%$.`;
+        case "above":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[0]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[0])}.
+
+   
+La proportion de valeurs supérieures ou égales à $ ${quartiles[arrQuartileIndex[0]]} $ est donc  $${texPercentage}\\%$.`;
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { quartiles } = identifiers;
+    const [q0, q1, q2, q3, q4] = quartiles;
+    const yOffset = 2;
+    const yScale = 0.8;
+    const commands = [
+        `BM = BoxPlot(${yOffset}, ${yScale}, ${q0}, ${q1}, ${q2}, ${q3}, ${q4})`,
+        `ShowLabel(BM, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: q0,
+            xMax: q4,
+            yMin: -2,
+            yMax: 5,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getBoxPlotReadingPercentagesQuestion = () => {
+    const arrBounds = probaLawFlip([
+        [
+            [
+                { min: 0, max: 8 },
+                { min: 12, max: 20 },
+            ],
+            0.6,
+        ],
+        [
+            [
+                { min: -8, max: 0 },
+                { min: 20, max: 28 },
+            ],
+            0.2,
+        ],
+        [
+            [
+                { min: -20, max: -12 },
+                { min: 0, max: 8 },
+            ],
+            0.2,
+        ],
+    ]);
+    const [q0, q1] = [0, 1]
+        .map((_) => randint(arrBounds[0].min, arrBounds[0].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const [q3, q4] = [0, 1]
+        .map((_) => randint(arrBounds[1].min, arrBounds[1].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const q2 = randint(q1, q3, [q1]); //we prevent q2 from being equal to q1 or q3
+    const quartiles = [q0, q1, q2, q3, q4];
+    const arrQuartileIndexAvailable = [
+        0,
+        ...(q0 !== q1 ? [1] : []),
+        2,
+        ...(q3 !== q4 ? [3] : []),
+        4,
+    ];
+    const arrQuartileIndex = randomMany(arrQuartileIndexAvailable, 2).toSorted((i1, i2) => i1 - i2);
+    const typeQ = random([
+        ...(arrQuartileIndex[0] === 0 ? ["below"] : []),
+        "between",
+        ...(arrQuartileIndex[1] === 4 ? ["above"] : []),
+    ]);
+    const identifiers = { quartiles, arrQuartileIndex, typeQ };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const boxPlotReadingPercentages = {
+    id: "boxPlotReadingPercentages",
+    label: "Lire des proportions sur une boîte à moustaches",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoxPlotReadingPercentagesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,6 @@ export * from "./tableReading.js";
 export * from "./barChartReading.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
+export * from "./boxPlotReadingPercentages.js";
+export * from "./boxPlotReading.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC"}

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

@@ -2,6 +2,8 @@ export * from "./tableReading.js";
 export * from "./barChartReading.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
+export * from "./boxPlotReadingPercentages.js";
+export * from "./boxPlotReading.js";
 // export * from "./testGen.js";
 // export * from "./testGenGGB.js";
 // export * from "./testGenStudentGGB.js";

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

@@ -44,6 +44,7 @@ const getGGBOptions = (identifiers) => {
     const penteString = penteTree.toMathString();
     const originString = originTree.toMathString();
     const polynome = new Polynomial(identifiers.coeffs);
+    console.log(polynome.toMathString());
     const commands = [
         `f(x) = ${polynome.toMathString()}`,
         `SetColor(f, "${blueMain}")`,

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIdsA: PointIdentifiers;
+    pointIdsB: PointIdentifiers;
+    funcName: string;
+};
+export declare const drawAffineFrom2Points: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=drawAffineFrom2Points.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drawAffineFrom2Points.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/drawAffineFrom2Points.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -0,0 +1,151 @@
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHint = () => {
+    return `Si $f$ est une fonction telle que $f(x) = y$, 
+alors la courbe représentative de f passe par le point de coordonnées $(x;y)$.
+Détermine deux points par lesquels passe la droite représentative de la fonction.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIdsA, pointIdsB, funcName } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    return `La fonction $${funcName}$ est une fonction affine.
+Sa représentation graphique est une droite, que l'on va nommer $d$.
+
+On sait que $ ${funcName}(${pointA.x.toTex()}) = ${pointA.y.toTex()} $.
+C'est-à-dire que le point de coordonnées $(${pointA.x.toTex()}; ${pointA.y.toTex()})$ appartient à $d$.
+
+On sait que $ ${funcName}(${pointB.x.toTex()}) = ${pointB.y.toTex()} $.
+C'est-à-dire que le point de coordonnées $(${pointB.x.toTex()}; ${pointB.y.toTex()})$ appartient également à $d$.
+
+On place donc les deux points de coordonnées $(${pointA.x.toTex()}; ${pointA.y.toTex()})$ et $(${pointB.x.toTex()}; ${pointB.y.toTex()})$, 
+puis on trace la droite passant par ces deux points.`;
+};
+const getInstruction = (identifiers) => {
+    const { pointIdsA, pointIdsB, funcName } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    return `La fonction $${funcName}$ est affine telle que : 
+  
+$ ${funcName}(${pointA.x.toTex()}) = ${pointA.y.toTex()} $ et
+$ ${funcName}(${pointB.x.toTex()}) = ${pointB.y.toTex()} $.
+
+Dans le repère, tracer la représentation graphique de la fonction $${funcName}$.`;
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointIdsA, pointIdsB } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    const studentGGB = new GeogebraConstructor({
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({
+            join: true,
+        }),
+    });
+    const [xA, xB, yA, yB] = [pointA.x, pointB.x, pointA.y, pointB.y].map((node) => node.evaluate());
+    const [xMin, xMax, yMin, yMax] = [
+        Math.min(xA, xB),
+        Math.max(xA, xB),
+        Math.min(yA, yB),
+        Math.max(yA, yB),
+    ];
+    return studentGGB.getOptions({
+        coords: studentGGB.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMax,
+            yMin,
+            forceShowAxes: true,
+        }),
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointIdsA, pointIdsB } = identifiers;
+    const pointA = PointConstructor.fromIdentifiers(pointIdsA);
+    const pointB = PointConstructor.fromIdentifiers(pointIdsB);
+    return [
+        `(${pointA.x.evaluate()},${pointA.y.evaluate()})`,
+        `(${pointB.x.evaluate()},${pointB.y.evaluate()})`,
+        `Line[A, B]`,
+    ];
+};
+const getDrawAffineFrom2PointsQuestion = () => {
+    const availableCoordValues = [...Array(21).keys()].map((i) => i - 10);
+    const [xA, xB] = randomMany(availableCoordValues, 2); //this prevents building vertical lines
+    const [yA, yB] = [0, 1].map((_) => random(availableCoordValues));
+    const pointA = new Point("A", xA, yA);
+    const pointB = new Point("B", xB, yB);
+    const funcName = random(["f", "g", "h"]);
+    const identifiers = {
+        pointIdsA: pointA.toIdentifiers(),
+        pointIdsB: pointB.toIdentifiers(),
+        funcName,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const isGGBAnswerValid = (ans, { pointIdsA, pointIdsB }) => {
+    try {
+        //parse la line (si +1, faux)
+        // parse le spoints de la line
+        //transformer en vrai droite
+        // checker si A et B sont sur la droite
+        const lines = ans.filter((s) => isGGBLine(s));
+        if (lines.length !== 1)
+            return false;
+        const pointNames = lines[0]
+            .split("Line")[1]
+            .replace("[", "")
+            .replace("]", "")
+            .replace(" ", "")
+            .split(",");
+        const pointCmds = ans.filter((s) => s.startsWith(pointNames[0] + "=") || s.startsWith(pointNames[1] + "="));
+        const pointsCoords = pointCmds.map((cmd) => cmd
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .split(",")
+            .map((n) => Number(n)));
+        const points = pointsCoords.map((coord) => new Point("A", coord[0], coord[1]));
+        const line = new Line(points[0], points[1]);
+        const A = PointConstructor.fromIdentifiers(pointIdsA);
+        const B = PointConstructor.fromIdentifiers(pointIdsB);
+        return line.includes(A, 0.5) && line.includes(B, 0.5);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const drawAffineFrom2Points = {
+    id: "drawAffineFrom2Points",
+    label: "Tracer la représentation graphique d'une fonction affine à partir de deux images",
+    isSingleStep: true,
+    answerType: "GGB",
+    generator: (nb) => getDistinctQuestions(getDrawAffineFrom2PointsQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getGGBAnswer,
+    getInstruction,
+    getStudentGGBOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -12,5 +12,6 @@ export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
 export * from "./affineFromExercise.js";
+export * from "./drawAffineFrom2Points.js";
 export * from "./drawAffineFromLitExp.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}

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

@@ -12,4 +12,5 @@ export * from "./affineAdjustmentComplete.js";
 export * from "./affineMeanValue.js";
 export * from "./affineExpressionFromTwoImages.js";
 export * from "./affineFromExercise.js";
+export * from "./drawAffineFrom2Points.js";
 export * from "./drawAffineFromLitExp.js";

package/lib/exercises/math/index.d.ts

@@ -23,5 +23,4 @@ export * from "./python/index.js";
 export * from "./sampling/index.js";
 export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
-export * from "./pcExosInMath.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC"}

package/lib/exercises/math/index.js

@@ -23,4 +23,4 @@ export * from "./python/index.js";
 export * from "./sampling/index.js";
 export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
-export * from "./pcExosInMath.js";
+// export * from "./pcExosInMath.js";

package/lib/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindAntecedent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2HF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}
+{"version":3,"file":"arithmeticFindAntecedent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2HF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}