math-exercises 3.0.112 → 3.0.114

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/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/probaStat/stats2var/fineAdjustementExercise.d.ts

@@ -1,5 +1,5 @@
 import { Exercise } from "../../../../exercises/exercise.js";
-import { CloudPointsIdentifiers } from "../../../../math/geometry/cloudPoints.js";
+import { CloudPointsIdentifiers } from "../../../../math/geometry/CloudPoints.js";
 type Identifiers = {
     isJustified: boolean;
     cloudPointsIdentifiers: CloudPointsIdentifiers;

package/lib/exercises/math/probaStat/stats2var/fineAdjustementExercise.js

@@ -1,7 +1,7 @@
 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 { CloudPoints, CloudPointsConstructor, } from "../../../../math/geometry/CloudPoints.js";
 import { PointConstructor } from "../../../../math/geometry/point.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.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"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.js

@@ -20,7 +20,7 @@ $$
 
 Calculer la valeur de $ ${varName} $ pour laquelle $ u_${varName} = ${uTex} $.`;
 };
-const getPropositions = (nb_prop, { answer, a, b, n }) => {
+const getPropositions = (nb, { answer, a, b, n }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const affineWithN = new Affine(a, b, varName);
@@ -28,16 +28,16 @@ const getPropositions = (nb_prop, { answer, a, b, n }) => {
     tryToAddWrongProp(propositions, new Affine(a, b).solve(0).toTex());
     tryToAddWrongProp(propositions, affineWithN.calculate(u).toTree().toTex());
     tryToAddWrongProp(propositions, new NumberNode(n + 1).toTex());
-    if (propositions.length < nb_prop) {
+    if (propositions.length < nb) {
         if (n - 1 >= 0) {
             tryToAddWrongProp(propositions, new NumberNode(n - 1).toTex());
         }
     }
-    while (propositions.length < nb_prop) {
+    while (propositions.length < nb) {
         const wrongAnswer = NumberNodeConstructor.random(0, 20);
         tryToAddWrongProp(propositions, wrongAnswer.toTex());
     }
-    return shuffleProps(propositions, nb_prop);
+    return shuffleProps(propositions, nb);
 };
 const getAnswer = (identifiers) => {
     const { n } = identifiers;
@@ -66,13 +66,13 @@ $$
 ${equationResolutionTex(a.toTree(), b.toTree(), (0).toTree(), u.toTree(), varName)}
 $$`;
 };
-const getKeys = (identifiers) => {
+const getKeys = () => {
     return [];
 };
-const isAnswerValid = (ans, { answer, a, b, n }) => {
+const isAnswerValid = (ans, { answer }) => {
     return numberVEA(ans, answer);
 };
-const getArithmeticFindAntecedentQuestion = (ops) => {
+const getArithmeticFindAntecedentQuestion = () => {
     const affine = AffineConstructor.random(undefined, {
         excludes: [0],
     });

package/lib/index.d.ts

@@ -851,6 +851,10 @@ declare const mathExercises: (Exercise<{
     phrase: number;
     initial: number;
     growth: number;
+}, object, string | number | boolean | string[]> | Exercise<{
+    pointIdsA: import("./math/geometry/point.js").PointIdentifiers;
+    pointIdsB: import("./math/geometry/point.js").PointIdentifiers;
+    funcName: string;
 }, object, string | number | boolean | string[]> | Exercise<{
     correctA: number;
     correctB: number;
@@ -2099,7 +2103,7 @@ declare const mathExercises: (Exercise<{
     yValues: number[];
 }, object, string | number | boolean | string[]> | Exercise<{
     isJustified: boolean;
-    cloudPointsIdentifiers: import("./math/geometry/cloudPoints.js").CloudPointsIdentifiers;
+    cloudPointsIdentifiers: import("./math/geometry/CloudPoints.js").CloudPointsIdentifiers;
 }, object, string | number | boolean | string[]> | Exercise<{
     pA: number;
     pB: number;
@@ -2616,6 +2620,13 @@ declare const mathExercises: (Exercise<{
 }, object, string | number | boolean | string[]> | Exercise<{
     points: number[][];
     labels: string[];
+}, object, string | number | boolean | string[]> | Exercise<{
+    quartiles: number[];
+    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
+    typeQ: "below" | "between" | "above";
+}, object, string | number | boolean | string[]> | Exercise<{
+    quartileIndex: 0 | 1 | 2 | 3 | 4;
+    quartiles: number[];
 }, object, string | number | boolean | string[]>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

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

@@ -15,4 +15,4 @@ export declare class CloudPoints {
     getFineAdjustement(): EqualNode;
     getCorrelationCoeff(): NumberNode;
 }
-//# sourceMappingURL=cloudPoints.d.ts.map
+//# sourceMappingURL=CloudPoints.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/cloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAMpE,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAU9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}
+{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGpE,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AAMpE,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAU9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}

package/lib/tree/nodes/equations/equalNode.d.ts

@@ -38,6 +38,6 @@ export declare class EqualNode implements AlgebraicNode {
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): EqualNode;
     isVerified(): boolean;
 }
-export declare const equationResolutionTex: (a: AlgebraicNode, b: AlgebraicNode, c: AlgebraicNode, d: AlgebraicNode, str__var?: string) => string | string[];
+export declare const equationResolutionTex: (a: AlgebraicNode, b: AlgebraicNode, c: AlgebraicNode, d: AlgebraicNode, strVar?: string) => string | string[];
 export {};
 //# sourceMappingURL=equalNode.d.ts.map

package/lib/tree/nodes/equations/equalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAkB,MAAM,uBAAuB,CAAC;AAQxE,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,GAAI,MAAM,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc;IAqG9C,UAAU,IAAI,aAAa;IAG3B,MAAM,IAAI,OAAO;IAGjB,QAAQ,IAAI,MAAM;IAGlB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS;IAMpE,UAAU;CAIX;AAED,eAAO,MAAM,qBAAqB,GAChC,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,WAAU,MAAY,sBA2DvB,CAAC"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGrE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAkB,MAAM,uBAAuB,CAAC;AAQxE,eAAO,MAAM,KAAK,GAChB,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,EAClC,GAAG,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,GAAI,MAAM,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc;IAqG9C,UAAU,IAAI,aAAa;IAG3B,MAAM,IAAI,OAAO;IAGjB,QAAQ,IAAI,MAAM;IAGlB,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS;IAMpE,UAAU;CAIX;AAED,eAAO,MAAM,qBAAqB,GAChC,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,GAAG,aAAa,EAChB,SAAQ,MAAY,sBAgErB,CAAC"}

package/lib/tree/nodes/equations/equalNode.js

@@ -199,7 +199,7 @@ export class EqualNode {
         return this.leftChild.simplify().equals(this.rightChild.simplify());
     }
 }
-export const equationResolutionTex = (a, b, c, d, str__var = "x") => {
+export const equationResolutionTex = (a, b, c, d, strVar = "x") => {
     //(+-a)x(+-b) = (+-c)x(+-d)
     const steps = [];
     const iteration = (a, b, c, d) => {
@@ -211,24 +211,24 @@ export const equationResolutionTex = (a, b, c, d, str__var = "x") => {
                 //ax = d
                 if (aEv === 1) {
                     //x = d
-                    steps.push(`${str__var}=${d.toTex()}`);
+                    steps.push(`${strVar}=${d.toTex()}`);
                     return;
                 }
                 else {
                     //ax = d
-                    steps.push(`${multiply(a, str__var).toTex()}=${d.toTex()}`);
+                    steps.push(`${multiply(a, strVar).toTex()}=${d.toTex()}`);
                     iteration((1).toTree(), (0).toTree(), (0).toTree(), frac(d, a).simplify());
                 }
             }
             else {
-                steps.push(`${monom(a, 1, { variable: str__var }).toTex()}=${add(monom(c, 1, { variable: str__var }), d).toTex()}`);
+                steps.push(`${monom(a, 1, { variable: strVar }).toTex()}=${add(monom(c, 1, { variable: strVar }), d).toTex()}`);
                 //ax = c!x + d
                 iteration(substract(a, c).simplify(), (0).toTree(), (0).toTree(), d);
             }
         }
         else {
             //ax + b! = cx + d
-            steps.push(`${add(multiply(a, str__var), b).simplify().toTex()}=${add(multiply(c, str__var), d)
+            steps.push(`${add(multiply(a, strVar), b).simplify().toTex()}=${add(multiply(c, strVar), d)
                 .simplify()
                 .toTex()}`);
             iteration(a, (0).toTree(), c, substract(d, b).simplify());

package/package.json

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