math-exercises 3.0.126 → 3.0.127

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts

@@ -6,7 +6,7 @@ type Identifiers = {
     progCalcIds: ProgCalcIdentifiers;
 };
 type Options = {
-    numberType: "Integer" | "Decimal";
+    numberType: "Entier" | "Décimal";
     nbSteps: number;
     nbDigits: number;
 };

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentalProgramSolve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalProgramSolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,OAAO,EAEL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AA2BzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AAoMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB7D,CAAC"}
+{"version":3,"file":"mentalProgramSolve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/mentalProgramSolve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAgCzC,KAAK,WAAW,GAAG;IACjB,qBAAqB,EAAE,eAAe,CAAC;IACvC,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAAC;AA8MF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA0B7D,CAAC"}

package/lib/exercises/math/calcul/mentalCaluls/mentalProgramSolve.js

@@ -2,22 +2,27 @@ import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType,
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { randomMany } from "../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
-import { ProgCalcConstructor, } from "../../../../math/progCalc/progCalc.js";
-import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { ProgCalc, ProgCalcConstructor, } from "../../../../math/progCalc/progCalc.js";
+import { isAddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getStrSolvingStep = (nodeStep) => {
     //write 10 + (-8) instead of 10 - 8
     function isNegative(node) {
         return !abs(node).simplify().equals(node.simplify());
     }
-    if (nodeStep instanceof AddNode && isNegative(nodeStep.rightChild)) {
+    if (isAddNode(nodeStep) && isNegative(nodeStep.rightChild)) {
         return `${nodeStep.leftChild.toTex()} + (${nodeStep.rightChild.toTex()}) = ${nodeStep
             .simplify()
             .toTex()}`;
     }
+    else if (isOppositeNode(nodeStep)) {
+        return `-(${nodeStep.child.toTex()}) = ${nodeStep.simplify().toTex()}`;
+    }
     else {
         const texL = nodeStep.toTex({
             allowDoubleMinus: true,
@@ -30,52 +35,61 @@ const getStrSolvingStep = (nodeStep) => {
         return `${texL} = ${texR}`;
     }
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, progCalcIds, nodeIdsStartingNumber }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    const nodeFinalNumber = answer.toTree();
-    const nbWrong = n - 1;
-    const arrOffset = randomMany([-10, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 10], nbWrong);
-    for (let i = 0; i < arrOffset.length; i++) {
-        const offset = arrOffset[i];
-        tryToAddWrongProp(propositions, add(nodeFinalNumber, offset).simplify().toTex());
+    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+    const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
+    const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
+    //applies progCalc to finalNumber
+    tryToAddWrongProp(propositions, progCalc.apply(nodeFinalNumber).simplify().toTex());
+    //applies progCalc operations in reverse to finalNumber
+    const progCalcReversed = new ProgCalc(progCalc.operations.toReversed());
+    tryToAddWrongProp(propositions, progCalcReversed.apply(nodeFinalNumber).simplify().toTex());
+    //stops at intermediary step (stops before goal)
+    const progCalcInverse = progCalc.getInverseProgCalc();
+    const inverseOperations = progCalcInverse.operations;
+    const arrStepNodes = [nodeFinalNumber];
+    for (let i = 0; i < inverseOperations.length - 1; i++) {
+        const nodePrevious = arrStepNodes[arrStepNodes.length - 1].simplify();
+        const operation = inverseOperations[i];
+        const nodeStep = operation.func(nodePrevious);
+        arrStepNodes.push(nodeStep);
     }
+    shuffle(arrStepNodes).forEach((nodeStep) => {
+        if (propositions.length < n) {
+            tryToAddWrongProp(propositions, nodeStep.simplify().toTex());
+        }
+    });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { nodeIdsStartingNumber } = identifiers;
-    const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
-    return nodeStartingNumber.toTex();
+    return NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
 };
 const getInstruction = (identifiers, opts) => {
     const { nodeIdsStartingNumber, progCalcIds } = identifiers;
     const nodeStartingNumber = NodeConstructor.fromIdentifiers(nodeIdsStartingNumber);
     const progCalc = ProgCalcConstructor.fromIdentifiers(progCalcIds);
     const nodeFinalNumber = progCalc.apply(nodeStartingNumber).simplify();
-    const strOpening = `Voici un programme de calcul :`;
-    const strChooseANumber = `Choisir un nombre
-    
-`;
-    const arrStrProgCalc = progCalc.getArrOfFrenchStrings().map((str) => `
-  
-${str}`);
-    const strProgCalc = arrStrProgCalc.reduce((acc, str) => acc + str);
-    const strFinalNumber = opts?.numberType == "Integer"
+    const strFinalNumber = opts?.numberType == "Entier"
         ? nodeFinalNumber.evaluate().frenchify()
         : nodeFinalNumber
             .evaluate()
             .toFixed(opts?.nbDigits ?? 0)
             .replace(".", ",");
-    const strQuestion = `Quel nombre faut-il choisir au départ pour obtenir $ ${strFinalNumber} $ à la fin ?`;
-    return `
-${strOpening}
+    return `Voici un programme de calcul :
 
-${strChooseANumber}
+> Choisir un nombre
 
-${strProgCalc}
+${progCalc.getArrOfFrenchStrings().map((str) => `> ${str}`).join(`
+  
+`)}
 
-${strQuestion}
-`;
+Quel nombre faut-il choisir au départ pour obtenir $ ${strFinalNumber} $ à la fin ?`;
 };
 const getHint = () => {
     return `Pars du résultat obtenu à la fin et remonte à l'envers en inversant chaque étape.`;
@@ -106,12 +120,10 @@ const getCorrection = (identifiers) => {
     return `
 On part de la fin et on remonte à l'envers en inversant chaque étape.
 
-${arrStrSolvingSteps.map((str) => `
-
-$$
-${str}
-$$
-`)}
+${alignTex(arrStrSolvingSteps.map((str) => {
+        const [lhs, rhs] = str.split("=");
+        return [lhs, "=", rhs];
+    }))}
   
 Le nombre choisi au départ était donc $ ${nodeStartingNumber.toTex()} $.`;
 };
@@ -131,12 +143,13 @@ const getMentalProgramSolveQuestion = (optsIn) => {
     const opts = optsIn ? Object.assign(optsDefault, optsIn) : optsDefault;
     let nbDigits = 0;
     switch (opts.numberType) {
-        case "Integer":
-            nbDigits = 0;
-            break;
-        case "Decimal":
+        case "Décimal":
             nbDigits = opts.nbDigits ?? 2;
             break;
+        default:
+        case "Entier":
+            nbDigits = 0;
+            break;
     }
     const powerOf10 = Math.pow(10, nbDigits);
     const valueStart = randint(0, 33 * powerOf10, []) / powerOf10;
@@ -161,7 +174,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
 };
 const optsDefault = {
-    numberType: "Integer",
+    numberType: "Entier",
     nbSteps: 4,
     nbDigits: 0,
 };
@@ -170,7 +183,7 @@ const options = [
         id: "numberType",
         label: "Type de nombres utilisés",
         defaultValue: optsDefault.numberType,
-        values: ["Integer", "Decimal"],
+        values: ["Entier", "Décimal"],
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.select,
     },
@@ -214,4 +227,5 @@ export const mentalProgramSolve = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

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;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AAyRF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}
+{"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,CAiBxD,CAAC"}

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

@@ -1,73 +1,10 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { abs } from "../../../../tree/nodes/functions/absNode.js";
-import { FunctionsIds, isFunctionNode, } from "../../../../tree/nodes/functions/functionNode.js";
-import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
 import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.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 { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { shuffle } from "../../../../utils/alea/shuffle.js";
-const randomOperatorReplacementDict = () => {
-    const operatorIds = [
-        OperatorIds.add,
-        OperatorIds.multiply,
-        OperatorIds.fraction,
-    ];
-    return Object.fromEntries(shuffle(operatorIds).map((opId, i) => [opId, operatorIds[i]]));
-};
-const randomFunctionReplacementDict = () => {
-    const functionIds = [FunctionsIds.sqrt, FunctionsIds.abs];
-    return Object.fromEntries(shuffle(functionIds).map((fId, i) => [fId, functionIds[i]]));
-};
-const nodeByReplacingOperations = (node, operatorReplacementDict, functionReplacementDict) => {
-    if (isOperatorNode(node)) {
-        const leftChild = nodeByReplacingOperations(node.leftChild, operatorReplacementDict, functionReplacementDict);
-        const rightChild = nodeByReplacingOperations(node.rightChild, operatorReplacementDict, functionReplacementDict);
-        const targetOperatorId = operatorReplacementDict[+node.id] ?? node.id;
-        switch (+targetOperatorId) {
-            case OperatorIds.add:
-                return add(leftChild, rightChild);
-            case OperatorIds.substract:
-                return substract(leftChild, rightChild);
-            case OperatorIds.multiply:
-                return multiply(leftChild, rightChild);
-            case OperatorIds.divide:
-            case OperatorIds.fraction:
-                return frac(leftChild, rightChild);
-            case OperatorIds.power:
-                return power(leftChild, rightChild);
-            default:
-                return add(leftChild, rightChild);
-        }
-    }
-    else if (isFunctionNode(node)) {
-        const child = nodeByReplacingOperations(node.child, operatorReplacementDict, functionReplacementDict);
-        const targetFunctionId = functionReplacementDict[+node.id] ?? node.id;
-        switch (+targetFunctionId) {
-            case FunctionsIds.sqrt:
-                return sqrt(child);
-            case FunctionsIds.abs:
-                return abs(child);
-            case FunctionsIds.opposite:
-            default:
-                return opposite(child);
-        }
-    }
-    else {
-        return node;
-    }
-};
-const nodeBySubstitutingX = (node, strVar) => {
-    return parseAlgebraic(node.toTex().replaceAll("{x}", `"${strVar}"`));
-};
 const getInstruction = (identifiers) => {
     const { orderedNodeIds } = identifiers;
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
@@ -84,13 +21,7 @@ $$
 \\frac{${B}}{${A}} > 1
 $$
   
-essaie de te ramener à 
-
-$$
-${B} <(ou >) ${A}
-$$
-
-par des opérations que l'on effectue à droite et à gauche de l'inégalité.`;
+essaye d’isoler chaque expression de chaque côté de l’inégalité.`;
 };
 const getCorrection = (identifiers) => {
     const { orderedNodeIds } = identifiers;
@@ -156,40 +87,11 @@ const getKeys = (identifiers) => {
     ];
 };
 const getCompareABUsingQuotientQuestion = () => {
-    const nbNodes = 2;
     const n = randint(2, 150);
-    const [s, t] = [0, 1].map(() => randint(1, 100));
-    const refNode = add(s, abs(multiply(t, "{x}")));
-    let orderedNodesAndEvaluations;
-    let isValidNodes = false;
-    while (!isValidNodes) {
-        const nodeInner = nodeBySubstitutingX(sqrt(add(1, "{x}")), `${n.frenchify()}`);
-        const nodes = [...Array(nbNodes).keys()].map(() => nodeBySubstitutingX(nodeByReplacingOperations(refNode, randomOperatorReplacementDict(), randomFunctionReplacementDict()), `{${nodeInner.toTex()}}`));
-        try {
-            const evaluations = nodes.map((node) => node.evaluate());
-            //discard impossible
-            if (evaluations.some((evaluation) => isNaN(evaluation) || evaluation <= 0)) {
-                isValidNodes = false;
-                continue;
-            }
-            //discard same
-            if (evaluations.some((evaluation, i) => evaluations.filter((_, j) => j !== i).includes(evaluation))) {
-                isValidNodes = false;
-                continue;
-            }
-            orderedNodesAndEvaluations = nodes
-                .map((node, i) => {
-                return { node, evaluation: evaluations[i] };
-            })
-                .toSorted(({ evaluation: evaluation1 }, { evaluation: evaluation2 }) => evaluation1 - evaluation2);
-            isValidNodes = true;
-        }
-        catch (_) {
-            continue;
-        }
-    }
-    const orderedNodeIds = orderedNodesAndEvaluations.map(({ node }) => node.toIdentifiers());
-    return getQuestionFromIdentifiers({ orderedNodeIds });
+    const orderedNodesIncreasing = [add(1, sqrt(add(1, n))), add(2, sqrt(n))];
+    return getQuestionFromIdentifiers({
+        orderedNodeIds: orderedNodesIncreasing.map((node) => node.toIdentifiers()),
+    });
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {

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;AAQ7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8KF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAoBnE,CAAC"}
+{"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,CAoBnE,CAAC"}

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

@@ -4,7 +4,7 @@ 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 { frac } from "../../../../tree/nodes/operators/fractionNode.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";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -19,18 +19,27 @@ const getHint = () => {
 const getCorrection = (identifiers) => {
     const { nodeIds } = identifiers;
     const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const [den1, den2] = nodes.map((node) => node.rightChild);
+    const nodesSimplified = nodes.map((node) => node.simplify());
+    const [den1, den2] = nodesSimplified.map((nodeSimplified) => {
+        return isFractionNode(nodeSimplified)
+            ? nodeSimplified.rightChild
+            : (1).toTree();
+    });
     const sameDen = lcm(den1.evaluate(), den2.evaluate());
-    const nodesSameDenMult = nodes.map((node) => frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild).simplify()), sameDen));
-    const nodesSameDen = nodes.map((node) => frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen));
+    const nodesSameDenMult = nodesSimplified.map((node) => isFractionNode(node)
+        ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild).simplify()), multiply(node.rightChild.simplify(), frac(sameDen, node.rightChild).simplify()))
+        : frac(multiply(node, sameDen), multiply(1, sameDen)));
+    const nodesSameDen = nodes.map((node) => isFractionNode(node)
+        ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen)
+        : frac(multiply(node, sameDen).simplify(), sameDen));
     const answer = getAnswer(identifiers);
     return `On a : 
 
 $$
-${nodes[1].toTex()} = ${frac(nodes[1].leftChild.simplify(), nodes[1].rightChild.simplify()).toTex()}
+${nodes[1].toSimplificationTex()}
 $$
 
-On veut donc comparer $${nodes[0].toTex()}$ et $${nodes[1].simplify().toTex()}$.
+On veut donc comparer $${nodesSimplified[0].toTex()}$ et $${nodesSimplified[1].toTex()}$.
 
 On peut choisir $${sameDen.frenchify()}$ comme dénominateur commun.
 
@@ -39,7 +48,12 @@ ${nodes
         ? `
 
 $$
-${(i === 0 ? nodes[i] : nodes[i].simplify()).toTex()} = ${nodesSameDenMult[i].toTex()} = ${nodesSameDen[i].toTex()}
+${(i === 0 ? nodes[i] : nodes[i].simplify()).toTex()} = ${[
+            ...new Set([
+                nodesSameDenMult[i].toTex(),
+                nodesSameDen[i].toTex(),
+            ]).values(),
+        ].join("=")}
 $$`
         : ``)
         .join("")}
@@ -75,7 +89,7 @@ const isAnswerValid = (ans, { texAnswers }) => {
 };
 const getCompareFracABWithFracAPlusCBPlusCQuestion = () => {
     const a = randint(1, 10);
-    const b = randint(1, 10);
+    const b = randint(1, 10, [a]);
     const c = randint(1, 10);
     const nodes = [frac(a, b), frac(add(a, c), add(b, c))];
     const isOrderAsc = coinFlip();

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;AAiYF,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,CAiB5D,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;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,CAiB5D,CAAC"}

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

@@ -47,7 +47,7 @@ $$
 Le classement par ordre décroissant de ces trois nombres est :`;
 };
 const getHint = () => {
-    return `Pour comparer des nombres on peut soit les écrire sous formes décimales 
+    return `Pour comparer des nombres on peut soit les écrire sous forme décimale 
   
 soit les mettre au même dénominateur.`;
 };
@@ -215,7 +215,9 @@ const getCompareFracAndDecQuestion = (optsIn) => {
     const nodes = {
         A: frac(a, 5),
         B: frac(substract(multiply(20, a), b).simplify(), 100),
-        C: frac(add(multiply(2, a), c).simplify(), 10),
+        C: frac(add(multiply(2, a), c).simplify(), 10)
+            .evaluate()
+            .toTree(),
     };
     Object.keys(nodes).forEach((letter) => {
         nodes[letter] = multiply(sign, nodes[letter]);
@@ -246,8 +248,7 @@ const getCompareFracAndDecQuestion = (optsIn) => {
                         return `
               
 $$
-${opts.isUseABC ? `${fakeName} =` : ``}
-${dictIsInDecimalFormat[trueName]
+${opts.isUseABC ? `${fakeName} =` : ``}${dictIsInDecimalFormat[trueName]
                             ? ``
                             : (() => {
                                 if (trueName === "A") {
@@ -322,7 +323,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 };
 const optsDefault = {
     isUseABC: false,
-    nbDecimalFormat: 0,
+    nbDecimalFormat: 1,
     isAllowingNegativeNumbers: false,
 };
 const options = [
@@ -338,7 +339,7 @@ const options = [
         label: "Nombre d'écritures décimales",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.select,
-        values: [0, 1, 2],
+        values: [1, 2],
         defaultValue: optsDefault.nbDecimalFormat,
     },
     {

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

@@ -1 +1 @@
-{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAqKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAmKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

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

@@ -11,10 +11,10 @@ const getInstruction = (identifiers) => {
 comparer $${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}$ et $${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}$.`;
 };
 const getHint = (identifiers) => {
-    const { a, b, isAdd } = identifiers;
+    const { a } = identifiers;
     return `En partant de $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
   
-essaie de te ramener à $${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}$ <(ou >) $${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}$
+essaie de te ramener aux expressions demandées
 
 par des opérations que l'on effectue à droite et à gauche de l'inégalité. 
 
@@ -22,7 +22,7 @@ Attention si tu multiplies à droite et à gauche d'une inégalité par un nombr
 };
 const getCorrection = (identifiers) => {
     const { a, b, isAdd } = identifiers;
-    return `
+    return `On sait que :
 
 $$
 \\sqrt{${a}} < \\sqrt{${a + 1}}
@@ -80,7 +80,7 @@ const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { a, b, isAdd } = identifiers;
     const propositions = [];
     addValidProp(propositions, `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
-    tryToAddWrongProp(propositions, `${b} ${!isAdd ? "+" : "-"} \\sqrt{${a}} ${!isAdd ? "<" : ">"} ${b} ${!isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
+    tryToAddWrongProp(propositions, `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${!isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
     return shuffleProps(propositions, nbProps);
 };
 const getKeys = (identifiers) => {

package/lib/exercises/math/calculLitteral/equation/equationFromProblem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AActE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA0mBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}
+{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAgBtE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA6qBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}