math-exercises 3.0.123 → 3.0.125

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.js

@@ -56,74 +56,85 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getInverseImageFunctionGeogebra = () => {
-    const isLine = coinFlip();
-    const hasAntecedent = probaFlip(0.8);
-    // const isLine = false;
-    // const hasAntecedent = true;
-    let yValue;
-    const points = [];
-    if (isLine) {
-        if (hasAntecedent) {
-            yValue = randint(-6, 7);
-            const xIsDecimal = probaFlip(0.3);
-            const xValue = xIsDecimal
-                ? randfloat(-6, 7, 2, [yValue])
-                : randint(-6, 7, [yValue]);
-            const wrongY = randint(-6, 7);
-            points.push([xValue, yValue], [yValue, wrongY]);
-        }
-        else {
-            yValue = randint(-6, 7, [0]);
-            const constante = randint(-6, 7, [yValue]);
-            points.push([0, constante], [1, constante]);
-        }
-    }
-    else {
-        if (hasAntecedent) {
-            yValue = randint(-6, 7);
-            const xIsDecimal = coinFlip();
-            const xValue = xIsDecimal
-                ? randfloat(-6, 7, 2, [yValue])
-                : randint(-6, 7, [yValue]);
-            const hasTwoAntecedents = probaFlip(0.8);
-            if (hasTwoAntecedents) {
-                const wrongY = randint(-6, 7, [yValue]);
-                const secondAntecedentPoint = [
-                    randint(-6, 7, [xValue, yValue]),
-                    yValue,
-                ];
-                points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+    function generateIdentifiers() {
+        const isLine = coinFlip();
+        const hasAntecedent = probaFlip(0.8);
+        // const isLine = false;
+        // const hasAntecedent = true;
+        let yValue;
+        const points = [];
+        if (isLine) {
+            if (hasAntecedent) {
+                yValue = randint(-6, 7);
+                const xIsDecimal = probaFlip(0.3);
+                const xValue = xIsDecimal
+                    ? randfloat(-6, 7, 2, [yValue])
+                    : randint(-6, 7, [yValue]);
+                const wrongY = randint(-6, 7);
+                points.push([xValue, yValue], [yValue, wrongY]);
             }
             else {
-                //(x,y) is summit
-                const wrongY = randint(-6, 7, [yValue]);
-                points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+                yValue = randint(-6, 7, [0]);
+                const constante = randint(-6, 7, [yValue]);
+                points.push([0, constante], [1, constante]);
             }
         }
         else {
-            yValue = randint(-8, 9);
-            const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
-            const below = wrongY < yValue;
-            const summit = [
-                randint(-6, 7, [yValue]),
-                below
-                    ? randint(wrongY + 1, yValue, [wrongY])
-                    : randint(yValue + 1, wrongY, [wrongY]),
-            ];
-            const thirdPoint = [2 * summit[0] - yValue, wrongY];
-            //construire deux autrs points au pif avec y sous/audssu yValus
-            points.push([yValue, wrongY], summit, thirdPoint);
+            if (hasAntecedent) {
+                yValue = randint(-6, 7);
+                const xIsDecimal = coinFlip();
+                const xValue = xIsDecimal
+                    ? randfloat(-6, 7, 2, [yValue])
+                    : randint(-6, 7, [yValue]);
+                const hasTwoAntecedents = probaFlip(0.8);
+                if (hasTwoAntecedents) {
+                    const wrongY = randint(-6, 7, [yValue]);
+                    const secondAntecedentPoint = [
+                        randint(-6, 7, [xValue, yValue]),
+                        yValue,
+                    ];
+                    points.push([xValue, yValue], [yValue, wrongY], secondAntecedentPoint);
+                }
+                else {
+                    //(x,y) is summit
+                    const wrongY = randint(-6, 7, [yValue]);
+                    points.push([xValue, yValue], [yValue, wrongY], [2 * xValue - yValue, wrongY]);
+                }
+            }
+            else {
+                yValue = randint(-8, 9);
+                const wrongY = randint(-3, 4, [yValue, yValue - 1, yValue + 1]);
+                const below = wrongY < yValue;
+                const summit = [
+                    randint(-6, 7, [yValue]),
+                    below
+                        ? randint(wrongY + 1, yValue, [wrongY])
+                        : randint(yValue + 1, wrongY, [wrongY]),
+                ];
+                const thirdPoint = [2 * summit[0] - yValue, wrongY];
+                //construire deux autrs points au pif avec y sous/audssu yValus
+                points.push([yValue, wrongY], summit, thirdPoint);
+            }
         }
+        points.sort((p1, p2) => p1[0] - p2[0]);
+        const identifiers = {
+            // xValue,
+            // affineCoeffs: isAffine ? affine!.coefficients : undefined,
+            // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
+            yValue,
+            points,
+            // isAffine,
+        };
+        return identifiers;
     }
-    points.sort((p1, p2) => p1[0] - p2[0]);
-    const identifiers = {
-        // xValue,
-        // affineCoeffs: isAffine ? affine!.coefficients : undefined,
-        // trinomCoeffs: isAffine ? undefined : trinom!.coefficients,
-        yValue,
-        points,
-        // isAffine,
-    };
+    function isInfinityOfSolutions(identifiers) {
+        const { yValue, points } = identifiers;
+        return points.every((point) => point[1] === yValue);
+    }
+    let identifiers;
+    do {
+        identifiers = generateIdentifiers();
+    } while (isInfinityOfSolutions(identifiers));
     return getQuestionFromIdentifiers(identifiers);
 };
 const getHint = (identifiers) => {

package/lib/exercises/math/functions/logarithm/powerEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/powerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoJF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAUF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxD,CAAC"}
+{"version":3,"file":"powerEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/powerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAUF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBxD,CAAC"}

package/lib/exercises/math/functions/logarithm/powerEquation.js

@@ -90,7 +90,6 @@ const isAnswerValid = (ans, { answer }) => {
         const parsed = parseAlgebraic(ans);
         const value = parsed.evaluate();
         const answerValue = parseAlgebraic(answer).evaluate();
-        console.log(value, answerValue);
         if (Math.abs(value - answerValue) < 0.01)
             return true;
         return parsed.simplify().toTex() === answer;

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"rootsFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsFromDevForm.js

@@ -2,9 +2,11 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exer
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
-import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { a, b, c } = identifiers;
     const trinom = new Trinom(a, b, c);
@@ -49,20 +51,43 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { a, b, c }) => {
-    // try {
-    //   const parsed = discreteSetParser(ans);
-    //   if (!parsed) return false;
-    //   return (
-    //     "S=" + parsed.simplify({ decimalToFractions: true }).toTex() === answer
-    //   );
-    // } catch (err) {
-    //   return handleVEAError(err);
-    // }
-    const trinom = new Trinom(a, b, c);
-    const roots = trinom.getRootsNode();
-    const answer = new EquationSolutionNode(new DiscreteSetNode(roots));
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        const trinom = new Trinom(a, b, c);
+        const roots = trinom.getRootsNode();
+        return isArrayOfNodesValid(parsed.elements, roots);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const isArrayOfNodesValid = (arrAns, arrAnswer) => {
+    //tried with toAllValidTexs() but there is always an unhandled case
+    function isNodesEqual(node1, node2) {
+        return [1, 1_000, 1_000_000].every((factor) => substract(multiply(factor, node1), multiply(factor, node2)).evaluate() === 0);
+    }
+    const dictAnswer = Object.fromEntries(arrAnswer.map((node, i) => [i, node]));
+    let isValid = true;
+    for (let i = 0; i < arrAns.length; i++) {
+        const nodeAns = arrAns[i];
+        let isFound = false;
+        const keys = Object.keys(dictAnswer);
+        for (let j = 0; j < keys.length; j++) {
+            const key = keys[j];
+            const answerNode = dictAnswer[key];
+            if (isNodesEqual(nodeAns, answerNode)) {
+                isFound = true;
+                delete dictAnswer[key]; //one-to-one correspondence
+                break;
+            }
+        }
+        isValid = isValid && isFound;
+        if (!isValid)
+            break;
+    }
+    return isValid;
 };
 export const rootsFromDevForm = {
     id: "rootsFromDevForm",

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsReading.js

@@ -80,8 +80,9 @@ const isAnswerValid = (ans, { a, b, c }) => {
         return ans === "\\text{Aucun}";
     }
     const studentNumbers = ans
-        .replaceAll("\\text{ }", "")
-        .split("\\text{ et }")
+        .replaceAll("\\text{", "")
+        .replaceAll("}", "") //as long as there's no \\frac{}{} involved, it's ok
+        .split("et")
         .map((n) => Number(n.replace(",", ".")))
         .filter((n) => !isNaN(n))
         .sort((a, b) => a - b);

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../../exercises/exercise.js";
 type Identifiers = {
     trinomCoeffs: number[];
     isAskingPositive: boolean;
+    isStrict: boolean;
 };
 export declare const trinomSignFromFacto: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinomSignFromFacto.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignFromFacto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAyHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAqBrD,CAAC"}
+{"version":3,"file":"trinomSignFromFacto.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/sign/trinomSignFromFacto.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAgJF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAqBrD,CAAC"}

package/lib/exercises/math/functions/trinoms/sign/trinomSignFromFacto.js

@@ -8,11 +8,12 @@ import { UnionIntervalNode } from "../../../../../tree/nodes/sets/unionIntervalN
 import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { unionIntervalParser } from "../../../../../tree/parsers/unionIntervalParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
-const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive }) => {
+const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive, isStrict }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
-    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive: !isAskingPositive }));
+    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive: !isAskingPositive, isStrict }));
+    tryToAddWrongProp(propositions, getAnswer({ trinomCoeffs, isAskingPositive, isStrict: !isStrict }));
     tryToAddWrongProp(propositions, new IntervalNode(trinom.a, trinom.b, ClosureType.FF).toTex());
     propWhile(propositions, n, () => {
         const interval = IntervalNodeConstructor.random();
@@ -21,36 +22,41 @@ const getPropositions = (n, { answer, trinomCoeffs, isAskingPositive }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswerNode = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     const roots = trinom.getRoots();
-    const a = identifiers.trinomCoeffs[2];
-    return a > 0 === identifiers.isAskingPositive
+    const a = trinomCoeffs[2];
+    return a > 0 === isAskingPositive
         ? new UnionIntervalNode([
-            new IntervalNode(MinusInfinityNode, roots[0], ClosureType.OF),
-            new IntervalNode(roots[1], PlusInfinityNode, ClosureType.FO),
+            new IntervalNode(MinusInfinityNode, roots[0], isStrict ? ClosureType.OO : ClosureType.OF),
+            new IntervalNode(roots[1], PlusInfinityNode, isStrict ? ClosureType.OO : ClosureType.FO),
         ])
-        : new IntervalNode(roots[0], roots[1], ClosureType.FF);
+        : new IntervalNode(roots[0], roots[1], isStrict ? ClosureType.OO : ClosureType.FF);
 };
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
 const getInstruction = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     return `Soit $f$ une fonction polynôme de degré $2$ définie sur $\\mathbb{R}$ par :
   
 $$
 f(x) = ${trinom.toFactorized().toTex()}
 $$
 
-Sur quel(s) intervalle(s) les valeurs de la fonction $f$ sont-elles ${identifiers.isAskingPositive ? "positives" : "négatives"} ?`;
+Sur quel(s) intervalle(s) les valeurs de la fonction $f$ sont-elles 
+${isStrict ? "strictement" : ""} ${isAskingPositive ? "positives" : "négatives"} 
+?`;
 };
 const getHint = () => {
     return `Une fonction polynôme de degré $2$ est du signe de son coefficient $a$, sauf entre ses racines.`;
 };
 const getCorrection = (identifiers) => {
-    const trinom = TrinomNodeConstructor.fromCoeffs(identifiers.trinomCoeffs);
+    const { trinomCoeffs, isAskingPositive, isStrict } = identifiers;
+    const trinom = TrinomNodeConstructor.fromCoeffs(trinomCoeffs);
     const roots = trinom.getRoots();
-    const a = identifiers.trinomCoeffs[2];
+    const a = trinomCoeffs[2];
     const answer = getAnswer(identifiers);
     const ineqSign = a > 0 ? ">" : "<";
     const sign = a > 0 ? "positive" : "négative";
@@ -60,7 +66,7 @@ Ici, $a = ${a}${ineqSign}0$, et les racines de $f$ sont $${roots[0].toTex()}$ et
 
 $f$ est donc ${sign} sauf sur l'intervalle $${new IntervalNode(roots[0], roots[1], ClosureType.FF).toTex()}$.
 
-On en déduit que $f$ est ${identifiers.isAskingPositive ? "positive" : "négative"} sur : 
+On en déduit que $f$ est ${isStrict ? "strictement" : ""} ${isAskingPositive ? "positive" : "négative"} sur : 
   
 $$
 ${answer}
@@ -83,8 +89,10 @@ const isAnswerValid = (ans, { answer }) => {
 const getTrinomSignFromFactoQuestion = () => {
     const trinom = TrinomNodeConstructor.randomNiceRoots(2);
     const isAskingPositive = coinFlip();
+    const isStrict = coinFlip();
     const identifiers = {
         isAskingPositive,
+        isStrict,
         trinomCoeffs: trinom.getCoeffs(),
     };
     return getQuestionFromIdentifiers(identifiers);

package/lib/exercises/math/geometry/perimeters/circleCircumference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2GF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/geometry/perimeters/circleCircumference.js

@@ -2,6 +2,8 @@ import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.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 getInstruction = (identifiers) => {
@@ -10,14 +12,15 @@ const getInstruction = (identifiers) => {
         ? "rayon " + `$${radius}\\ \\textrm{cm}$`
         : "diamètre " + `$${diametre} \\ \\textrm{cm}$`} (arrondir au centième de $\\textrm{cm}$).`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { coin, radius, diametre } = identifiers;
     const answerNb = coin
         ? round(2 * Math.PI * radius, 2)
         : round(Math.PI * diametre, 2);
-    const answer = answerNb.frenchify();
-    const answerTex = answer + "\\text{cm}";
-    return answerTex;
+    return answerNb.toTree();
+};
+const getAnswer = (identifiers) => {
+    return `${getAnswerNode(identifiers).toTex()} \\text{cm}`;
 };
 const getHint = () => {
     return `Le périmètre d'un cercle de rayon $r$ est donné par : 
@@ -79,9 +82,14 @@ const getPropositions = (n, { answer }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer }) => {
-    const texs = [answer, answer.split("\\text")[0]];
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    if (ans.includes("\\text{cm}^2")) {
+        return false;
+    }
+    const refinedAns = ans.replace("\\text{cm}", "");
+    const ansNode = parseAlgebraic(refinedAns);
+    const answerNode = getAnswerNode(identifiers);
+    return substract(ansNode, answerNode).evaluate() === 0;
 };
 export const circleCircumference = {
     id: "circleCircumference",

package/lib/exercises/math/geometry/shapes/basicShapesNaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC;CAC/D,CAAC;AAiKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,cAAc,EACf,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,GAAG,cAAc,GAAG,eAAe,CAAC;CAC/D,CAAC;AAmKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

package/lib/exercises/math/geometry/shapes/basicShapesNaming.js

@@ -31,7 +31,7 @@ const getAnswer = (identifiers) => {
             break;
         case 3: //droite
         default:
-            return obj.toTexNoLeftRight();
+            return `(${obj.toTexNoLeftRight()})`;
             break;
     }
 };
@@ -105,12 +105,14 @@ const getBasicShapesNamingQuestion = () => {
     const type = randint(1, 4);
     let objIds;
     switch (type) {
-        case 1: { //segment
+        case 1: {
+            //segment
             const segment = SegmentConstructor.random();
             objIds = segment.toIdentifiers();
             break;
         }
-        case 2: { //demi-droite
+        case 2: {
+            //demi-droite
             const ray = RayConstructor.random();
             objIds = ray.toIdentifiers();
             break;

package/lib/exercises/math/geometry/vectors/vectorLinearCombination.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorLinearCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsNF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"vectorLinearCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqNF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/geometry/vectors/vectorLinearCombination.js

@@ -154,7 +154,6 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
             if (!isBinomialCoefficientNode(parsed))
                 return false;
             const vec = new Vector("u", parsed.leftChild, parsed.rightChild);
-            console.log(solVector.toCoords(), vec.toCoords());
             return solVector.simplify().toCoords() === vec.toCoords();
         }
         else {

package/lib/exercises/math/percent/evolutions/evolutionToCM.js

@@ -32,7 +32,7 @@ $$
 1${isHausse ? "+" : "-"}\\frac{${Math.abs(evolution)}}{100} = ${CM}
 $$
 
-    `;
+`;
 };
 const getEvolutionToCmQuestion = () => {
     const evolution = randint(-99, 101, [0]);
@@ -43,7 +43,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["percent"],
+        keys: [],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),

package/lib/exercises/math/percent/findProportion.d.ts

@@ -1,8 +1,13 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
+    indexSituation: number;
     total: number;
     lefties: number;
+    opts: Options;
 };
-export declare const findProportion: Exercise<Identifiers>;
+type Options = {
+    isPercentSymbolRequired: boolean;
+};
+export declare const findProportion: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=findProportion.d.ts.map

package/lib/exercises/math/percent/findProportion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,uBAAuB,EAAE,OAAO,CAAC;CAClC,CAAC;AAeF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBzD,CAAC"}