math-exercises 3.0.126 → 3.0.128

package/lib/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.js

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randomMany } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { varNames } = identifiers;
     const [x, y, u] = varNames;
@@ -20,33 +21,11 @@ const getHint = (identifiers) => {
 const getCorrection = (identifiers) => {
     const { varNames } = identifiers;
     const [x, y, u] = varNames;
-    return `L'inverse de  $\\frac{1}{${u}}$ est $${u}$. 
-  
-L'inverse de $\\frac{1}{${x}}+\\frac{1}{${y}}$ est $\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}$. 
-
-Il faut donc mettre ces deux fractions au même dénominateur. 
-
-On obtient :  
-
-$$
-\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}
-$$
-
-$$
-= \\frac{1}{\\frac{${x}+${y}}{${x}${y}}}
-$$
-
-$$
-= \\frac{${x}${y}}{${x}+${y}}
-$$
-
-Conclusion :
-
-$$
-\\frac{1}{${u}} = \\frac{${x}${y}}{${x}+${y}}
-$$
-
-`;
+    return alignTex([
+        [`${u}`, "=", `\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}`],
+        [``, "=", `\\frac{1}{\\frac{${x}+${y}}{${x}${y}}}`],
+        [``, "=", `\\frac{${x}${y}}{${x}+${y}}`],
+    ]);
 };
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { varNames } = identifiers;

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAkMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}
+{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAyMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -2,6 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { names, texInstruction } = identifiers;
     return `Si $${names[0]}$ et $${names[1]}$  sont deux nombres tels que  
@@ -12,9 +13,8 @@ $$
 
 alors on peut dire que :`;
 };
-const getHint = (identifiers) => {
-    const { names } = identifiers;
-    return `Il s'agit de comparer  $${names[0]}$ et $${names[1]}$.`;
+const getHint = () => {
+    return `Essaye d’isoler chaque variable de chaque côté de l’inégalité.`;
 };
 const getCorrection = (identifiers) => {
     const { names, texInstruction, texsCorrection } = identifiers;
@@ -44,30 +44,34 @@ $$
 };
 const getPropositions = (n, { names, texsAnswer }) => {
     const propositions = [];
-    texsAnswer.forEach((tex) => {
-        addValidProp(propositions, tex);
-    });
-    const invalidProps = [
-        `${names[0]} < ${names[1]}`,
-        `${names[0]} > ${names[1]}`,
-        `${names[0]} \\leq ${names[1]}`,
-        `${names[0]} \\geq ${names[1]}`,
-        `${names[1]} < ${names[0]}`,
-        `${names[1]} > ${names[0]}`,
-        `${names[1]} \\leq ${names[0]}`,
-        `${names[1]} \\geq ${names[0]}`,
-    ].filter((tex) => !texsAnswer.includes(tex));
+    const validSample = shuffle(texsAnswer)[0];
+    addValidProp(propositions, validSample);
+    const allPossibleProps = [
+        `${names[0]}<${names[1]}`,
+        `${names[0]}>${names[1]}`,
+        `${names[0]}\\le ${names[1]}`,
+        `${names[0]}\\ge ${names[1]}`,
+        `${names[1]}<${names[0]}`,
+        `${names[1]}>${names[0]}`,
+        `${names[1]}\\le ${names[0]}`,
+        `${names[1]}\\ge ${names[0]}`,
+    ];
+    const invalidProps = allPossibleProps.filter((tex) => !texsAnswer.includes(tex));
     invalidProps.forEach((tex) => {
         tryToAddWrongProp(propositions, tex);
     });
     return shuffleProps(propositions, n);
 };
+const getAnswer = (identifiers) => {
+    const { texsAnswer } = identifiers;
+    return texsAnswer[0];
+};
 const isAnswerValid = (ans, { texsAnswer }) => {
     return texsAnswer.includes(ans);
 };
 const getCompareAMinusBQuestion = () => {
     const namesPool = ["a", "b", "c", "d", "r", "s", "t", "u", "v"];
-    let names = randomMany(namesPool, 2);
+    const names = randomMany(namesPool, 2);
     const compareSymbol = random(["inf", "sup", "leq", "geq"]);
     let texsObjectArray = [];
     switch (compareSymbol) {
@@ -76,13 +80,13 @@ const getCompareAMinusBQuestion = () => {
                 texsObjectArray = [
                     {
                         texInstruction: `x - y < 0`,
-                        texsCorrection: [`x < y`, `x \\leq y`],
-                        texsAnswer: [`x < y`, `x \\leq y`, `y > x`, `y \\geq x`],
+                        texsCorrection: [`x<y`, `x\\le y`],
+                        texsAnswer: [`x<y`, `x\\le y`, `y>x`, `y\\ge x`],
                     },
                     {
                         texInstruction: `0 > x - y`,
-                        texsCorrection: [`y > x`, `y \\geq x`],
-                        texsAnswer: [`x < y`, `x \\leq y`, `y > x`, `y \\geq x`],
+                        texsCorrection: [`y>x`, `y\\ge x`],
+                        texsAnswer: [`x<y`, `x\\le y`, `y>x`, `y\\ge x`],
                     },
                 ];
             }
@@ -92,13 +96,13 @@ const getCompareAMinusBQuestion = () => {
                 texsObjectArray = [
                     {
                         texInstruction: `x - y > 0`,
-                        texsCorrection: [`x > y`, `x \\geq y`],
-                        texsAnswer: [`x > y`, `x \\geq y`, `y < x`, `y \\leq x`],
+                        texsCorrection: [`x>y`, `x\\ge y`],
+                        texsAnswer: [`x>y`, `x\\ge y`, `y<x`, `y\\le x`],
                     },
                     {
                         texInstruction: `0 < x - y`,
-                        texsCorrection: [`y < x`, `y \\leq x`],
-                        texsAnswer: [`x > y`, `x \\geq y`, `y < x`, `y \\leq x`],
+                        texsCorrection: [`y<x`, `y\\le x`],
+                        texsAnswer: [`x>y`, `x\\ge y`, `y<x`, `y\\le x`],
                     },
                 ];
             }
@@ -107,14 +111,14 @@ const getCompareAMinusBQuestion = () => {
             {
                 texsObjectArray = [
                     {
-                        texInstruction: `x - y \\leq 0`,
-                        texsCorrection: [`x \\leq y`],
-                        texsAnswer: [`x \\leq y`, `y \\geq x`],
+                        texInstruction: `x - y \\le 0`,
+                        texsCorrection: [`x\\le y`],
+                        texsAnswer: [`x\\le y`, `y\\ge x`],
                     },
                     {
-                        texInstruction: `0 \\geq x - y`,
-                        texsCorrection: [`y \\geq x`],
-                        texsAnswer: [`x \\leq y`, `y \\geq x`],
+                        texInstruction: `0 \\ge x - y`,
+                        texsCorrection: [`y\\ge x`],
+                        texsAnswer: [`x\\le y`, `y\\ge x`],
                     },
                 ];
             }
@@ -123,14 +127,14 @@ const getCompareAMinusBQuestion = () => {
             {
                 texsObjectArray = [
                     {
-                        texInstruction: `x - y \\geq 0`,
-                        texsCorrection: [`x \\geq y`],
-                        texsAnswer: [`x \\geq y`, `y \\leq x`],
+                        texInstruction: `x - y \\ge 0`,
+                        texsCorrection: [`x\\ge y`],
+                        texsAnswer: [`x\\ge y`, `y\\le x`],
                     },
                     {
                         texInstruction: `0 \\leq x - y`,
-                        texsCorrection: [`y \\leq x`],
-                        texsAnswer: [`x \\geq y`, `y \\leq x`],
+                        texsCorrection: [`y\\le x`],
+                        texsAnswer: [`x\\ge y`, `y\\le x`],
                     },
                 ];
             }
@@ -144,7 +148,6 @@ const getCompareAMinusBQuestion = () => {
     texInstruction = replaceVarNames(texInstruction);
     texsCorrection = texsCorrection.map((tex) => replaceVarNames(tex));
     texsAnswer = texsAnswer.map((tex) => replaceVarNames(tex));
-    names = order.map((i) => names[i]);
     return getQuestionFromIdentifiers({
         names,
         texInstruction,
@@ -154,6 +157,7 @@ const getCompareAMinusBQuestion = () => {
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
+        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: ["inf", "sup", "leq", "geq", ...identifiers.names],
         answerFormat: "tex",
@@ -177,6 +181,4 @@ export const compareAMinusB = {
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
-    answerType: "QCM",
-    isQCM: true,
 };

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFromPiMinusFrac.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"compareFromPiMinusFrac.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAmJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.js

@@ -129,7 +129,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 };
 export const compareFromPiMinusFrac = {
     id: "compareFromPiMinusFrac",
-    label: "Comparer deux nombres (Pi et une fraction approximante) par le calcul de leur différence",
+    label: "Comparer deux nombres ($\\pi$ et une fraction approximante) par le calcul de leur différence",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCompareFromPiMinusFracQuestion(opts), nb, 30),
     qcmTimer: 60,
@@ -139,6 +139,5 @@ export const compareFromPiMinusFrac = {
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
-    answerType: "QCU",
     hasHintAndCorrection: true,
 };

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valuateExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/valuateExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}
+{"version":3,"file":"valuateExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/valuateExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.js

@@ -5,7 +5,6 @@ import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getExpression = (identifiers) => {
     const { a, b, monomFirst } = identifiers;
     return add(monomFirst ? monom(a, 1) : b, monomFirst ? b : monom(a, 1));
@@ -53,14 +52,6 @@ $$`;
 const getKeys = () => {
     return [];
 };
-const isAnswerValid = () => {
-    try {
-        throw Error("VEA not implemented");
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getValuateExpressionQuestion = () => {
     const a = randint(-9, 10, [0, 1, -1]);
     const b = randint(-9, 10, [0]);
@@ -93,7 +84,6 @@ export const valuateExpression = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getHint,

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeLitExpFromFrenchExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmCrC,KAAK,QAAQ,GACT,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAoEb,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,QAAQ,CAAC;IACvB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/B,wBAAwB,EAAE,OAAO,CAAC;CACnC,CAAC;AAyNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}
+{"version":3,"file":"writeLitExpFromFrenchExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmCrC,KAAK,QAAQ,GACT,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAoEb,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,QAAQ,CAAC;IACvB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/B,wBAAwB,EAAE,OAAO,CAAC;CACnC,CAAC;AAuRF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.js

@@ -40,27 +40,27 @@ class ExpressionConstructor {
             case "opposite":
                 return {
                     node: opposite(a),
-                    str__french: `L'opposé de $ ${a} $`,
+                    strFrench: `L'opposé de $ ${a} $`,
                 };
             case "inverse":
                 return {
                     node: frac(1, a),
-                    str__french: `L'inverse de $ ${a} $`,
+                    strFrench: `L'inverse de $ ${a} $`,
                 };
             case "add":
                 return {
                     node: add(a, b),
-                    str__french: `La somme de $ ${a} $ et de $ ${b} $`,
+                    strFrench: `La somme de $ ${a} $ et de $ ${b} $`,
                 };
             case "subtract":
                 return {
                     node: substract(a, b),
-                    str__french: `La différence entre $ ${a} $ et $ ${b} $`,
+                    strFrench: `La différence entre $ ${a} $ et $ ${b} $`,
                 };
             case "multiply":
                 return {
                     node: multiply(a, b),
-                    str__french: typeof b === "string" && isUsingFrenchFactorNouns
+                    strFrench: typeof b === "string" && isUsingFrenchFactorNouns
                         ? dictTexFactorToFrenchFactor[a.frenchify()]
                             ? `${dictTexFactorToFrenchFactor[a.frenchify()]} de $ ${b} $`
                             : `Le produit de $ ${a} $ par $ ${b} $`
@@ -69,7 +69,7 @@ class ExpressionConstructor {
             case "divide":
                 return {
                     node: frac(a, b),
-                    str__french: typeof a === "string" && isUsingFrenchFactorNouns
+                    strFrench: typeof a === "string" && isUsingFrenchFactorNouns
                         ? dictTexFactorToFrenchFactor[frac(1, b).toTex()]
                             ? `${dictTexFactorToFrenchFactor[frac(1, b).toTex()]} de $ ${a} $`
                             : `Le quotient de $ ${a} $ par $ ${b} $`
@@ -145,7 +145,7 @@ const getAnswer = (identifiers) => {
     return node.toTex();
 };
 const getInstruction = (identifiers) => {
-    const statementString = ExpressionConstructor.fromIdentifiers(identifiers).str__french;
+    const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
     return `Écrire l'expression littérale pour : 
 
 ${statementString}
@@ -157,32 +157,77 @@ const getHint = (identifiers) => {
         case "opposite":
             return `La somme d'un nombre et de son opposé donne $0$.`;
         case "inverse":
-            return `L'inverse de $8$ est $0.25$.`;
+            return `L'inverse de $8$ est $0,25$.`;
         case "add":
-            return `La somme de $8457$ et de $6567$ est $${8457 + 6567}$.`;
+            return `La somme de $8$ et de $6$ est $14$.`;
         case "subtract":
-            return `La différence entre $8457$ est $6567$ est $${8457 - 6567}$.`;
-        case "multiply":
-            return `Le produit de $8457$ par $6567$ est $${8457 * 6567}$ .`;
-        case "divide":
-            return `Le quotient de $200$ par $8$ est $25$.`;
+            return `La différence entre $8$ et $6$ est $2$.`;
+        case "multiply": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("produit")) {
+                const bHint = randint(2, 10, typeof identifiers.b === "number" ? [identifiers.b] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: "" + bHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: bHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                return `Le produit de $8$ par $6$ est $48$.`;
+            }
+        }
+        case "divide": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("quotient")) {
+                const aHint = randint(2, 10, typeof identifiers.a === "number" ? [identifiers.a] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: "" + aHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: aHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node.toTex()}$.`;
+            }
+            else {
+                return `Le quotient de $200$ par $8$ est $25$.`;
+            }
+        }
     }
 };
 const getCorrection = (identifiers) => {
+    const { a, operatorName, b } = identifiers;
     const expression = ExpressionConstructor.fromIdentifiers(identifiers);
-    const statementString = expression.str__french;
-    let outString = `${capitalize(statementString)} est $ ${getAnswer(identifiers)} $.`;
+    const statementString = expression.strFrench;
     //explain rewriting if needed
     const nodeRaw = expression.node;
     const nodeRefined = nodeRaw.simplify();
-    const texRaw = nodeRaw.toTex({
-        allowDoubleMinus: true,
-        forceTimesSign: true,
-        forceParenthesis: true,
-        forceNoSimplification: true,
-        allowMinusAnywhereInFraction: true,
-    });
+    let texRaw;
+    switch (operatorName) {
+        case "add":
+            {
+                const [texA, texB] = [a, b].map((c) => parseAlgebraic("" + c).toTex());
+                const isWrapWithParenthesis = ("" + b).startsWith("-");
+                texRaw = `${texA}+${isWrapWithParenthesis ? `(${texB})` : `${texB}`}`;
+            }
+            break;
+        default:
+            {
+                texRaw = nodeRaw.toTex({
+                    allowDoubleMinus: true,
+                    forceTimesSign: true,
+                    forceParenthesis: true,
+                    forceNoSimplification: true,
+                    allowMinusAnywhereInFraction: true,
+                });
+            }
+            break;
+    }
     const texRefined = nodeRefined.toTex();
+    let outString = `${capitalize(statementString)} est $ ${texRefined} $.`;
     if (texRaw !== texRefined) {
         outString += `
 

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     distance: number;
     minutes: number;
 };
-export declare const kmPerMinToKmPerHourConversion: Exercise<Identifiers>;
+type Options = {
+    unitTex: string;
+};
+export declare const kmPerMinToKmPerHourConversion: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=kmPerMinToKmPerHourConversion.d.ts.map

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kmPerMinToKmPerHourConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/kmPerMinToKmPerHourConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}
+{"version":3,"file":"kmPerMinToKmPerHourConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/kmPerMinToKmPerHourConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBxE,CAAC"}

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { dividersOf } from "../../../math/utils/arithmetic/dividersOf.js";
 import { randint } from "../../../math/utils/random/randint.js";
@@ -7,85 +7,103 @@ import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { random } from "../../../utils/alea/random.js";
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
-    return `Si on parcourt $${distance.frenchify()}$ km en $${minutes.frenchify()}$ min, 
-quelle est la vitesse moyenne en km/h ( $km.h^{-1}$ ) ?`;
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
+    return `Si on parcourt $${distance.frenchify()} \\ \\textrm{km}$ en $${minutes.frenchify()} \\ \\textrm{min}$, 
+quelle est la vitesse moyenne en $${unitTex}$ ?`;
 };
-const getAnswer = (identifiers) => {
+const getAnswer = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
     const nodeAnswer = multiply(distance, frac(60, minutes));
-    return `${nodeAnswer.simplify().toTex()}km.h^{-1}`;
+    return `${nodeAnswer.simplify().toTex()} \\ ${unitTex}`;
 };
 const isAnswerValid = (ans, { distance, minutes }) => {
     const nodeAnswer = multiply(distance, frac(60, minutes));
-    const nodeAns = parseAlgebraic(ans.replace("$km.h^{-1}$", "").replace("km/h", ""));
+    const nodeAns = parseAlgebraic(["\\textrm{km/h}", "\\textrm{km}.\\textrm{h}^{-1}"].reduce((acc, x) => acc.replace(x, ""), ans));
     return substract(nodeAns, nodeAnswer).evaluate() === 0;
 };
 const getHint = () => {
     return `Combien de minutes constituent une heure ?`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
-    return `En $60$ minutes, on parcourt $${multiply(distance, frac(60, minutes)).toTex()}$ km 
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
+    return `En $60$ minutes, on parcourt $${multiply(distance, frac(60, minutes)).toTex()} \\ \\textrm{km}$ 
 donc la vitesse est de $${multiply(distance, frac(60, minutes).simplify()).toTex()} = ${multiply(distance, frac(60, minutes))
         .simplify()
-        .toTex()}$ $km.h^{-1}$`;
+        .toTex()} \\ ${unitTex}$`;
 };
-const getPropositions = (n, { answer, distance, minutes }) => {
+const getPropositions = (n, { answer, distance, minutes }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
     const propositions = [];
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, `${multiply(60, minutes).simplify().toTex()}km.h^{-1}`);
-    tryToAddWrongProp(propositions, `${frac(distance, minutes).simplify().toTex()}km.h^{-1}`);
-    tryToAddWrongProp(propositions, `${multiply(3.6, frac(distance, minutes)).simplify().toTex()}km.h^{-1}`);
+    tryToAddWrongProp(propositions, `${multiply(60, minutes).simplify().toTex()} \\ ${unitTex}`);
+    tryToAddWrongProp(propositions, `${frac(distance, minutes).simplify().toTex()} \\ ${unitTex}`);
+    tryToAddWrongProp(propositions, `${multiply(3.6, frac(distance, minutes))
+        .simplify()
+        .toTex()} \\ ${unitTex}`);
     return shuffleProps(propositions, n);
 };
-const getKmPerMinToKmPerHourConversionQuestion = () => {
+const getKmPerMinToKmPerHourConversionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const distance = randint(1, 101);
     const minutes = random(dividersOf(60));
     const identifiers = {
         distance,
         minutes,
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: [
             {
                 id: "custom",
-                label: "{km}.{h}^{-1}",
+                label: opts.unitTex,
                 labelType: "tex",
                 mathfieldInstructions: {
                     method: "write",
-                    content: "{km}.{h}^{-1}",
-                },
-            },
-            {
-                id: "custom",
-                label: "km/h",
-                labelType: "raw",
-                mathfieldInstructions: {
-                    method: "write",
-                    content: "km/h",
+                    content: opts.unitTex,
                 },
             },
         ],
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
     return question;
 };
+const optsDefault = {
+    unitTex: "\\textrm{km/h}",
+};
+const options = [
+    {
+        id: "unitTex",
+        label: "Unité affichée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["\\textrm{km/h}", "\\textrm{km}.\\textrm{h}^{-1}"],
+        defaultValue: optsDefault.unitTex,
+    },
+];
 export const kmPerMinToKmPerHourConversion = {
     id: "kmPerMinToKmPerHourConversion",
     connector: "=",
-    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en km/h)",
+    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en \\textrm{km/h})",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getKmPerMinToKmPerHourConversionQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getKmPerMinToKmPerHourConversionQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -94,5 +112,4 @@ export const kmPerMinToKmPerHourConversion = {
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
     shouldHaveCalculator: true,
-    answerType: "QCU",
 };

package/lib/exercises/math/conversion/minutesToHours.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"minutesToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/minutesToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}
+{"version":3,"file":"minutesToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/minutesToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/conversion/minutesToHours.js

@@ -146,5 +146,4 @@ export const minutesToHours = {
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
     shouldHaveCalculator: true,
-    answerType: "QCU",
 };

package/lib/exercises/math/conversion/prefixToNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefixToNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/prefixToNumber.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAsLF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC"}
+{"version":3,"file":"prefixToNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/prefixToNumber.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAoMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC"}