math-exercises 3.0.213 → 3.0.215

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

@@ -0,0 +1,521 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetGGBOptions,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+//   GeneratorOption,
+//   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";
+export {};
+// const _degreesToRadians = (angleInDegrees: number, precision: number) => {
+//   const oneOver180 = 0.00555555555555555;
+//   return round(
+//     multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(),
+//     precision,
+//   );
+// };
+// const rotateVector = (vec: Vector, angle: number, name: string) => {
+//   //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: Point,
+//   angle: number,
+//   center: Point,
+//   name: string,
+//   precision: number | undefined = 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: Point,
+//   to: Point,
+//   name: string,
+//   precision: number | undefined = 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: number,
+//   y: number,
+//   name: string,
+//   precision: number | undefined = 5,
+// ) => {
+//   return new Point(name, round(x, precision), round(y, precision));
+// };
+// /************/
+// type Time = {
+//   hours: number;
+//   minutes: number;
+// };
+// type Identifiers = {
+//   time1: Time;
+//   time2?: Time;
+//   duration?: Time;
+//   qType: string;
+//   opType: string;
+//   timeDisplayType1: string;
+//   timeDisplayType2: string;
+// };
+// const getHydrated = (identifiers: Identifiers) => {
+//   const { time1, time2, duration, qType, opType } = identifiers;
+//   const dictHydratedClock = (() => {
+//     const {hours, minutes} = timeOnClock;
+//     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,
+//       };
+//   })();
+//   function createStrTime(time: Time) {
+//     const {hours, minutes} = time;
+//     const strHour = hours === 24 ? `0` : `${hours}`;
+//     const strMinutes = (() => {
+//       if (minutes < 10) {
+//         return `0${minutes}`;
+//       } else {
+//         return `${minutes}`;
+//       }
+//     })();
+//     return `${strHour}h${strMinutes}`;
+//   }
+//   const [strTimeOnClock, strTime2] = [timeOnClock, time2].map(createStrTime);
+//   return {
+//     dictHydratedClock,
+//     strTimeOnClock,
+//     strTime2,
+//   };
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const { opType } = identifiers;
+//   const { strTime2 } = getHydrated(identifiers);
+//   switch (opType) {
+//     case "addition": {
+//       return `Quand je suis parti dehors, il était ${strTime2}`
+//     }
+//     case "soustraction": {
+//     }
+//     default:
+//       throw new Error("Unsupported qType: " + qType);
+//   }
+//   return `Quelle est l'heure affichée sur l'horloge ? ${(() => {
+// };
+// const getAnswer: GetAnswer<Identifiers> = (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: GetHint<Identifiers> = () => {
+//   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: GetCorrection<Identifiers> = (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: GetGGBOptions<Identifiers> = (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)`,
+//         ];
+//       })(),
+//       ...(() => {
+//         const [pointA, pointB] = arrPointNeedleMinutes;
+//         return [
+//           `segNeedleMinutes = Segment(${pointA.toMathString()}, ${pointB.toMathString()})`,
+//           `SetLineThickness(segNeedleMinutes, 10)`,
+//         ];
+//       })(),
+//     ],
+//     hideAxes: true,
+//     hideGrid: true,
+//     forbidShiftDragZoom: true,
+//   });
+//   return ggb.getOptions({
+//     coords: [-1.4, 1.4, -1.4, 1.4],
+//   });
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (
+//   n,
+//   { answer, ...identifiers },
+// ) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   //student: one hour more
+//   {
+//     if (identifiers.minutes >= 30) {
+//       const identifiersWrong: Identifiers = {
+//         hours: identifiers.hours + 1,
+//         minutes: identifiers.minutes,
+//       };
+//       tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+//     }
+//   }
+//   //student: hours<->minutes
+//   {
+//     const identifiersWrong: Identifiers = {
+//       hours: identifiers.minutes / 5,
+//       minutes: (identifiers.hours % 12) * 5,
+//     };
+//     tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+//   }
+//   //student: am<->pm
+//   {
+//     const identifiersWrong: Identifiers = {
+//       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: GetKeys<Identifiers> = () => {
+//   return ["h"];
+// };
+// const isAnswerValid: VEA<Identifiers> = (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: string) => {
+//   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: Identifiers = {
+//     hours,
+//     minutes,
+//   };
+//   return identifiers;
+// };
+// const getClockReadingPlusTimeOperationQuestion: QuestionGenerator<
+//   Identifiers,
+//   Options
+// > = (optsIn) => {
+//   const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+//   const arrAMPMType = arrayedOpts.amPmType;
+//   function drawAMPMType(arrAMPMType: string[]) {
+//     if (arrAMPMType.length === 1) {
+//       const [amPmType] = arrAMPMType;
+//       return amPmType;
+//     } else {
+//       let amPmType: string | undefined;
+//       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: GetQuestionFromIdentifiers<
+//   Identifiers,
+//   Options
+// > = (identifiers) => {
+//   const question: Question<Identifiers, Options> = {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//     ggbOptions: getGGBOptions(identifiers),
+//   };
+//   return question;
+// };
+// type Options = {
+//   amPmType: string;
+//   qType: string;
+//   opType: string;
+// };
+// type ArrayedOptions = {
+//   readonly [K in keyof Options]: Options[K] extends unknown[]
+//     ? Options[K]
+//     : Options[K][];
+// };
+// const arrayedOptsDefault: ArrayedOptions = {
+//   amPmType: ["AM", "midi"],
+//   opType: ["addition", "soustraction"],
+//   time1Type: ["horloge", "texte"],
+//   time2Type: ["horloge", "texte"],
+// };
+// const options: GeneratorOption[] = [
+//   {
+//     id: "amPmType1",
+//     label: "Type de plage horaire pour l'horloge",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     values: ["AM", "midi", "PM", "minuit"],
+//     defaultValue: arrayedOptsDefault.amPmType,
+//   },
+//   {
+//     id: "amPmType2",
+//     label: "Type de plage horaire pour l'autre heure",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     values: ["AM", "midi", "PM", "minuit"],
+//     defaultValue: arrayedOptsDefault.amPmType,
+//   },
+//   {
+//     id: "opType",
+//     label: "opération",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     values: ["addition", "soustraction"],
+//     defaultValue: arrayedOptsDefault.opType,
+//   },
+//   {
+//     id: "opType",
+//     label: "opération",
+//     target: GeneratorOptionTarget.generation,
+//     type: GeneratorOptionType.multiselect,
+//     values: ["addition", "soustraction"],
+//     defaultValue: arrayedOptsDefault.opType,
+//   },
+// ];
+// export const clockReadingPlusTimeOperation: Exercise<Identifiers, Options> = {
+//   id: "clockReadingPlusTimeOperation",
+//   label: "Lire l'heure sur une horloge et effectuer une opération",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(
+//       () => getClockReadingPlusTimeOperationQuestion(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/clockWritingByManipulatingNeedles.d.ts

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

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

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