math-exercises 3.0.128 → 3.0.129

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AA+IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AA2HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.js

@@ -44,21 +44,6 @@ const getAnswer = (identifiers) => {
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
     return `${B}>${A}`;
 };
-const isAnswerValid = (ans, { ...identifiers }) => {
-    const { orderedNodeIds } = identifiers;
-    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
-    const compSymbol = ans.includes(">")
-        ? ">"
-        : ans.includes("<")
-            ? "<"
-            : undefined;
-    if (!compSymbol) {
-        return false;
-    }
-    else {
-        return (compSymbol === ">" ? [B, A] : [A, B]).every((tex, i) => tex === ans.split(compSymbol)[i]);
-    }
-};
 const getPropositions = (nbProps, { ...identifiers }) => {
     const { orderedNodeIds } = identifiers;
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
@@ -88,7 +73,7 @@ const getKeys = (identifiers) => {
 };
 const getCompareABUsingQuotientQuestion = () => {
     const n = randint(2, 150);
-    const orderedNodesIncreasing = [add(1, sqrt(add(1, n))), add(2, sqrt(n))];
+    const orderedNodesIncreasing = [add(1, sqrt(1 + n)), add(2, sqrt(n))];
     return getQuestionFromIdentifiers({
         orderedNodeIds: orderedNodesIncreasing.map((node) => node.toIdentifiers()),
     });
@@ -113,10 +98,10 @@ export const compareABUsingQuotient = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     nodeIds: NodeIdentifiers[];
     texAnswers: string[];
 };
-export declare const compareFracABWithFracAPlusCBPlusC: Exercise<Identifiers>;
+type Options = {
+    isFracOfSums: boolean;
+};
+export declare const compareFracABWithFracAPlusCBPlusC: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=compareFracABWithFracAPlusCBPlusC.d.ts.map

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4LF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}
+{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA0MF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAgBF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqB1E,CAAC"}

package/lib/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.js

@@ -1,9 +1,9 @@
-import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { lcm } from "../../../../math/utils/arithmetic/lcm.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { add, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
@@ -33,12 +33,17 @@ const getCorrection = (identifiers) => {
         ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen)
         : frac(multiply(node, sameDen).simplify(), sameDen));
     const answer = getAnswer(identifiers);
-    return `On a : 
+    const isFracOfSums = isAddNode(nodes[1].leftChild);
+    return `${isFracOfSums
+        ? `On a : 
 
 $$
 ${nodes[1].toSimplificationTex()}
 $$
 
+`
+        : ``}
+
 On veut donc comparer $${nodesSimplified[0].toTex()}$ et $${nodesSimplified[1].toTex()}$.
 
 On peut choisir $${sameDen.frenchify()}$ comme dénominateur commun.
@@ -84,14 +89,19 @@ const getAnswer = (identifiers) => {
     const { texAnswers } = identifiers;
     return texAnswers[0];
 };
-const isAnswerValid = (ans, { texAnswers }) => {
-    return texAnswers.includes(ans);
-};
-const getCompareFracABWithFracAPlusCBPlusCQuestion = () => {
+const getCompareFracABWithFracAPlusCBPlusCQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const a = randint(1, 10);
-    const b = randint(1, 10, [a]);
+    const b = randint(2, 10, [a]);
     const c = randint(1, 10);
-    const nodes = [frac(a, b), frac(add(a, c), add(b, c))];
+    const nodes = [
+        frac(a, b),
+        (() => {
+            const nodeNum = opts.isFracOfSums ? add(a, c) : (a + c).toTree();
+            const nodeDec = opts.isFracOfSums ? add(b, c) : (b + c).toTree();
+            return frac(nodeNum, nodeDec);
+        })(),
+    ];
     const isOrderAsc = coinFlip();
     const sortedNodes = nodes.toSorted((node1, node2) => (isOrderAsc ? +1 : -1) * (node1.evaluate() - node2.evaluate()));
     const texAnswers = [
@@ -132,17 +142,31 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
+const optsDefault = {
+    isFracOfSums: false,
+};
+const options = [
+    {
+        id: "isFracOfSums",
+        label: "Fraction de sommes ?",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        values: [true, false],
+        defaultValue: optsDefault.isFracOfSums,
+    },
+];
 export const compareFracABWithFracAPlusCBPlusC = {
     id: "compareFracABWithFracAPlusCBPlusC",
     label: "Effectuer des comparaisons entre des fractions simples (de la forme $\\frac{a}{b}$ et $\\frac{a+c}{b+c}$)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCompareFracABWithFracAPlusCBPlusCQuestion(opts), nb, 30),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
-    isAnswerValid,
     getPropositions,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts

@@ -5,18 +5,14 @@ type QCMItem = {
     isValidAnswer: boolean;
 };
 type QuestionParam = {
-    fakeName: string;
+    letter: string;
     trueName: string;
     tex: string;
     nodeIds: NodeIdentifiers;
     explainTex: string;
 };
 type Identifiers = {
-    sign: number;
-    a: number;
-    b: number;
-    c: number;
-    dictFakeNameToQuestionParam: Record<string, QuestionParam>;
+    questionParams: QuestionParam[];
     items: QCMItem[];
 };
 type Options = {

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3D,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAkYF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AA+BF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}
+{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA0SF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}

package/lib/exercises/math/calcul/ordering/compareFracAndDec.js

@@ -2,44 +2,39 @@ import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrong
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { random, randomMany } from "../../../../utils/alea/random.js";
+import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { permute } from "../../../../utils/arrays/permutations.js";
-const getDecimalFormatTex = (questionParam) => {
-    return NodeConstructor.fromIdentifiers(questionParam.nodeIds)
-        .evaluate()
-        .frenchify();
-};
 const getInstruction = (identifiers, optsIn) => {
-    const { dictFakeNameToQuestionParam } = identifiers;
+    const { questionParams } = identifiers;
     const opts = Object.assign(optsDefault, optsIn);
     return `Voici trois nombres.
   
 ${opts.isUseABC
-        ? Object.entries(dictFakeNameToQuestionParam)
-            .toSorted(([fakeName1], [fakeName2]) => fakeName1.localeCompare(fakeName2))
-            .map(([fakeName, questionParam]) => {
-            return `
+        ? (() => {
+            const entries = questionParams.map((qP) => [qP.letter, qP]);
+            return entries
+                .toSorted(([letter1], [letter2]) => letter1.localeCompare(letter2))
+                .map(([letter, questionParam]) => {
+                return `
   
 $$
-${fakeName} = ${questionParam.tex}
+${letter} = ${questionParam.tex}
 $$
 
 `;
-        })
-            .join("")
+            })
+                .join("");
+        })()
         : `
 
 $$
-${Object.values(dictFakeNameToQuestionParam)
-            .map((questionParam) => questionParam.tex)
-            .join(" ; ")}
+${questionParams.map((questionParam) => questionParam.tex).join(" ; ")}
 $$
 
 `}
@@ -52,116 +47,48 @@ const getHint = () => {
 soit les mettre au même dénominateur.`;
 };
 const getCorrection = (identifiers, optsIn) => {
-    const { sign, a, dictFakeNameToQuestionParam } = identifiers;
-    const opts = Object.assign(optsDefault, optsIn);
-    const dictTrueNameToQuestionParam = Object.fromEntries(Object.entries(dictFakeNameToQuestionParam).map(([, questionParam]) => [
-        questionParam.trueName,
-        questionParam,
-    ]));
-    const letters = Object.keys(dictTrueNameToQuestionParam).toSorted((s1, s2) => s1.localeCompare(s2));
-    const [A, B, C] = letters.map((trueName) => {
-        const questionParam = dictTrueNameToQuestionParam[trueName];
-        return opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+    const { questionParams } = identifiers;
+    const opts = optsIn ?? optsDefault;
+    const ascOrderedQuestionParams = questionParams.toSorted((questionParam1, questionParam2) => {
+        const [node1, node2] = [questionParam1, questionParam2].map((questionParam) => NodeConstructor.fromIdentifiers(questionParam.nodeIds));
+        return substract(node1, node2).evaluate();
     });
-    return `
-
-${(() => {
-        if (opts.nbDecimalFormat > 0) {
-            return `On a :
-
-${letters
-                .toSorted((trueName1, trueName2) => {
-                const [fakeName1, fakeName2] = [trueName1, trueName2].map((trueName) => dictTrueNameToQuestionParam[trueName].fakeName);
-                return fakeName1.localeCompare(fakeName2);
-            })
-                .map((trueName) => {
-                const questionParam = dictTrueNameToQuestionParam[trueName];
-                return questionParam.explainTex;
-            })
-                .join("")}`;
-        }
-        else {
-            return `On a :
+    return `On a : 
+${questionParams
+        .toSorted((qp1, qp2) => qp1.letter.localeCompare(qp2.letter))
+        .map((questionParam) => questionParam.explainTex.length > 0 &&
+        `
 
 $$
-${A} = ${sign === +1 ? `` : `-`}\\frac{${a} \\times 20}{5 \\times 20} = ${sign === +1 ? `` : `-`}\\frac{${20 * a}}{100}
+${questionParam.explainTex}
 $$
 
-De plus :
-
-$$
-${A} = ${sign === +1 ? `` : `-`}\\frac{${a} \\times 2}{5 \\times 2} = ${sign === +1 ? `` : `-`}\\frac{${2 * a}}{10}
-$$
-
-Ainsi :
-
-${(() => {
-                if (sign === +1) {
-                    return `
-    
-$$
-${dictTrueNameToQuestionParam["C"].tex} > \\frac{${2 * a}}{10} = \\frac{${20 * a}}{100} > ${dictTrueNameToQuestionParam["B"].tex}
-$$
-
-`;
-                }
-                else {
-                    return `
-    
-$$
-${dictTrueNameToQuestionParam["B"].tex} > -\\frac{${20 * a}}{100} = -\\frac{${2 * a}}{10} > ${dictTrueNameToQuestionParam["C"].tex}
-$$
-
-`;
-                }
-            })()}
-`;
-        }
-    })()}
-
-
-Or :
-
-${(() => {
-        if (sign === +1) {
-            return `
-    
-$$
-${getDecimalFormatTex(dictTrueNameToQuestionParam["C"])} 
-> 
-${getDecimalFormatTex(dictTrueNameToQuestionParam["A"])}
-> 
-${getDecimalFormatTex(dictTrueNameToQuestionParam["B"])}
-$$
-
-Le classement par ordre décroissant est donc :
+`)
+        .join("")}
+  
+Le classement par ordre décroissant est donc : 
 
 $$
-${C} > ${A} > ${B}
+${ascOrderedQuestionParams
+        .toReversed()
+        .map((questionParam) => questionParam.tex)
+        .join(">")}
 $$
 
-`;
-        }
-        else {
-            return `
-    
-$$
-${getDecimalFormatTex(dictTrueNameToQuestionParam["B"])} 
-> 
-${getDecimalFormatTex(dictTrueNameToQuestionParam["A"])}
-> 
-${getDecimalFormatTex(dictTrueNameToQuestionParam["C"])}
-$$
-
-Le classement par ordre décroissant est donc :
-
+${opts.isUseABC
+        ? `
+  
 $$
-${B} > ${A} > ${C}
+${ascOrderedQuestionParams
+            .toReversed()
+            .map((questionParam) => questionParam.letter)
+            .join(">")}
 $$
+  
+`
+        : ``}
 
-`;
-        }
-    })()}`;
+  `;
 };
 const getPropositions = (_, { answer, ...identifiers }) => {
     const { items } = identifiers;
@@ -184,16 +111,16 @@ const getAnswer = (identifiers) => {
 const isAnswerValid = (ans, { answer }) => {
     const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split(">").map((tex) => parseAlgebraic(tex)));
     return (ansNodes.length === 3 &&
-        [0, 1, 2].every((i) => ansNodes[i].equals(answerNodes[i])));
+        [0, 1, 2].every((i) => substract(ansNodes[i], answerNodes[i]).evaluate() === 0));
 };
 const getKeys = (identifiers, optsIn) => {
-    const { dictFakeNameToQuestionParam } = identifiers;
+    const { questionParams } = identifiers;
     const opts = Object.assign(optsDefault, optsIn);
     return [
         "sup",
         "inf",
-        ...Object.values(dictFakeNameToQuestionParam).map((questionParam) => {
-            const tex = opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+        ...questionParams.map((questionParam) => {
+            const tex = opts.isUseABC ? questionParam.letter : questionParam.tex;
             return {
                 id: "custom",
                 label: tex,
@@ -208,85 +135,60 @@ const getKeys = (identifiers, optsIn) => {
 };
 const getCompareFracAndDecQuestion = (optsIn) => {
     const opts = Object.assign(optsDefault, optsIn);
-    const sign = opts.isAllowingNegativeNumbers ? (coinFlip() ? +1 : -1) : +1;
+    function randomSign() {
+        return opts.isAllowingNegativeNumbers ? (coinFlip() ? +1 : -1) : +1;
+    }
     const a = random([...Array(19).keys()].map((i) => i + 1).filter((i) => i % 5 !== 0));
     const b = randint(1, a - 1);
-    const c = random([...Array(99).keys()].map((i) => i + 1));
-    const nodes = {
-        A: frac(a, 5),
-        B: frac(substract(multiply(20, a), b).simplify(), 100),
-        C: frac(add(multiply(2, a), c).simplify(), 10)
-            .evaluate()
-            .toTree(),
-    };
-    Object.keys(nodes).forEach((letter) => {
-        nodes[letter] = multiply(sign, nodes[letter]);
-    });
-    const dictIsInDecimalFormat = Object.fromEntries(randomMany(["A", "C"], opts.nbDecimalFormat).map((letter) => [
-        letter,
-        true,
-    ]));
+    const d = randint(Math.floor(a / 10 + 1), 99);
+    const nodes = [
+        frac(multiply(randomSign(), a).evaluate(), 5),
+        frac(multiply(randomSign(), substract(multiply(20, a), b).evaluate()).simplify(), 100),
+        multiply(randomSign(), `0,${d}`.unfrenchify().toTree()).simplify(),
+    ];
     const nbTotal = 4;
     const nbValid = 1;
     const nbInvalid = nbTotal - nbValid;
-    const letters = Object.keys(nodes).toSorted((s1, s2) => s1.localeCompare(s2));
+    const letters = ["A", "B", "C"];
     const shuffledLetters = shuffle(letters);
-    const dictFakeNameToQuestionParam = Object.fromEntries(letters.map((trueName, i) => {
-        const node = nodes[trueName];
-        const fakeName = shuffledLetters[i];
+    const dictLetterToQuestionParam = Object.fromEntries(shuffledLetters.map((letter, i) => {
+        const node = nodes[i];
         return [
-            fakeName,
+            letter,
             {
-                fakeName: fakeName,
-                trueName: trueName,
+                letter,
                 nodeIds: node.toIdentifiers(),
-                tex: dictIsInDecimalFormat[trueName]
-                    ? node.evaluate().frenchify()
-                    : node.toTex(),
-                explainTex: (() => {
-                    if (opts.isUseABC || !dictIsInDecimalFormat[trueName]) {
-                        return `
-              
-$$
-${opts.isUseABC ? `${fakeName} =` : ``}${dictIsInDecimalFormat[trueName]
-                            ? ``
-                            : (() => {
-                                if (trueName === "A") {
-                                    return `${node.toTex()} = 
-${sign === +1 ? `` : `-`}\\frac{${a} \\times 2}{5 \\times 2} = 
-${sign === +1 ? `` : `-`}\\frac{${2 * a}}{10} =`;
-                                }
-                                else {
-                                    return `${node.toTex()} =`;
-                                }
-                            })()} 
-${node.evaluate().frenchify()}
-$$
-
-`;
+                tex: node.toTex(),
+                explainTex: `${opts.isUseABC ? `${letter} = ` : ``}${(() => {
+                    const isPositive = nodes[i].evaluate() >= 0;
+                    const tex = node.toTex();
+                    const strEv = node.evaluate().frenchify();
+                    if (i === 0) {
+                        return `${node.toTex()} = 
+${isPositive ? `` : `-`}\\frac{${a} \\times 2}{5 \\times 2} = 
+${isPositive ? `` : `-`}\\frac{${2 * a}}{10} = ${strEv}`;
                     }
                     else {
-                        return ``;
+                        return strEv !== tex ? `${tex} = ${strEv}` : ``;
                     }
-                })(),
+                })()}`,
             },
         ];
     }));
-    const dictTrueNameToQuestionParam = Object.fromEntries(Object.values(dictFakeNameToQuestionParam).map((questionParam) => [
-        questionParam.trueName,
-        questionParam,
-    ]));
-    const [A, B, C] = letters.map((trueName) => {
-        const questionParam = dictTrueNameToQuestionParam[trueName];
-        return opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+    const ascOrderedQuestionParams = Object.values(dictLetterToQuestionParam).toSorted((questionParam1, questionParam2) => {
+        const [node1, node2] = [questionParam1, questionParam2].map((questionParam) => NodeConstructor.fromIdentifiers(questionParam.nodeIds));
+        return substract(node1, node2).evaluate();
     });
     const validItems = [
         {
-            tex: sign === +1 ? `{${C}}>{${A}}>{${B}}` : `{${B}}>{${A}}>{${C}}`,
+            tex: ascOrderedQuestionParams
+                .toReversed()
+                .map((questionParam) => opts.isUseABC ? questionParam.letter : questionParam.tex)
+                .join(">"),
             isValidAnswer: true,
         },
     ];
-    const invalidItems = permute([A, B, C])
+    const invalidItems = permute(ascOrderedQuestionParams.map((questionParam) => opts.isUseABC ? questionParam.letter : questionParam.tex))
         .filter(([D, E, F]) => `{${D}}>{${E}}>{${F}}` !== validItems[0].tex)
         .map(([D, E, F]) => {
         return {
@@ -300,11 +202,7 @@ $$
         ...shuffle(invalidItems).slice(0, nbInvalid),
     ]);
     return getQuestionFromIdentifiers({
-        sign,
-        a,
-        b,
-        c,
-        dictFakeNameToQuestionParam,
+        questionParams: shuffle(ascOrderedQuestionParams),
         items,
     });
 };
@@ -334,14 +232,6 @@ const options = [
         type: GeneratorOptionType.checkbox,
         defaultValue: optsDefault.isUseABC,
     },
-    {
-        id: "nbDecimalFormat",
-        label: "Nombre d'écritures décimales",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.select,
-        values: [1, 2],
-        defaultValue: optsDefault.nbDecimalFormat,
-    },
     {
         id: "isAllowingNegativeNumbers",
         label: "Permettre les nombres négatifs",

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,CAexD,CAAC"}
+{"version":3,"file":"compareFromPiMinusFrac.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,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;AA+IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -50,9 +50,6 @@ const getAnswer = (identifiers) => {
     const { texAnswers } = identifiers;
     return texAnswers[0];
 };
-const isAnswerValid = (ans, { texAnswers }) => {
-    return texAnswers.includes(ans);
-};
 const getCompareFromPiMinusFracQuestion = () => {
     const fracsPool = [
         frac(31, 10),
@@ -134,10 +131,10 @@ export const compareFromPiMinusFrac = {
     generator: (nb, opts) => getDistinctQuestions(() => getCompareFromPiMinusFracQuestion(opts), nb, 30),
     qcmTimer: 60,
     freeTimer: 60,
-    isAnswerValid,
     getPropositions,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

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

@@ -100,7 +100,7 @@ const options = [
 export const kmPerMinToKmPerHourConversion = {
     id: "kmPerMinToKmPerHourConversion",
     connector: "=",
-    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en \\textrm{km/h})",
+    label: "Effectuer des conversions de vitesse ( $x$ $\\textrm{km}$ en $y$ $\\textrm{min}$ donne une vitesse $V$ en $\\textrm{km/h}$)",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getKmPerMinToKmPerHourConversionQuestion(opts), nb),
     options,

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,CAehD,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;AA8LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

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

@@ -76,13 +76,16 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     addValidProp(propositions, answer);
     if (isMinutesToHours) {
         const roundedValue = round(hours.evaluate(), 2);
-        const texDecimal = roundedValue.frenchify().split(",")[1];
         tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
         tryToAddWrongProp(propositions, `${multiply(minutes.evaluate(), 60).simplify().toTex()}\\text{h}`);
         tryToAddWrongProp(propositions, `${frac(60, minutes).toTex()}\\text{h}`);
         propWhile(propositions, n, () => {
-            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
-            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            const texDecimal = roundedValue.frenchify().split(",")[1];
+            if (texDecimal) {
+                tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+                tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            }
+            tryToAddWrongProp(propositions, `${randint(1, 20)}\\text{h}`);
         });
     }
     else {

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

@@ -1 +1 @@
-{"version":3,"file":"secondsToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/secondsToHours.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":"secondsToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/secondsToHours.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;AA8LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

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

@@ -76,13 +76,16 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     addValidProp(propositions, answer);
     if (isSecondsToHours) {
         const roundedValue = round(hours.evaluate(), 2);
-        const texDecimal = roundedValue.frenchify().split(",")[1];
         tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
         tryToAddWrongProp(propositions, `${multiply(seconds.evaluate(), 3600).simplify().toTex()}\\text{h}`);
         tryToAddWrongProp(propositions, `${frac(3600, seconds).toTex()}\\text{h}`);
         propWhile(propositions, n, () => {
-            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
-            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            const texDecimal = roundedValue.frenchify().split(",")[1];
+            if (texDecimal) {
+                tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+                tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+            }
+            tryToAddWrongProp(propositions, `${randint(1, 20)}\\text{h}`);
         });
     }
     else {

package/lib/exercises/math/dataRepresentations/barChartInterpreting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AAotBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}
+{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AAktBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}

package/lib/exercises/math/dataRepresentations/barChartInterpreting.js

@@ -8,7 +8,6 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randint } from "../../../math/utils/random/randint.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { capitalize } from "../../../utils/strings/capitalize.js";
-import { shuffle } from "../../../utils/alea/shuffle.js";
 class BarChartConstructor {
     static stylesPools = {
         color: [
@@ -98,7 +97,7 @@ class BarChartConstructor {
     }
     static createRandomCategories(dictIsUsingCategory, categoryPropsPool, styleType) {
         const nbCategUsed = Object.keys(dictIsUsingCategory).length;
-        const styles = shuffle(this.stylesPools[styleType].slice(0, nbCategUsed));
+        const styles = this.stylesPools[styleType].slice(0, nbCategUsed);
         return categoryPropsPool
             .filter((_, i) => dictIsUsingCategory[i])
             .map((props, i) => {
@@ -357,7 +356,8 @@ const getGGBOptionsVertStacked = (identifiers) => {
     }
     function createCommandsForBar(barChart, barIndex) {
         //const bar = barChart.bars[barIndex];
-        const commands = barChart.categories.flatMap((categ, categIndex) => {
+        const categoriesReversed = barChart.categories.toReversed();
+        const commands = categoriesReversed.flatMap((categ, categIndex) => {
             const xRange = getXRangeForBarIndex(barIndex);
             const yRange = getYRangeForCategory(barIndex, categIndex);
             const style = categ.style;
@@ -366,8 +366,8 @@ const getGGBOptionsVertStacked = (identifiers) => {
                 `${B} = Polygon((${xRange.min}, ${yRange.min}), (${xRange.min}, ${yRange.max}),(${xRange.max}, ${yRange.max}),(${xRange.max}, ${yRange.min}))`,
                 `ShowLabel(${B},false)`,
                 style.type === "color"
-                    ? `SetColor(${B}, "${barChart.categories[categIndex].style.color}")`
-                    : `SetDecoration(${B}, ${barChart.categories[categIndex].style.fill})`,
+                    ? `SetColor(${B}, "${categ.style.color}")`
+                    : `SetDecoration(${B}, ${categ.style.fill})`,
             ];
             return barChartCommand;
         });

package/lib/index.d.ts

@@ -275,17 +275,13 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
-    sign: number;
-    a: number;
-    b: number;
-    c: number;
-    dictFakeNameToQuestionParam: Record<string, {
-        fakeName: string;
+    questionParams: {
+        letter: string;
         trueName: string;
         tex: string;
         nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
         explainTex: string;
-    }>;
+    }[];
     items: {
         tex: string;
         isValidAnswer: boolean;
@@ -313,7 +309,9 @@ declare const mathExercises: (Exercise<{
 }, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     texAnswers: string[];
-}, object, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
+}, {
+    isFracOfSums: boolean;
+}, string | number | boolean | string[] | number[] | boolean[]> | Exercise<{
     a: number;
     b: number;
     isAdd: boolean;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0EAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kEAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/tests/questionTest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CAqP3B,CAAC"}
+{"version":3,"file":"questionTest.d.ts","sourceRoot":"","sources":["../../src/tests/questionTest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAKjE,eAAO,MAAM,YAAY,GACvB,KAAK,QAAQ,CAAC,MAAM,CAAC,EACrB,UAAU,QAAQ,CAAC,MAAM,CAAC;;;CA2P3B,CAAC"}

package/lib/tests/questionTest.js

@@ -191,10 +191,12 @@ export const questionTest = (exo, question) => {
                 throw new Error(`exo ${exo.id} has invalid props`);
         }
         props.forEach((prop) => {
+            if (prop.statement.includes("undefined"))
+                throw new Error(`exo ${exo.id} has invalid prop (undefined) : ${prop.statement}`);
             if (prop.statement.match(dotDecimalPattern))
-                throw new Error(`exo ${exo.id} has invalid prop (dot) : ${prop}`);
+                throw new Error(`exo ${exo.id} has invalid prop (dot) : ${prop.statement}`);
             if (prop.statement.includes("[object Object]"))
-                throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop}`);
+                throw new Error(`exo ${exo.id} has invalid prop (objectObject) : ${prop.statement}`);
             if (!props.every((prop2) => prop2.id === prop.id || prop.statement !== prop2.statement))
                 throw new Error(`exo ${exo.id} has invalid prop (duplicate): ${prop.statement}`);
             if (prop.format !== "raw") {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.128",
+  "version": "3.0.129",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [