math-exercises 3.0.69 → 3.0.71

package/lib/exercises/pc/motion/typeOfMovement.js

@@ -1,55 +1,27 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
-import { AffineConstructor } from "../../../math/polynomials/affine.js";
+import { Affine, AffineConstructor } from "../../../math/polynomials/affine.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
-const getTypeOfMovementQuestion = () => {
-    const exo = generateExercise();
-    const ggb = exo.ggb;
-    const question = {
-        answer: exo.answer,
-        instruction: exo.instruction,
-        ggbOptions: ggb.getOptions({
-            coords: exo.coords,
-        }),
-        keys: [],
-        answerFormat: "raw",
-        identifiers: { movementType: exo.answer, ggbCommands: ggb.commands },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer, "raw");
-    tryToAddWrongProp(propositions, "Rectiligne", "raw");
-    tryToAddWrongProp(propositions, "Circulaire", "raw");
-    tryToAddWrongProp(propositions, "Curviligne", "raw");
-    tryToAddWrongProp(propositions, "On ne peut pas savoir.", "raw");
-    return shuffleProps(propositions, n);
-};
-const generateExercise = () => {
-    const movementType = random(["Rectiligne", "Circulaire", "Curviligne"]);
-    const ggb = getGgb(movementType);
-    const instruction = `Soit le graphique ci-dessous, représentant la position d'un objet en fonction du temps. \n \\
+const getInstruction = (identifiers) => {
+    const instruction = `Soit le graphique ci-dessous, représentant la position d'un objet en fonction du temps.
+
 Déterminer le type de mouvement de l'objet.`;
-    return {
-        instruction,
-        answer: movementType,
-        movementType,
-        ggb: ggb.ggb,
-        coords: ggb.coords,
-    };
+    return instruction;
 };
-const getGgb = (movementType) => {
+const getAnswer = (identifiers) => {
+    const { movementType } = identifiers;
+    return movementType;
+};
+const getGGBOptions = (identifiers) => {
+    const { movementType, a, b } = identifiers;
     let commands = [];
     let coords = [];
     let point1;
     let point2;
     switch (movementType) {
         case "Circulaire":
-            const a = randint(1, 5);
-            const b = randint(6, 9);
             commands = [
                 `Semicircle((${a},4),(${b},8))`,
                 `Point({${a},4})`,
@@ -59,46 +31,74 @@ const getGgb = (movementType) => {
             coords = [-2, 10, -2, 10];
             break;
         case "Rectiligne":
-            const affine = AffineConstructor.random({ min: 1, max: 4 }, { min: 1, max: 4 });
+            const affine = new Affine(a, b);
             point1 = `(2,${affine.calculate(2)})`;
             point2 = `(8,${affine.calculate(8)})`;
-            commands = [`Segment(${point1},${point2})`].concat(getPoints(movementType, { affine }));
+            commands = [`Segment(${point1},${point2})`];
+            for (let x = 3; x < 8; x++) {
+                commands.push(`Point({${x},${affine.calculate(x)}})`);
+            }
             coords = [-2, 10, -2, affine.calculate(8) + 5];
             break;
         case "Curviligne":
-            const random = randint(10, 21);
-            const bRand = randint(1, 5);
-            commands = [`Function(e^sin(x)+${bRand},0,${random})`].concat(getPoints(movementType, { bRand: bRand }));
+            commands = [`Function(e^sin(x)+${b},0,${a})`];
+            for (let x = 1; x < 9; x++) {
+                commands.push(`Point({${x},${Math.exp(Math.sin(x)) + b}})`);
+            }
             coords = [-2, 10, -2, 10];
             break;
     }
-    return {
-        ggb: new GeogebraConstructor({ commands }),
+    const ggb = new GeogebraConstructor({ commands });
+    return ggb.getOptions({
         coords,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
     };
+    return question;
 };
-const getPoints = (movementType, options) => {
-    const commands = [];
+const getTypeOfMovementQuestion = () => {
+    const movementType = random(["Rectiligne", "Circulaire", "Curviligne"]);
+    let a, b;
     switch (movementType) {
+        case "Circulaire":
+            a = randint(1, 5);
+            b = randint(6, 9);
+            break;
         case "Rectiligne":
-            for (let x = 3; x < 8; x++) {
-                commands.push(`Point({${x},${options.affine.calculate(x)}})`);
-            }
+            const affine = AffineConstructor.random({ min: 1, max: 4 }, { min: 1, max: 4 });
+            a = affine.a;
+            b = affine.b;
             break;
         case "Curviligne":
-            for (let x = 1; x < 9; x++) {
-                commands.push(`Point({${x},${Math.exp(Math.sin(x)) + options.bRand}})`);
-            }
+        default:
+            a = randint(10, 21);
+            b = randint(1, 5);
             break;
     }
-    return commands;
+    const identifiers = { movementType, a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Rectiligne", "raw");
+    tryToAddWrongProp(propositions, "Circulaire", "raw");
+    tryToAddWrongProp(propositions, "Curviligne", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir.", "raw");
+    return shuffleProps(propositions, n);
 };
 export const typeOfMovement = {
     id: "typeOfMovement",
     label: "Déterminer le type de mouvement",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getTypeOfMovementQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -106,4 +106,5 @@ export const typeOfMovement = {
     answerType: "QCU",
     subject: "Physique",
     hasGeogebra: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/orderOfMagnitude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderOfMagnitude.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/orderOfMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"orderOfMagnitude.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/orderOfMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/pc/orderOfMagnitude.js

@@ -7,17 +7,35 @@ import { Measure } from "../../pc/measure/measure.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { PowerNode } from "../../tree/nodes/operators/powerNode.js";
 const ten = new NumberNode(10);
-const getOrderOfMagnitudeQuestion = () => {
-    const exercise = generateExercise();
+const getInstruction = (identifiers) => {
+    const { order, multiplier } = identifiers;
+    const diameter = new Measure(multiplier, order, DistanceUnit.m);
+    const instruction = `Supposons qu'on ait un atome de diamètre $${diameter.toTex()}$. Indiquez l'ordre de grandeur du diamètre de cet atome.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { order, multiplier } = identifiers;
+    const answer = multiplier > 5
+        ? new PowerNode(ten, (order + 1).toTree())
+        : new PowerNode(ten, order.toTree());
+    return answer.toTex();
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: `${exercise.answer.toTex()}`,
-        instruction: exercise.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { order: exercise.order, multiplier: exercise.multiplier },
+        identifiers,
     };
     return question;
 };
+const getOrderOfMagnitudeQuestion = () => {
+    const order = randint(-15, -10);
+    const multiplier = +randfloat(1, 11).toFixed(1);
+    const identifiers = { order: order, multiplier: multiplier };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, order, multiplier }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -34,32 +52,15 @@ const generatePropositions = (order, multiplier) => {
     const third = new PowerNode(ten, correctAnswer.toTree()).toTex();
     return [first, second, third];
 };
-const generateExercise = () => {
-    const order = randint(-15, -10);
-    const multiplier = +randfloat(1, 11).toFixed(1);
-    const diameter = new Measure(multiplier, order, DistanceUnit.m);
-    const answer = multiplier > 5
-        ? new PowerNode(ten, (order + 1).toTree())
-        : new PowerNode(ten, order.toTree());
-    const instruction = `Supposons qu'on ait un atome de diamètre $${diameter.toTex()}$. Indiquez l'ordre de grandeur du diamètre de cet atome.`;
-    return {
-        answer,
-        order,
-        diameter,
-        multiplier,
-        instruction,
-    };
-};
 export const orderOfMagnitude = {
     id: "orderOfMagnitude",
     label: "Calcul d'ordre de grandeur",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Chimie organique"],
     generator: (nb) => getDistinctQuestions(getOrderOfMagnitudeQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
     subject: "Chimie",
 };

package/lib/exercises/pc/pH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAcpC,CAAC"}
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA2EF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -4,29 +4,51 @@ import { frenchify } from "../../math/utils/latex/frenchify.js";
 import { randint } from "../../math/utils/random/randint.js";
 import { round } from "../../math/utils/round.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
-const getpH = () => {
-    const randomNumber = randint(1, 10);
-    const randomTenPower = randint(2, 10);
+const getInstruction = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
+    const instruction = `Calculer le pH d'une solution ayant une concentration en ions hydrogène ($H^+$) de $${randomNumber} \\times 10^{-${randomTenPower}} \\ \\textrm{mol}/\\textrm{L}$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
     const concentrationHydrogene = randomNumber * 10 ** -randomTenPower;
-    const instruction = `Calculer le pH d'une solution ayant une concentration en ions hydrogène ($H^+$) de $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.`;
     const answer = frenchify(round(-Math.log10(concentrationHydrogene), 1));
-    const hint = "Utilisez la formule du pH : $\\text{pH} = -\\log[H^+]$.";
-    const correction = `Pour calculer le pH, on utilise la formule $\\text{pH} = -\\log[H^+]$ :
-  \n$1$. La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.
-  \n$2$. En appliquant la formule, on obtient $\\text{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
-  \n$3$. Le résultat est $${answer}$.`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const hint = "Utilise la formule du pH : $\\text{pH} = -\\log[H^+]$.";
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
+    const correction = `Pour calculer le pH, on utilise la formule $\\textrm{pH} = -\\log[H^+]$.
+  
+La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}\\ \\textrm{mol}/\\textrm{L}$.
+
+En appliquant la formule, on obtient $\\textrm{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
+
+Le résultat est $${getAnswer(identifiers)}$.`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: `pH`,
-        answer,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["logBrackets"],
         answerFormat: "tex",
-        identifiers: { randomNumber, randomTenPower },
+        identifiers,
     };
     return question;
 };
+const getpH = () => {
+    const randomNumber = randint(1, 10);
+    const randomTenPower = randint(2, 10);
+    const identifiers = { randomNumber, randomTenPower };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -46,8 +68,6 @@ export const pH = {
     id: "pH",
     connector: "=",
     label: "Calculer le pH d'une solution",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Acide / Base"],
     subject: "Chimie",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getpH, nb),
@@ -56,4 +76,5 @@ export const pH = {
     getPropositions,
     isAnswerValid,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/perceivedFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perceivedFrequency.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/perceivedFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"perceivedFrequency.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/perceivedFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EAIT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}

package/lib/exercises/pc/perceivedFrequency.js

@@ -6,24 +6,38 @@ import { round } from "../../math/utils/round.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
 const soundSpeed = 340; // Vitesse du son dans l'air en m/s
 const observerSpeed = 0; // La vitesse de l'observateur est supposée être nulle (observateur immobile)
-const getPerceivedFrequency = () => {
-    const frequencyEmitted = randint(200, 1500); // Fréquence émise en Hz
-    const ambulanceSpeed = Math.floor(Math.random() * 40 + 10); // Vitesse de l'ambulance entre 10 et 50 m/s
+const getInstruction = (identifiers) => {
+    const { frequencyEmitted, ambulanceSpeed } = identifiers;
+    return `Une ambulance émet un son d'une fréquence de $${frequencyEmitted}\\ \\textrm{Hz}$ lorsqu'elle
+  s'approche d'un observateur à une vitesse de $${ambulanceSpeed} \\ \\textrm{m}/\\textrm{s}$. 
+  
+La vitesse du son dans l'air est de $340 \\ \\textrm{m}/\\textrm{s}$. 
+  
+Calculer la fréquence perçue par l'observateur.`;
+};
+const getAnswer = (identifiers) => {
+    const { frequencyEmitted, ambulanceSpeed } = identifiers;
     const perceivedFrequency = (frequencyEmitted * (soundSpeed + observerSpeed)) /
         (soundSpeed - ambulanceSpeed);
-    const instruction = `Une ambulance émet un son d'une fréquence de $${frequencyEmitted}$ Hz lorsqu'elle
-  s'approche d'un observateur à une vitesse de $${ambulanceSpeed}$ m/s. Si la vitesse du son
-  dans l'air est de $340$ m/s, calculer la fréquence perçue par l'observateur.`;
-    const answer = `${frenchify(round(perceivedFrequency, 0))} \\ Hz`;
+    const answer = `${frenchify(round(perceivedFrequency, 0))}\\text{Hz}`;
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["Hz"],
         answerFormat: "tex",
-        identifiers: { ambulanceSpeed, frequencyEmitted },
+        identifiers,
     };
     return question;
 };
+const getPerceivedFrequency = () => {
+    const frequencyEmitted = randint(200, 1500); // Fréquence émise en Hz
+    const ambulanceSpeed = Math.floor(Math.random() * 40 + 10); // Vitesse de l'ambulance entre 10 et 50 m/s
+    const identifiers = { ambulanceSpeed, frequencyEmitted };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, ambulanceSpeed, frequencyEmitted }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -31,7 +45,7 @@ const getPropositions = (n, { answer, ambulanceSpeed, frequencyEmitted }) => {
         (soundSpeed - ambulanceSpeed);
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, frenchify(round(perceivedFrequency * (0.3 + Math.random() * 1.5), 0)) +
-            " \\ Hz");
+            " \\text{Hz}");
     }
     return shuffle(propositions);
 };
@@ -42,8 +56,6 @@ export const perceivedFrequency = {
     id: "perceivedFrequency",
     connector: "\\iff",
     label: "Calculer une fréquence perçue par un observateur",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Ondes"],
     subject: "Physique",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPerceivedFrequency, nb),
@@ -51,4 +63,5 @@ export const perceivedFrequency = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/potentialEnergy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EAIT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/pc/potentialEnergy.js

@@ -8,31 +8,44 @@ import { DistanceUnit } from "../../pc/units/distanceUnits.js";
 import { EnergyUnit } from "../../pc/units/energyUnit.js";
 import { MassUnit } from "../../pc/units/massUnits.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
-const getPotentialEnergy = () => {
-    const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+const getInstruction = (identifiers) => {
+    const { mass, height } = identifiers;
     const massMeasure = new Measure(mass, 0, MassUnit.kg);
-    const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
     const heightMeasure = new Measure(height, 0, DistanceUnit.m);
-    const potentialEnergy = mass * 9.81 * height;
     const instruction = `Un objet de masse $${massMeasure.toTex({
         notScientific: true,
     })}$ est suspendu à une hauteur de $${heightMeasure.toTex({
         notScientific: true,
     })}$. Il est ensuite relâché et tombe librement.
-  $\\\\$ Calculer l'énergie potentielle de l'objet. (Supposons que l'accélération due à la gravité est de $${earthGravityAcceleration.measure
+  
+Calculer l'énergie potentielle de l'objet (on suppose que l'accélération due à la gravité est de $${earthGravityAcceleration.measure
         .toSignificant(2)
-        .toTex()}$)`;
+        .toTex()}$).`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { mass, height } = identifiers;
+    const potentialEnergy = mass * 9.81 * height;
     const answer = `${frenchify(round(potentialEnergy, 2))}${EnergyUnit.J.toTex()}`;
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "Ep",
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["J"],
         answerFormat: "tex",
-        identifiers: { height, mass },
+        identifiers,
     };
     return question;
 };
+const getPotentialEnergy = () => {
+    const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+    const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
+    const identifiers = { height, mass };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, height, mass }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -50,8 +63,6 @@ export const potentialEnergy = {
     id: "potentialEnergy",
     connector: "=",
     label: "Calculer l'énergie potentielle",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Mécanique"],
     subject: "Physique",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPotentialEnergy, nb),
@@ -59,4 +70,5 @@ export const potentialEnergy = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/power/calculatePowerOfLight.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
-    E: number;
-    S: number;
+    E: number[];
+    S: number[];
 };
 export declare const calculatePowerOfLight: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/power/calculatePowerOfLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculatePowerOfLight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/calculatePowerOfLight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"calculatePowerOfLight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/calculatePowerOfLight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA+GF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/pc/power/calculatePowerOfLight.js

@@ -8,29 +8,81 @@ import { PowerUnit } from "../../../pc/units/powerUnits.js";
 import { WattUnit } from "../../../pc/units/wattUnit.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 const two = new NumberNode(2);
-const getCalculatePowerOfLightQuestion = () => {
-    const exo = getExercise();
+const getInstruction = (identifiers) => {
+    const { E, S } = identifiers;
+    const EMeasure = new Measure(E[0], E[1]);
+    const SMeasure = new Measure(S[0], S[1]);
+    const instruction = `Une cellule photovoltaïque est exposée à une lumière dont l'éclairement $E$ est de $${EMeasure.toTex({ notScientific: true })}$.
+
+La surface utile $S$ de cette cellule est de $${SMeasure.toTex({
+        notScientific: true,
+    })}$. 
+  
+Calculez la puissance lumineuse reçue par la cellule photovoltaïque.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { E, S } = identifiers;
+    const EMeasure = new Measure(E[0], E[1]);
+    const SMeasure = new Measure(S[0], S[1]);
+    const lightPower = EMeasure.times(SMeasure).toSignificant(2);
+    return lightPower.toTex({ hideUnit: true, notScientific: true });
+};
+const getHint = (identifiers) => {
+    const hint = `La puissance lumineuse reçue $P$, exprimée en $${WattUnit.W.toTex()}$, est donnée par la formule :
+
+$$
+P=E \\cdot S
+$$
+`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { E, S } = identifiers;
+    const EMeasure = new Measure(E[0], E[1]);
+    const SMeasure = new Measure(S[0], S[1]);
+    const lightPower = EMeasure.times(SMeasure).toSignificant(2);
+    const correction = `En appliquant la formule $P=E \\cdot S$ on obtient : 
+
+$$
+P=${EMeasure.toTex({ notScientific: true })} \\times ${SMeasure.toTex({
+        notScientific: true,
+    })}\\ \\Rightarrow  P=${lightPower.toTex({ notScientific: true })}
+$$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer,
-        instruction: exo.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        hint: exo.hint,
-        correction: exo.correction,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            E: exo.E.significantPart * Math.pow(10, exo.E.exponent),
-            S: exo.S.significantPart * Math.pow(10, exo.S.exponent),
-        },
+        identifiers,
     };
     return question;
 };
+const getCalculatePowerOfLightQuestion = () => {
+    const E = new Measure(randint(10, 30), 0, new DivideUnit(WattUnit.W, new PowerUnit(DistanceUnit.m, two)));
+    const S = new Measure(randint(3, 11), 0, new PowerUnit(DistanceUnit.m, two));
+    const identifiers = {
+        E: [E.significantPart, E.exponent],
+        S: [S.significantPart, S.exponent],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, E, S }) => {
     const propositions = [];
     addValidProp(propositions, answer + `\\ ${WattUnit.W.toTex()}`);
-    generatePropositions(E, S).forEach((value) => tryToAddWrongProp(propositions, value.toTex({ notScientific: true })));
+    const EMeasure = new Measure(E[0], E[1]);
+    const SMeasure = new Measure(S[0], S[1]);
+    const Eev = EMeasure.getValueAsNumber();
+    const Sev = SMeasure.getValueAsNumber();
+    generatePropositions(Eev, Sev).forEach((value) => tryToAddWrongProp(propositions, value.toTex({ notScientific: true })));
     let random;
     while (propositions.length < n) {
-        random = randint(E * S - 10, E * S + 10, [E]);
+        random = randint(Eev * Sev - 10, Eev * Sev + 10, [Eev]);
         tryToAddWrongProp(propositions, new Measure(random, 0, WattUnit.W).toTex({ notScientific: true }));
     }
     return shuffleProps(propositions, n);
@@ -42,37 +94,10 @@ const generatePropositions = (E, S) => {
     const first = new Measure(Math.floor(E / S), 0, WattUnit.W);
     return [first];
 };
-const getExercise = () => {
-    const E = new Measure(randint(10, 30), 0, new DivideUnit(WattUnit.W, new PowerUnit(DistanceUnit.m, two)));
-    const S = new Measure(randint(3, 11), 0, new PowerUnit(DistanceUnit.m, two));
-    const lightPower = E.times(S).toSignificant(2);
-    const instruction = `Une cellule photovoltaïque est exposée à une lumière dont l'éclairement $E$ est de $${E.toTex({ notScientific: true })}$.\n \\
-  La surface utile $S$ de cette cellule est de $${S.toTex({
-        notScientific: true,
-    })}$. Calculez la puissance lumineuse reçue par la cellule photovoltaïque. $${lightPower.toTex({ notScientific: true })}$`;
-    const hint = `Rappel : La puissance lumineuse reçue $P$, exprimée en $${WattUnit.W.toTex()}$, est donnée par la formule :
-- $P=E \\cdot S$
-`;
-    const correction = `En appliquant la formule $P=E \\cdot S$ on obtient : 
-- $P=${E.toTex({ notScientific: true })} \\times ${S.toTex({
-        notScientific: true,
-    })}\\ \\Rightarrow  P=${lightPower.toTex({ notScientific: true })}$`;
-    return {
-        instruction,
-        answer: lightPower.toTex({ hideUnit: true, notScientific: true }),
-        hint,
-        correction,
-        E,
-        S,
-        lightPower,
-    };
-};
 export const calculatePowerOfLight = {
     id: "calculatePowerOfLight",
     label: "Calcul de puissance lumineuse.",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Lumière"],
     generator: (nb) => getDistinctQuestions(getCalculatePowerOfLightQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -80,4 +105,5 @@ export const calculatePowerOfLight = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts

@@ -1,6 +1,8 @@
 import { Exercise } from "../../exercises/exercise.js";
 type Identifiers = {
-    commands: string[];
+    isAsking: string;
+    enetringLightX: number;
+    enetringLightY: number;
 };
 export declare const recognizeRefractionOrReflectionAngles: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAmHF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAcvE,CAAC"}
+{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkHF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAavE,CAAC"}