math-exercises 3.0.123 → 3.0.125

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.js

@@ -2,11 +2,13 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 const getInstruction = (identifiers) => {
     const { firstValue, reason } = identifiers;
     const firstRank = 0;
@@ -81,7 +83,17 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    return texs.includes(ans);
+    return (texs.includes(ans) ||
+        (() => {
+            let nodeAns = parseLatex(ans);
+            if (isEqualNode(nodeAns)) {
+                nodeAns = nodeAns.rightChild;
+            }
+            const differenceNode = substract(nodeAns, formula);
+            return (differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0);
+        })());
 };
 export const geometricFindExplicitFormula = {
     id: "geometricFindExplicitFormula",

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     reason: number;
     startRank: number;
+    askedRank: number;
     startValue: number;
 };
 export declare const geometricReasonUsage: Exercise<Identifiers>;

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}
+{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.js

@@ -1,20 +1,26 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 const getInstruction = (identifiers) => {
-    const { reason, startRank, startValue } = identifiers;
-    const askedRank = startRank + 1;
+    const { reason, startRank, startValue, askedRank } = identifiers;
     return `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`;
 };
 const getAnswer = (identifiers) => {
-    const { reason, startValue } = identifiers;
-    const answer = (startValue * reason).toString();
+    const answer = getAnswerNode(identifiers).evaluate().frenchify();
     return answer;
 };
+const getAnswerNode = (identifiers) => {
+    const { reason, startValue, startRank, askedRank } = identifiers;
+    return multiply(startValue, power(reason, substract(askedRank, startRank)));
+};
 const getStartStatement = (identifiers) => {
-    const { startRank } = identifiers;
-    const askedRank = startRank + 1;
+    const { askedRank } = identifiers;
     return `u_{${askedRank}}`;
 };
 const getQuestionFromIdentifiers = (identifiers) => {
@@ -31,26 +37,44 @@ const getQuestionFromIdentifiers = (identifiers) => {
 const getGeometricReasonUsage = () => {
     const reason = randint(2, 10);
     const startRank = randint(0, 20);
+    const askedRank = startRank +
+        probaLawFlip([
+            [1, 0.5],
+            [2, 0.3],
+            [3, 0.2],
+        ]);
     const startValue = randint(1, 10);
-    const identifiers = { startValue, reason, startRank };
+    const identifiers = { startValue, reason, startRank, askedRank };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer, startValue, reason }) => {
+const getPropositions = (n, { answer, startValue, reason, askedRank, startRank }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    if (startValue + reason !== 4)
-        tryToAddWrongProp(propositions, (startValue + reason).toString());
+    //next term
+    tryToAddWrongProp(propositions, getAnswerNode({
+        startValue,
+        startRank,
+        reason,
+        askedRank: startRank + 1,
+    })
+        .evaluate()
+        .frenchify());
+    //arithmetic
+    tryToAddWrongProp(propositions, add(startValue, reason).evaluate().frenchify());
+    tryToAddWrongProp(propositions, add(startValue, multiply(reason, substract(askedRank, startRank)))
+        .evaluate()
+        .frenchify());
+    //savoir ses tables
     propWhile(propositions, n, () => {
         tryToAddWrongProp(propositions, startValue * (reason + randint(-reason + 1, 6, [0])) + "");
     });
-    return shuffle(propositions);
+    return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, startRank }) => {
-    return [
-        answer,
-        `u_{${startRank}}=${answer}`,
-        `u_${startRank}=${answer}`,
-    ].includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { askedRank } = identifiers;
+    return ([answer, `u_{${askedRank}}=${answer}`, `u_${askedRank}=${answer}`].includes(ans) ||
+        //tant pis pour les tables
+        parseAlgebraic(ans).evaluate() === getAnswerNode(identifiers).evaluate());
 };
 export const geometricReasonUsage = {
     id: "geometricReasonUsage",

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+MF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkOF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}

package/lib/exercises/math/sequences/sequenceEvaluation.js

@@ -5,7 +5,9 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 const getInstruction = (identifiers) => {
     const { termeid, affine, termeAdd, termeMult } = identifiers;
     const aff = new Affine(affine[0], affine[1], "n");
@@ -149,7 +151,22 @@ const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
         });
     }
     const latexs = validanswer.toAllValidTexs();
-    return latexs.includes(ans);
+    return (latexs.includes(ans) ||
+        (() => {
+            //allow "5 \\times n - 10"
+            const ansWithoutTimes = ans.replaceAll("\\times", "").replaceAll(" ", "");
+            const [nodeAns, nodeAnsWithoutTimes] = [ans, ansWithoutTimes].map((tex) => parseAlgebraic(tex));
+            const differenceNode = substract(nodeAns, nodeAnsWithoutTimes);
+            const isSameNode = differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0;
+            if (!isSameNode) {
+                return false;
+            }
+            else {
+                return latexs.includes(ansWithoutTimes);
+            }
+        })());
 };
 export const sequenceEvaluation = {
     id: "sequenceEvaluation",

package/lib/exercises/pc/chemicalReactions/chemicalEquations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chemicalEquations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/chemicalEquations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,eAAe,EAChB,MAAM,mDAAmD,CAAC;AAG3D,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAwDF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"chemicalEquations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/chemicalEquations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,eAAe,EAChB,MAAM,mDAAmD,CAAC;AAI3D,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAuEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/pc/chemicalReactions/chemicalEquations.js

@@ -17,7 +17,20 @@ const getAnswer = (identifiers) => {
 };
 const getKeys = (identifiers) => {
     const reaction = new Reaction(identifiers.reactionArray);
-    return [...reaction.getKeyIds(), "rightarrow"];
+    return [
+        "rightarrow",
+        ...reaction.getSpeciesFormula().map((formula) => {
+            return {
+                id: "custom",
+                label: formula,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: formula,
+                },
+            };
+        }),
+    ];
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
@@ -44,7 +57,9 @@ const getPropositions = (n, { answer, reactionArray }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    const ansNoSpace = ans.replaceAll(" ", "");
+    const answerNoSpace = answer.replaceAll(" ", "");
+    return ansNoSpace === answerNoSpace;
 };
 export const chemicalEquations = {
     id: "chemicalEquations",

package/lib/exercises/pc/mole/molarMass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"molarMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mole/molarMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAwDF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}
+{"version":3,"file":"molarMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/mole/molarMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgEF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}

package/lib/exercises/pc/mole/molarMass.js

@@ -3,6 +3,8 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round, roundSignificant } from "../../../math/utils/round.js";
 import { molecules } from "../../../pc/constants/molecularChemistry/molecule.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
 const getInstruction = (identifiers) => {
@@ -41,7 +43,11 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (ans === answer ||
+        (() => {
+            const [nodeAns, nodeAnswer] = [ans, answer].map((tex) => parseAlgebraic(tex));
+            return substract(nodeAns, nodeAnswer).evaluate() === 0;
+        })());
 };
 export const molarMass = {
     id: "molarMass",

package/lib/exercises/pc/motion/averageSpeed.d.ts

@@ -1,12 +1,17 @@
 import { Exercise } from "../../../exercises/exercise.js";
+type Msr = {
+    value: number;
+    unitIndex: number;
+};
 type Identifiers = {
     distance: Msr;
     time: Msr;
+    opts: Options;
 };
-type Msr = {
-    value: number;
-    unitIndex: number;
+type Options = {
+    acceptedInputType: string;
+    unitTex: string;
 };
-export declare const averageSpeed: Exercise<Identifiers>;
+export declare const averageSpeed: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=averageSpeed.d.ts.map

package/lib/exercises/pc/motion/averageSpeed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,GAAG,CAAC;CACX,CAAC;AAEF,KAAK,GAAG,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAuKhD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}
+{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,GAAG,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,GAAG,CAAC;IACV,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AA0NF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAsBF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAcvD,CAAC"}

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

@@ -1,4 +1,4 @@
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
@@ -6,9 +6,25 @@ import { Measure } from "../../../pc/measure/measure.js";
 import { DistanceUnit } from "../../../pc/units/distanceUnits.js";
 import { TimeUnit } from "../../../pc/units/timeUnits.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+const timeUnits = [TimeUnit.h, TimeUnit.min];
+const distanceUnitValues = [DistanceUnit.km, DistanceUnit.m];
+const getAcceptedInputTypesSentence = (identifiers) => {
+    const { opts } = identifiers;
+    return `Donner le résultat
+${(() => {
+        switch (opts.acceptedInputType) {
+            case "exact":
+                return "sous forme exacte";
+            case "significant(3)":
+                return "approché avec $3$ chiffres significatifs";
+        }
+    })()}.`;
+};
 const getInstruction = (identifiers) => {
-    const { distance, time } = identifiers;
+    const { distance, time, opts } = identifiers;
     const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
     const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
     const instruction = `Soit un objet parcourant $${distanceMeasure.toTex({
@@ -16,111 +32,166 @@ const getInstruction = (identifiers) => {
     })}$ en $${timeMeasure.toTex({ notScientific: true })}$.
 
 
-Caculer la vitesse moyenne de cet objet en $${DistanceUnit.m.toTex()} \\cdot ${TimeUnit.s.toTex()}^{-1}$.
+Calculer la vitesse moyenne de cet objet en $${opts.unitTex}$.
+
+${getAcceptedInputTypesSentence(identifiers)}
   `;
     return instruction;
 };
-const getAnswer = (identifiers) => {
-    const { distance, time } = identifiers;
-    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
-    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
-    const answer = distanceMeasure
-        .convert("m")
-        .divide(timeMeasure.convert("s"))
-        .toSignificant(2);
-    return answer.toTex();
-};
-const getHint = () => {
+const getHint = ({ opts }) => {
     return `La vitesse moyenne est donnée par : 
   
 $$
-\\frac{\\text{distance}}{\\text{temps}} \\ \\textrm{m} \\cdot \\textrm{s}^{-1}
+\\frac{\\text{distance}}{\\text{temps}} \\ ${opts.unitTex}
 $$`;
 };
 const getCorrection = (identifiers) => {
-    const { distance, time } = identifiers;
+    const { distance, time, opts } = identifiers;
     let correction = ``;
     const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
     const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
-    const calcul = new FractionNode(new VariableNode(distanceMeasure.toSignificant(2).toTex()), new VariableNode(timeMeasure.toSignificant(2).toTex()));
-    const answer = distanceMeasure.divide(timeMeasure).toSignificant(2).toTex();
+    const calcul = new FractionNode(new VariableNode(distanceMeasure.toTex()), new VariableNode(timeMeasure.toTex()));
+    const answer = getAnswer(identifiers);
     if (distance.unitIndex === 0)
-        correction = `- On convertit les $\\textrm{km}$ en $\\textrm{m}$ : $1\\ \\textrm{km}=1000\\ \\textrm{m}$.`;
+        correction = `- On convertit les $\\textrm{km}$ en $\\textrm{m}$ : $1\\ \\textrm{km}=1000\\ \\textrm{m}$.
+
+$$
+${distance.value.frenchify()} \\textrm{km} = ${distance.value.frenchify()} \\times 1000 = ${distanceMeasure.toTex()}
+$$
+
+`;
     switch (time.unitIndex) {
         case 0:
             correction = `${correction}
-- On convertit les heures en secondes : $1\\ \\textrm{h} = 3600\\ \\textrm{s}$.`;
+- On convertit les heures en secondes : $1\\ \\textrm{h} = 3600\\ \\textrm{s}$.
+
+$$
+${time.value.frenchify()} \\textrm{h} = ${time.value.frenchify()} \\times 3600 = ${timeMeasure.toTex()}
+$$
+
+`;
             break;
         case 1:
         default:
             correction = `${correction}
-- On convertit les minutes en secondes : $1\\ \\textrm{m} = 60\\ \\textrm{s}$.`;
+- On convertit les minutes en secondes : $1\\ \\textrm{min} = 60\\ \\textrm{s}$.
+
+$$
+${time.value.frenchify()} \\textrm{min} = ${time.value.frenchify()} \\times 60 = ${timeMeasure.toTex()}
+$$
+
+`;
     }
     return `${correction}
-- On applique la règle de calcul pour la vitesse moyenne : $${calcul.toTex()} = ${answer}$`;
+- On applique la règle de calcul pour la vitesse moyenne : $${calcul.toTex()}$
+- On arrondit à la toute fin : $${calcul.toTex()} \\approx ${answer} \\ ${opts.unitTex}$`;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: [],
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-        answerFormat: "tex",
-        identifiers,
-    };
-    return question;
+const getAnswer = (identifiers) => {
+    return getAnswerMeasure(identifiers).toTex({ hideUnit: true });
 };
-const timeUnits = [TimeUnit.h, TimeUnit.mi];
-const distanceUnitValues = [DistanceUnit.km, DistanceUnit.m];
-const getAverageSpeedQuestion = () => {
-    const distance = { value: randint(70, 151), unitIndex: randint(0, 2) };
-    const time = { value: randint(10, 61), unitIndex: randint(0, 2) };
-    const identifiers = { distance, time };
-    return getQuestionFromIdentifiers(identifiers);
+const getAnswerMeasure = (identifiers) => {
+    const { distance, time } = identifiers;
+    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
+    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
+    return distanceMeasure
+        .convert("m")
+        .divide(timeMeasure.convert("s"))
+        .toSignificant(2);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const ansNode = parseAlgebraic(ans);
+    const answerNode = parseAlgebraic(getAnswerMeasure(identifiers).toTex({ hideUnit: true }));
+    return substract(ansNode, answerNode).simplify().evaluate() === 0;
 };
-const getPropositions = (n, { answer, distance, time }) => {
+const getPropositions = (n, { answer, distance, time, opts }) => {
     const propositions = [];
-    addValidProp(propositions, answer);
+    addValidProp(propositions, `${answer} \\ ${opts.unitTex}`);
     const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
     const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
-    genearatePropositions(distanceMeasure, timeMeasure).forEach((value) => tryToAddWrongProp(propositions, value));
+    generatePropositions(distanceMeasure, timeMeasure).forEach((value) => tryToAddWrongProp(propositions, `${value} \\ ${opts.unitTex}`));
     const division = distanceMeasure
         .convert("m")
         .divide(timeMeasure.convert("s"));
     const divisionValue = division.significantPart * division.exponent;
     propWhile(propositions, n, () => {
         const random = randfloat(divisionValue - 10, divisionValue + 11);
-        tryToAddWrongProp(propositions, new Measure(random, 0, division.getUnit()).toSignificant(2).toTex());
+        const valueTex = new Measure(random, 0, division.getUnit())
+            .toSignificant(2)
+            .toTex({ hideUnit: true });
+        tryToAddWrongProp(propositions, `${valueTex} \\ ${opts.unitTex}`);
     });
     return shuffleProps(propositions, n);
 };
-const genearatePropositions = (distance, time) => {
+const generatePropositions = (distance, time) => {
     const distanceInMeter = distance.convert("m");
     const timeInSeconds = time.convert("s");
     return [
-        distanceInMeter.times(timeInSeconds).toSignificant(2).toTex(),
-        distanceInMeter.divide(time).toSignificant(2).toTex(),
-        distance.divide(timeInSeconds).toSignificant(2).toTex(),
-        distance.divide(time).toSignificant(2).toTex(),
-    ];
-};
-const isAnswerValid = (ans, { answer, distance, time }) => {
-    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
-    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
-    return [
-        answer,
-        distanceMeasure
-            .divide(timeMeasure)
+        distanceInMeter
+            .times(timeInSeconds)
             .toSignificant(2)
             .toTex({ hideUnit: true }),
-    ].includes(ans);
+        distanceInMeter.divide(time).toSignificant(2).toTex({ hideUnit: true }),
+        distance.divide(timeInSeconds).toSignificant(2).toTex({ hideUnit: true }),
+        distance.divide(time).toSignificant(2).toTex({ hideUnit: true }),
+    ];
+};
+const getKeys = () => {
+    return [];
+    // return [`\\text{m} \\cdot \\text{s}^{-1}`].map((tex) => {
+    //   return {
+    //     id: "custom",
+    //     label: tex,
+    //     labelType: "raw",
+    //     mathfieldInstructions: {
+    //       method: "write",
+    //       content: tex,
+    //     },
+    //   } as KeyProps;
+    // });
+};
+const getAverageSpeedQuestion = (optsIn) => {
+    const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const distance = { value: randint(70, 151), unitIndex: randint(0, 2) };
+    const time = { value: randint(10, 61), unitIndex: randint(0, 2) };
+    const identifiers = { distance, time, opts };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const optsDefault = {
+    acceptedInputType: "significant(3)",
+    unitTex: "\\text{m} \\cdot \\text{s}^{-1}",
 };
+const options = [
+    {
+        id: "unitTex",
+        label: "Unité utilisée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: [
+            "\\text{m} \\cdot \\text{s}^{-1}",
+            "\\text{m/s}",
+            "\\text{s} \\cdot \\text{m}^{-1}",
+        ],
+        defaultValue: optsDefault.unitTex,
+    },
+];
 export const averageSpeed = {
     id: "averageSpeed",
-    label: "Caclul de vitesse moyenne",
+    label: "Calcul de vitesse moyenne",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getAverageSpeedQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageSpeedQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/pc/motion/averageSpeedCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA6PF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AAmQF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

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

@@ -42,7 +42,9 @@ const getInstruction = (identifiers) => {
 Utiliser ces informations pour calculer ${targetVariable.name === "distance" ||
         targetVariable.name === "vitesse moyenne"
         ? "la"
-        : "le"} ${targetVariable.name} en $${targetVariable.value.getUnit().toTex()}$.`;
+        : "le"} ${targetVariable.name} en $${targetVariable.value.getUnit().toTex()}$.
+  
+Donner la réponse sous forme arrondie à $2$ décimales.`;
     return instruction;
 };
 const getAnswer = (identifiers) => {
@@ -83,16 +85,20 @@ const getCorrection = (identifiers) => {
     const correction = targetVariable.name === "vitesse moyenne"
         ? `La vitesse moyenne est calculée en utilisant la formule $v = \\frac{d}{\\Delta t}$. Donc, $v = \\frac{${round(distance, 2)
             .toTree()
-            .toTex()}}{${round(deltaTime, 2).toTree().toTex()}} = ${new Measure(round(distance / deltaTime, 2), 0, targetVariable.value.getUnit()).toTex({ notScientific: true })}$.`
+            .toTex()}}{${round(deltaTime, 2)
+            .toTree()
+            .toTex()}} \\approx ${new Measure(round(distance / deltaTime, 2), 0, targetVariable.value.getUnit()).toTex({ notScientific: true })}$.`
         : targetVariable.name === "distance"
             ? `La distance est calculée en utilisant la formule $d = v \\times \\Delta t$. Donc, $d = ${round(speed, 2)
                 .toTree()
                 .toTex()} \\times ${round(deltaTime, 2)
                 .toTree()
-                .toTex()} = ${new Measure(round(speed * deltaTime, 2), 0, DistanceUnit.km).toTex({ notScientific: true })}$.`
+                .toTex()} \\approx ${new Measure(round(speed * deltaTime, 2), 0, DistanceUnit.km).toTex({ notScientific: true })}$.`
             : `Le temps est calculé en utilisant la formule $\\Delta t = \\frac{d}{v}$. Donc, $t = \\frac{${round(distance, 2)
                 .toTree()
-                .toTex()}}{${round(speed, 2).toTree().toTex()}} = ${new Measure(round(distance / speed, 2), 0, TimeUnit.h).toTex({ notScientific: true })}$.`;
+                .toTex()}}{${round(speed, 2)
+                .toTree()
+                .toTex()}} \\approx ${new Measure(round(distance / speed, 2), 0, TimeUnit.h).toTex({ notScientific: true })}$.`;
     return correction;
 };
 const getAnswerNode = (identifiers) => {

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

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