math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/conversion/clock/clockReading.js

@@ -0,0 +1,385 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const _degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const getHydrated = (identifiers) => {
+    const { hours, minutes } = identifiers;
+    const isExactlyNoon = hours === 12 && minutes === 0;
+    const strAMPM = (() => {
+        if (minutes !== 0) {
+            if (hours < 12) {
+                return "Nous sommes avant midi";
+            }
+            else {
+                return "Nous sommes après midi";
+            }
+        }
+        else {
+            if (hours === 0) {
+                return "Nous sommes avant midi (il n'est pas midi).";
+            }
+            else if (hours === 24) {
+                return "Nous sommes après midi (il n'est pas midi).";
+            }
+            else {
+                return "Nous sommes en pleine journée.";
+            }
+        }
+    })();
+    const duodecHours = hours > 12 ? hours - 12 : hours;
+    const duodecMinutes = minutes / 5;
+    const angleMinutes = (Math.PI / 6.0) * duodecMinutes;
+    const angleHours = 2 * Math.PI * (((hours + minutes / 60) / 12.0) % 1);
+    return {
+        strAMPM,
+        isExactlyNoon,
+        duodecHours,
+        duodecMinutes,
+        angleHours,
+        angleMinutes,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { strAMPM, isExactlyNoon } = getHydrated(identifiers);
+    return `Quelle est l'heure affichée sur l'horloge ? ${(() => {
+        if (isExactlyNoon) {
+            return "";
+        }
+        else {
+            return `Indication : ${strAMPM}`;
+        }
+    })()}`;
+};
+const getAnswer = (identifiers) => {
+    const { hours, minutes } = identifiers;
+    const strMinutes = (() => {
+        if (minutes < 10) {
+            return `0${minutes}`;
+        }
+        else {
+            return `${minutes}`;
+        }
+    })();
+    return `${hours === 24 ? "0" : hours}h${strMinutes}`;
+};
+const getHint = () => {
+    return `L'aiguille des heures est l'aiguille la plus courte. 
+Avant midi, les heures vont de $0$ à $11$. Après midi, les heures vont de $12$ à $23$.
+Les graduations des minutes vont de $0$ à $55$ (de $5$ en $5$).`;
+};
+const getCorrection = (identifiers) => {
+    const { hours, minutes } = identifiers;
+    const { duodecHours, duodecMinutes } = getHydrated(identifiers);
+    const strMinutes = (() => {
+        if (minutes < 10) {
+            return `0${minutes}`;
+        }
+        else {
+            return `${minutes}`;
+        }
+    })();
+    if (minutes !== 0) {
+        if (hours < 12) {
+            return `Nous sommes avant midi. 
+L'aiguille des heures est entre $${duodecHours}$ et $${duodecHours + 1}$.
+
+Il est donc $${hours}h...$
+
+L'aiguille des minutes est sur la graduation $${duodecMinutes}$.
+
+$$
+${duodecMinutes} \\times 5 = ${minutes}
+$$
+
+Il est donc $${hours}h${strMinutes}$.
+
+`;
+        }
+        else if (hours > 12) {
+            return `Nous sommes après midi. 
+L'aiguille des heures est entre $${duodecHours}$ et $${duodecHours + 1}$.
+
+$$
+12 + ${duodecHours} = ${hours}
+$$
+
+Il est donc $${hours}h...$
+
+L'aiguille des minutes est sur la graduation $${duodecMinutes}$.
+
+$$
+${duodecMinutes} \\times 5 = ${minutes}
+$$
+
+Il est donc $${hours}h${strMinutes}$.
+
+`;
+        }
+        else {
+            return "Il est exactement midi ($12h00$).";
+        }
+    }
+    else {
+        if (hours === 0) {
+            return `Il est exactement minuit ($0h00$).`;
+        }
+        else if (hours === 24) {
+            return `Il est exactement minuit ($0h00$) (on passe dans le jour suivant donc on n'écrit pas "$24h00$").`;
+        }
+        else {
+            return `Il est exactement $${hours}h00$.`;
+        }
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { angleHours, angleMinutes } = getHydrated(identifiers);
+    const pointOrigin = new Point("O", 0, 0);
+    //ticks
+    const arrPointTickTop = [
+        PointConstructor.fromCoords([0, 0.8], "tickTopA"),
+        PointConstructor.fromCoords([0, 1], "tickTopB"),
+    ];
+    const arrArrPointTick = [...Array(12).keys()].map((i) => {
+        const angle = (i * Math.PI) / 6;
+        return arrPointTickTop.map((point, j) => rotatePoint(point, angle, pointOrigin, `tick${i}${j === 0 ? "A" : "B"}`));
+    });
+    //needles
+    const arrPointNeedleHours = [
+        PointConstructor.fromCoords([0, 0], "needleHoursTopA"),
+        PointConstructor.fromCoords([0, 0.5], "needleHoursTopB"),
+    ].map((point, j) => rotatePoint(point, -angleHours, pointOrigin, `needleHours${j === 0 ? "A" : "B"}`));
+    const arrPointNeedleMinutes = [
+        PointConstructor.fromCoords([0, 0], "needleMinutesTopA"),
+        PointConstructor.fromCoords([0, 0.75], "needleMinutesTopB"),
+    ].map((point, j) => rotatePoint(point, -angleMinutes, pointOrigin, `needleHours${j === 0 ? "A" : "B"}`));
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `C = Circle((0,0), 1)`,
+            `SetFixed(C, true, false)`,
+            `SetLineThickness(C, 1)`,
+            //ticks
+            ...arrArrPointTick.flatMap(([pointA, pointB], i) => [
+                `segTick${i} = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+                `SetLineThickness(segTick${i}, ${i === 0 ? "6" : "2"})`,
+                `SetFixed(segTick${i}, true, false)`,
+            ]),
+            //needles
+            ...(() => {
+                const [pointA, pointB] = arrPointNeedleHours;
+                return [
+                    `segNeedleHours = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+                    `SetLineThickness(segNeedleHours, 20)`,
+                    `SetFixed(segNeedleHours, true, false)`,
+                ];
+            })(),
+            ...(() => {
+                const [pointA, pointB] = arrPointNeedleMinutes;
+                return [
+                    `segNeedleMinutes = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+                    `SetLineThickness(segNeedleMinutes, 10)`,
+                    `SetFixed(segNeedleMinutes, true, false)`,
+                ];
+            })(),
+        ],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.4, 1.4, -1.4, 1.4],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: one hour more
+    {
+        if (identifiers.minutes >= 30) {
+            const identifiersWrong = {
+                hours: identifiers.hours + 1,
+                minutes: identifiers.minutes,
+            };
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        }
+    }
+    //student: hours<->minutes
+    {
+        const identifiersWrong = {
+            hours: identifiers.minutes / 5,
+            minutes: (identifiers.hours % 12) * 5,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    //student: am<->pm
+    {
+        const identifiersWrong = {
+            hours: identifiers.hours < 12
+                ? identifiers.hours + 12
+                : identifiers.hours - 12,
+            minutes: identifiers.minutes,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    propWhile(propositions, n, () => {
+        const amPmType = random(["AM", "midi", "PM", "minuit"]);
+        const identifiersWrong = createRandomIdentifiers(amPmType);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["h"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        if (!ans.includes("h")) {
+            return false;
+        }
+        const [hoursAns, minutesAns] = ans.split("h").map((str) => parseInt(str));
+        const { hours, minutes } = identifiers;
+        return zip([hoursAns, minutesAns], [hours === 24 ? 0 : hours, minutes]).every(([ans, answer]) => ans === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (amPmType) => {
+    const [hours, minutes] = (() => {
+        switch (amPmType) {
+            case "AM": {
+                const hours = randint(0, 12);
+                const minutes = randint(1, 12) * 5;
+                return [hours, minutes];
+            }
+            case "midi": {
+                return [12, 0];
+            }
+            case "PM": {
+                const hours = randint(12, 23);
+                const minutes = randint(1, 12) * 5;
+                return [hours, minutes];
+            }
+            case "minuit": {
+                return random([
+                    [0, 0],
+                    [24, 0],
+                ]);
+            }
+            default:
+                throw new Error("Unsupported typeAMPM: " + amPmType);
+        }
+    })();
+    const identifiers = {
+        hours,
+        minutes,
+    };
+    return identifiers;
+};
+const getClockReadingQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const arrAMPMType = arrayedOpts.amPmType;
+    function drawAMPMType(arrAMPMType) {
+        if (arrAMPMType.length === 1) {
+            const [amPmType] = arrAMPMType;
+            return amPmType;
+        }
+        else {
+            let amPmType;
+            do {
+                const amPmTypeDrawn = probaLawFlip([
+                    ["AM", 0.4],
+                    ["midi", 0.1],
+                    ["PM", 0.4],
+                    ["minuit", 0.1],
+                ]);
+                if (arrAMPMType.includes(amPmTypeDrawn)) {
+                    amPmType = amPmTypeDrawn;
+                }
+            } while (!amPmType);
+            return amPmType;
+        }
+    }
+    const amPmType = drawAMPMType(arrAMPMType);
+    const identifiers = createRandomIdentifiers(amPmType);
+    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;
+};
+const arrayedOptsDefault = {
+    amPmType: ["AM", "midi"],
+};
+const options = [
+    {
+        id: "amPmType",
+        label: "Type de plage horaire",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["AM", "midi", "PM", "minuit"],
+        defaultValue: arrayedOptsDefault.amPmType,
+    },
+];
+export const clockReading = {
+    id: "clockReading",
+    label: "Lire l'heure sur une horloge",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getClockReadingQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/conversion/clock/clockReadingPlusTimeOperation.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=clockReadingPlusTimeOperation.d.ts.map

package/lib/exercises/math/conversion/clock/clockReadingPlusTimeOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clockReadingPlusTimeOperation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/clockReadingPlusTimeOperation.ts"],"names":[],"mappings":""}