math-exercises 3.0.125 → 3.0.126

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

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    points: number[][];
+    parties: Party[];
+    alliances: Alliance[];
+};
+type Party = {
+    name: string;
+    color: string;
+    p: number;
+};
+type Alliance = {
+    parties: Party[];
+    p: number;
+};
+export declare const halfPieChartCommenting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=halfPieChartCommenting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"halfPieChartCommenting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/halfPieChartCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,OAAO,EAAE,KAAK,EAAE,CAAC;IACjB,SAAS,EAAE,QAAQ,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,KAAK,GAAG;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,KAAK,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6PF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

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

@@ -0,0 +1,228 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { blueDark, blueExtraDark, colorWithOpacity, greenMain, orange, pinkLight, red, } from "../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../math/geometry/point.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { decapitalize } from "../../../utils/strings/decapitalize.js";
+import { getLetter } from "../../../utils/strings/getLetter.js";
+const allParties = [
+    ["Parti rouge", red],
+    ["Parti vert", greenMain],
+    ["Parti rose", pinkLight],
+    ["Parti orange", orange],
+    ["Parti gris", "#C0C0C0"],
+    ["Parti bleu", blueDark],
+    ["Parti bleu foncé", blueExtraDark],
+    ["Parti brun", "#8B4513"],
+];
+const getNameForAlliance = (alliance) => {
+    if (alliance.parties.length > 1) {
+        const frColors = alliance.parties.map((party) => party.name.slice(6));
+        return `Coalition ${frColors.join("-")}`;
+    }
+    else {
+        return alliance.parties[0].name;
+    }
+};
+const getPropositions = (n, { alliances }) => {
+    const propositions = [];
+    alliances.forEach((alliance) => {
+        const name = getNameForAlliance(alliance);
+        if (alliance.p > 0.5) {
+            addValidProp(propositions, name, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, name, "raw");
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getInstruction = () => {
+    return `Voici le diagramme semi-circulaire indiquant la composition d'un parlement. 
+  
+Parmi les partis et coalitions proposés, lesquels détiennent la majorité absolue ?`;
+};
+const getHint = () => {
+    return `Pour avoir une majorité absolue, un parti ou une coalition doit détenir plus de $50\\%$ des sièges.
+
+On voit que les coalitions se font entre partis adjacents sur l'hémicycle.`;
+};
+const getCorrection = (identifiers) => {
+    const { alliances } = identifiers;
+    return `Pour avoir une majorité absolue, un parti ou une coalition doit détenir plus de $50\\%$ des sièges.
+
+C'est-à-dire que le parti ou la coalition doit être représenté(e) par plus d'un quart de disque.
+
+C'est le cas pour ${(() => {
+        const alliancesWithMajority = alliances.filter((alliance) => alliance.p > 0.5);
+        const names = alliancesWithMajority.map((alliance) => {
+            const laLe = alliance.parties.length > 1 ? "la" : "le";
+            return `${laLe} ${decapitalize(getNameForAlliance(alliance))}`;
+        });
+        return `${names.length > 1 ? `${names.slice(0, -1).join(", ")} et` : ``} ${names.slice(-1)}`;
+    })()}
+.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { points, parties } = identifiers;
+    const labels = parties.map((party) => party.name);
+    const colors = parties.map((party) => party.color);
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const getMidPoint = (nextPoint, prevPoint) => {
+        const [xA, yA] = prevPoint;
+        const angleA = Math.atan2(yA, xA);
+        const [xB, yB] = nextPoint;
+        const angleB = Math.atan2(yB, xB);
+        // const angleM = (angleA + angleB) / 2;
+        const angleM = angleA +
+            Math.atan2(Math.sin(angleB - angleA), Math.cos(angleB - angleA)) / 2;
+        return [0.8 * Math.cos(angleM), 1.2 * Math.sin(angleM)];
+    };
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `C = CircularSector((0,0), (1,0), (-1,0))`,
+            `SetFixed(C, true)`,
+            `SetLineThickness(C, 1)`,
+            // `SetVisibleInView(C, 1, false)`,
+            // ...pointsObj.flatMap((p) => p.toGGBCommand()),
+            ...pointsObj.slice(0, -1).flatMap((p, i) => {
+                const midPoint = getMidPoint(points[(i + 1 + points.length) % points.length], points[i]);
+                return [
+                    `C_${i} = CircularSector((0,0), ${pointsObj[(i + 1 + pointsObj.length) % pointsObj.length].toMathString()}, ${p.toMathString()})`,
+                    `SetFixed(C_${i}, true)`,
+                    `SetColor(C_${i}, "${colorWithOpacity(colors[i], 80)}")`,
+                    `SetLineThickness(C_${i}, 0)`,
+                    // `SetCaption(C_${i}, "$\\tiny \\text{${labels[i]}}$")`,
+                    // `ShowLabel(C_${i}, true)`,
+                    // `Text("$\\tiny \\text{${labels[i]
+                    //   .split(" ")
+                    //   .join("\\\\")}}$", (${getMidPoint(
+                    //   points[(i + 1 + points.length) % points.length],
+                    //   points[i],
+                    // ).join(",")}), true, true, 1, 0)`,
+                    `Text("$\\tiny \\text{${labels[i]}}$", (${[
+                        midPoint[0],
+                        midPoint[1],
+                    ].join(",")}), true, true, 0, 0)`,
+                ];
+            }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.0, 1.0, -0.2, 1.4],
+    });
+};
+const getHalfPieChartReadingQuestion = () => {
+    let question;
+    let counter = 0;
+    const counterMax = 100;
+    while (counter < counterMax && !question) {
+        try {
+            question = getHalfPieChartReadingQuestionCandidate();
+        }
+        catch (_) {
+            continue;
+        }
+        counter++;
+    }
+    if (counter === counterMax) {
+        throw new Error("should-throw whileLoop: counter === counterMax");
+    }
+    return question;
+};
+const getHalfPieChartReadingQuestionCandidate = () => {
+    const nbPartiesPicked = randint(4, 7);
+    const getPointFromPrev = (prevPoint, degAngle) => {
+        const radAngle = -(degAngle * Math.PI) / 180;
+        return [
+            round(prevPoint[0] * Math.cos(radAngle) - prevPoint[1] * Math.sin(radAngle), 6),
+            round(prevPoint[0] * Math.sin(radAngle) + prevPoint[1] * Math.cos(radAngle), 6),
+        ];
+    };
+    const angles = [randint(9, 100)];
+    for (let i = 0; i < nbPartiesPicked - 1; i++) {
+        const remaining = 180 - angles.reduce((acc, curr) => acc + curr);
+        if (i === nbPartiesPicked - 2)
+            angles.push(remaining);
+        else
+            angles.push(randint(15, Math.min(50, remaining - 15)));
+    }
+    const points = [[-1, 0]];
+    for (let i = 0; i < angles.length; i++) {
+        points.push(getPointFromPrev(points[i], angles[i]));
+    }
+    const parties = randomMany(allParties.map(([label, color], i) => [i, label, color]), nbPartiesPicked)
+        .toSorted(([i1], [i2]) => i1 - i2)
+        .map(([_, label, color], i) => {
+        return { name: label, color, p: angles[i] / 180 };
+    });
+    const nbPartiesInAllianceMin = 1;
+    const nbPartiesInAllianceMax = nbPartiesPicked - 1;
+    const alliancePool = [];
+    for (let i = 0; i < nbPartiesPicked; i++) {
+        for (let j = nbPartiesInAllianceMin; j < nbPartiesInAllianceMax && i + j <= nbPartiesPicked; j++) {
+            const allianceParties = parties.slice(i, i + j);
+            const alliance = {
+                parties: allianceParties,
+                p: allianceParties.reduce((acc, party) => acc + party.p, 0),
+            };
+            alliancePool.push(alliance);
+        }
+    }
+    const nbAlliances = 4;
+    let alliances = [];
+    let isAtLeastOneMajority = false;
+    let counter = 0;
+    const counterMax = 100;
+    while (counter < counterMax && !isAtLeastOneMajority) {
+        alliances = randomMany(alliancePool, nbAlliances);
+        isAtLeastOneMajority = alliances.some((alliance) => alliance.p > 0.5);
+        counter++;
+    }
+    if (counter === counterMax) {
+        throw new Error("should-throw whileLoop: counter === counterMax");
+    }
+    const identifiers = {
+        points,
+        parties,
+        alliances,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const halfPieChartCommenting = {
+    id: "halfPieChartCommenting",
+    label: "Commenter un diagramme semi-circulaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHalfPieChartReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"halfPieChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/halfPieChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAsOF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

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

@@ -0,0 +1,213 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { blueExtraDark, colorWithOpacity, greenDark, orange, pinkDark, purpleDark, red, } from "../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../math/geometry/angle.js";
+import { Point } from "../../../math/geometry/point.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+import { getLetter } from "../../../utils/strings/getLetter.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    tryToAddWrongProp(propositions, angleValue.frenchify() + "\\%");
+    tryToAddWrongProp(propositions, `${round(100 / (points.length - 1), 1)}\\%`);
+    tryToAddWrongProp(propositions, round((angleValue * 100) / 180, 2).frenchify() + "\\%");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(8, 80, 2).frenchify() + "\\%");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    return round((angleValue * 100) / 180, 2).frenchify() + "\\%";
+};
+const getInstruction = () => {
+    return `Ci-dessous est donnée la répartition des communications effectuées par des lycéens avec leur téléphone portable. 
+  
+Quelle proportion des communications effectuées, les communications audio représentent-elles ?
+  
+Arrondir au centième de pourcentage.`;
+};
+const getHint = (identifiers) => {
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    return `Dans un diagramme circulaire, une proportion de $100\\%$ représente $180^{\\circ}$. 
+  
+On utilise donc un produit en croix pour déterminer la proportion représentée par $${angleValue}^{\\circ}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { points } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const angleValue = angle.evaluate();
+    return `Dans un diagramme circulaire, une proportion de $100\\%$ représente $180^{\\circ}$. 
+  
+On utilise donc un produit en croix pour déterminer la proportion représentée par $${angleValue}^{\\circ}$ : 
+
+$$
+${angleValue} \\times \\frac{100}{180} ${approxOrEqual((angleValue * 100) / 180, 2).join("")}
+$$
+
+Les communications audio représentent donc $${getAnswer(identifiers)}$ des communications effectuées.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { points, labels } = identifiers;
+    const pointsObj = points.map((p, i) => new Point(getLetter(i, true), p[0], p[1]));
+    // const reversedPoints = pointsObj.reverse();
+    const colors = [greenDark, orange, pinkDark, purpleDark, red];
+    const angle = new Angle([pointsObj[1], new Point("O", 0, 0), pointsObj[0]]);
+    const getMidPoint = (nextPoint, prevPoint) => {
+        const [xA, yA] = prevPoint;
+        const angleA = Math.atan2(yA, xA);
+        const [xB, yB] = nextPoint;
+        const angleB = Math.atan2(yB, xB);
+        // const angleM = (angleA + angleB) / 2;
+        const angleM = angleA +
+            Math.atan2(Math.sin(angleB - angleA), Math.cos(angleB - angleA)) / 2;
+        return [1.2 * Math.cos(angleM), 1.2 * Math.sin(angleM)];
+    };
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `C = CircularSector((0,0), (1,0), (-1,0))`,
+            `SetFixed(C, true)`,
+            `SetLineThickness(C, 1)`,
+            // `SetVisibleInView(C, 1, false)`,
+            // ...pointsObj.flatMap((p) => p.toGGBCommand()),
+            ...pointsObj.slice(0, -1).flatMap((p, i) => {
+                const midPoint = getMidPoint(points[(i + 1 + points.length) % points.length], points[i]);
+                return [
+                    `C_${i} = CircularSector((0,0), ${pointsObj[(i + 1 + pointsObj.length) % pointsObj.length].toMathString()}, ${p.toMathString()})`,
+                    `SetFixed(C_${i}, true)`,
+                    `SetColor(C_${i}, "${colorWithOpacity(colors[i], 80)}")`,
+                    `SetLineThickness(C_${i}, 0)`,
+                    // `SetCaption(C_${i}, "$\\tiny \\text{${labels[i]}}$")`,
+                    // `ShowLabel(C_${i}, true)`,
+                    // `Text("$\\tiny \\text{${labels[i]
+                    //   .split(" ")
+                    //   .join("\\\\")}}$", (${getMidPoint(
+                    //   points[(i + 1 + points.length) % points.length],
+                    //   points[i],
+                    // ).join(",")}), true, true, 1, 0)`,
+                    `Text("$\\tiny \\text{${labels[i].split(" ").join("\\\\")}}$", (${[
+                        midPoint[0] + (i === 0 ? 0.3 : 0),
+                        midPoint[1],
+                    ].join(",")}), true, true, 0, 0)`,
+                ];
+            }),
+            ...angle.toCommands({
+                showValue: points[1][0] === 1 ? false : true,
+                pointsAreNotBuilt: true,
+                thickness: 1,
+                color: blueExtraDark,
+            }),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.0, 1.0, -0.2, 1.4],
+    });
+};
+const getKeys = () => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        //!à factoriser
+        //!pb est que parseAlgebraic ne gère pas encore les %
+        let parsed;
+        if (ans.includes("%")) {
+            parsed = percentParser(ans);
+            return parsed === answer;
+        }
+        else {
+            parsed = parseAlgebraic(ans);
+            const nbAns = answer.replace("\\%", "").unfrenchify();
+            return Math.abs(parsed.evaluate() - nbAns / 100) < 0.0001;
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getHalfPieChartReadingQuestion = () => {
+    const labels = [
+        "communications audio",
+        "communications vidéo",
+        "messagerie électronique",
+        "autre",
+        "messages SMS",
+    ];
+    const getPointFromPrev = (prevPoint, degAngle) => {
+        const radAngle = -(degAngle * Math.PI) / 180;
+        return [
+            round(prevPoint[0] * Math.cos(radAngle) - prevPoint[1] * Math.sin(radAngle), 6),
+            round(prevPoint[0] * Math.sin(radAngle) + prevPoint[1] * Math.cos(radAngle), 6),
+        ];
+    };
+    const angles = [5 * randint(6, 15)];
+    for (let i = 0; i < labels.length - 1; i++) {
+        const remaining = 180 - angles.reduce((acc, curr) => acc + curr);
+        if (i === labels.length - 2)
+            angles.push(remaining);
+        else
+            angles.push(randint(15, Math.min(50, remaining - 15)));
+    }
+    const points = [[-1, 0]];
+    for (let i = 0; i < angles.length; i++) {
+        points.push(getPointFromPrev(points[i], angles[i]));
+    }
+    const identifiers = {
+        labels,
+        points,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const halfPieChartReading = {
+    id: "halfPieChartReading",
+    label: "Convertir un angle en pourcentage dans un diagramme semi-circulaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHalfPieChartReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"histogramReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/histogramReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoLF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAmBlD,CAAC"}

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

@@ -0,0 +1,163 @@
+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 { frenchify } from "../../../math/utils/latex/frenchify.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../utils/alea/random.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { data } = identifiers;
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(data).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { data, itemAsked } = identifiers;
+    return data[itemAsked].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { bounds, itemAsked } = identifiers;
+    const labels = bounds.map(frenchify);
+    return `Un producteur trie sa récolte de pommes selon leur diamètre. L'histogramme ci-dessous représente ses résultats.
+
+Combien de pommes de diamètre entre $${labels[itemAsked]}$ et $${labels[itemAsked + 1]}\\ \\textrm{cm}$  le producteur a-t-il récoltées ?
+`;
+};
+const getHint = () => {
+    return `Dans un histogramme, l'effectif d'une classe est donné par l'aire du rectangle
+compris entre les deux bornes de la classe.`;
+};
+const getCorrection = (identifiers) => {
+    const { bounds, data, itemAsked } = identifiers;
+    const labels = bounds.map(frenchify);
+    const upperBound = bounds[itemAsked + 1];
+    const lowerBound = bounds[itemAsked];
+    const nodeWidth = substract(upperBound, lowerBound).simplify();
+    const nodeHeight = frac(data[itemAsked], nodeWidth).simplify();
+    const isLastClass = itemAsked == data.length;
+    return `Ici la classe est [$${labels[itemAsked]}$;$${labels[itemAsked + 1]}$${isLastClass ? "]" : "["}.
+Pour trouver l'effectif, on calcule l'aire du rectangle pour cette classe, 
+autrement dit le produit largeur $\\times$ hauteur.
+La largeur est l'étendue de la classe.
+${alignTex(`${upperBound} - ${lowerBound} = ${nodeWidth.toTex()}`)}
+Pour la hauteur, on lit $${nodeHeight.toTex()}$.
+${alignTex(`${nodeWidth.toTex()} \\times ${nodeHeight.toTex()} = ${data[itemAsked]}`)}
+Le producteur produit $${data[itemAsked]}$ pommes de diamètre entre $${lowerBound.frenchify()}$ et $${upperBound.frenchify()}\\ \\textrm{cm}$.
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { bounds, data } = identifiers;
+    const heights = [];
+    for (let i = 0; i < data.length; i++) {
+        const width = bounds[i + 1] - bounds[i];
+        const height = data[i] / width;
+        heights.push(height);
+    }
+    const offsetX = -bounds[0] + 1;
+    const offsettedBounds = bounds.map((bound) => bound + offsetX);
+    // const xMin = offsettedBounds[0];
+    const xMax = offsettedBounds[offsettedBounds.length - 1];
+    const heightMin = 0;
+    const heightMax = Math.max(...heights);
+    const commands = [
+        `B = Histogram({${offsettedBounds}}, {${heights.join(",")}})`,
+        ...bounds.map((bound, i) => `Text("\\footnotesize ${bound.frenchify()}", (${offsettedBounds[i]}, 50), true, true, 0, -1)`),
+        `Text("\\footnotesize Diamètre\\ (en \\ cm)", (3, -300), true, true, 0, -1)`,
+        `ShowLabel(B,false)`,
+        `SetColor(B, "#FE0045AB")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        gridDistance: [10000, 50],
+        fontSize: 16,
+        lockedAxesRatio: false,
+        xAxis: {
+            hideNumbers: true,
+            showPositive: true,
+            // hidden: true,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Pommes/cm$",
+            steps: 100,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -1,
+            xMax: xMax + 1,
+            yMin: heightMin - 1000,
+            yMax: heightMax + 300,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getHistogramReadingQuestion = () => {
+    const data = [];
+    const bounds = [11.5, 12, 13.5, 15, 15.5, 16, 16.2];
+    for (let i = 0; i < bounds.length - 1; i++) {
+        const nodeWidth = substract(bounds[i + 1], bounds[i]);
+        let dataI;
+        let isHeightAnInteger;
+        do {
+            dataI =
+                50 *
+                    randint(1, i < 3 ? 18 : 20, //pour ne pas que les 2 premieres barres touchent le label de l'axe
+                    data.map((d) => d / 50));
+            isHeightAnInteger = !frac(dataI, nodeWidth)
+                .simplify()
+                .toTex()
+                .includes("frac");
+        } while (!isHeightAnInteger);
+        data.push(dataI);
+    }
+    const itemAsked = randint(0, bounds.length - 1);
+    const identifiers = {
+        bounds,
+        data,
+        itemAsked,
+    };
+    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 histogramReading = {
+    id: "histogramReading",
+    label: "Lire les effectifs sur un histogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHistogramReadingQuestion(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,7 +2,17 @@ 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";
 //# 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;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,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,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}