math-exercises 3.0.124 → 3.0.125

package/lib/exercises/math/calcul/arithmetics/primeNumbers.d.ts

@@ -3,7 +3,7 @@ type Identifiers = {
     nb: number;
 };
 type Options = {
-    usePowers?: boolean;
+    asPowers?: boolean;
 };
 export declare const primeNumbers: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/calcul/arithmetics/primeNumbers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primeNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/primeNumbers.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAmB9B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAmMF,KAAK,OAAO,GAAG;IACb,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAWF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBvD,CAAC"}
+{"version":3,"file":"primeNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/primeNumbers.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAmB9B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAsMF,KAAK,OAAO,GAAG;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAcF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBvD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/primeNumbers.js

@@ -26,14 +26,16 @@ const getInstruction = (identifiers) => {
   
 $$
 ${getStartStatement(identifiers)}
-$$`;
+$$
+
+`;
 };
 const getAnswer = (identifiers, opts) => {
     const { nb } = identifiers;
     const decomp = primeDecomposition(nb);
-    const usePowers = opts?.usePowers;
+    const asPowers = opts?.asPowers;
     const nodes = [];
-    if (usePowers) {
+    if (asPowers) {
         for (const d of decomp) {
             if (d.power === 1)
                 nodes.push(d.value.toTree());
@@ -50,7 +52,8 @@ const getAnswer = (identifiers, opts) => {
     }
     return operatorComposition(MultiplyNode, nodes).toTex();
 };
-const getPrimeNumbers = (opts) => {
+const getPrimeNumbers = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const rand = randint(2, 5);
     let nb = 0;
     let counter = 0;
@@ -71,16 +74,16 @@ const getPrimeNumbers = (opts) => {
 const getHint = (identifiers) => {
     return `Les premiers nombres premiers sont : $2$, $3$, $5$, $7$, $11$.
   
-Essaie de diviser le nombre $${identifiers.nb}$ par ces nombres.`;
+On peut essayer de diviser le nombre $${identifiers.nb}$ par ces nombres.`;
 };
 const getCorrection = (identifiers, opts) => {
     const { nb } = identifiers;
     let n = nb;
     const list = [];
-    const usePowers = opts?.usePowers;
-    const answerPowers = usePowers ? getAnswer(identifiers, opts) : undefined;
-    const answerNoPowers = getAnswer(identifiers, { usePowers: false });
-    const powerIsDifferent = !usePowers ? false : answerPowers !== answerNoPowers;
+    const asPowers = opts?.asPowers;
+    const answerPowers = asPowers ? getAnswer(identifiers, opts) : undefined;
+    const answerNoPowers = getAnswer(identifiers, { asPowers: false });
+    const powerIsDifferent = !asPowers ? false : answerPowers !== answerNoPowers;
     for (const k of [2, 3, 5, 7, 11]) {
         let counter = 0;
         while (n % k === 0) {
@@ -98,7 +101,7 @@ ${alignTex(list)}
 On prend alors la liste des quotients : 
 
 $$
-${nb.frenchify()} = ${answerNoPowers} ${powerIsDifferent ? `=${answerPowers}` : ""}
+${nb.frenchify()} = ${answerNoPowers} ${powerIsDifferent && asPowers ? `=${answerPowers}` : ""}
 $$
 `;
 };
@@ -152,7 +155,7 @@ const isAnswerValid = (ans, { nb }) => {
     try {
         //? aucune idée de comment, mais les élèves envoient parfois des espaces
         const parsed = parseAlgebraic(ans.replaceAll("\\ ", ""));
-        if (!isMultiplyNode(parsed))
+        if (!(isMultiplyNode(parsed) || isPowerNode(parsed)))
             return false;
         const externals = [];
         const recur = (node) => {
@@ -192,13 +195,16 @@ const isAnswerValid = (ans, { nb }) => {
         return handleVEAError(err);
     }
 };
+const optsDefault = {
+    asPowers: true,
+};
 const options = [
     {
-        id: "usePowers",
-        label: "Utiliser des puissances",
+        id: "asPowers",
+        label: "correction avec des puissances",
         target: GeneratorOptionTarget.answer,
         type: GeneratorOptionType.checkbox,
-        defaultValue: false,
+        defaultValue: optsDefault.asPowers,
     },
 ];
 export const primeNumbers = {

package/lib/exercises/math/calcul/fractions/fractionsMix.js

@@ -44,7 +44,7 @@ const getAnswer = (identifiers) => {
     return statement.simplify().toTex();
 };
 const getInstruction = (identifiers) => {
-    return `Écrire sous la forme d'une fraction irréductible : 
+    return `Écrire sous la forme d'une fraction irréductible ou d'un entier : 
   
 $$
 ${getStatement(identifiers).toTex()}

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

@@ -1 +1 @@
-{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAgIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAwIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -2,6 +2,8 @@ import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/dec
 import { randint } from "../../../math/utils/random/randint.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 { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
@@ -99,7 +101,11 @@ const getPropositions = (n, { answer, randomUnitIndex, randomUnitInstructionInde
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (ans === answer ||
+        (() => {
+            const [nodeAns, nodeAnswer] = [ans, answer].map((tex) => parseAlgebraic(tex));
+            return substract(nodeAns, nodeAnswer).evaluate() === 0;
+        })());
 };
 export const volumeConversion = {
     id: "volumeConversion",

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAmFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA2FF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.js

@@ -18,12 +18,15 @@ f(x) = ${fct.toTex()}
 $$`;
 };
 const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getAnswerNode = (identifiers) => {
     const { affine1Coeffs, affine2Coeffs } = identifiers;
     const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
     const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
     const exp = new ExpNode(affine2.toTree());
     const deriv = new MultiplyNode(new Affine(affine2.a * affine1.a, affine1.a + affine2.a * affine1.b).toTree(), exp);
-    return deriv.simplify().toTex();
+    return deriv.simplify();
 };
 const getExpDerivativeFourQuestion = () => {
     const affine1 = AffineConstructor.random();
@@ -53,12 +56,15 @@ const getPropositions = (n, { answer }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
         const parsed = parseAlgebraic(ans);
         if (!parsed)
             return false;
-        return parsed.simplify().toTex() === answer;
+        // return parsed.simplify().toTex() === answer;
+        const ansTex = parsed.simplify().toTex();
+        const ansNode = getAnswerNode(identifiers);
+        return ansNode.toAllValidTexs().includes(ansTex);
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/functions/affines/drawAffineFromLitExp.js

@@ -1,13 +1,13 @@
-import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
-import { isGGBPoint } from "../../../../exercises/utils/geogebra/isGGBPoint.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNamesFromAnswer.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
-import { Point } from "../../../../math/geometry/point.js";
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { random } from "../../../../utils/alea/random.js";
+import { isGGBLine } from "../../../../exercises/utils/geogebra/isGGBLine.js";
+import { isGGBPoint } from "../../../../exercises/utils/geogebra/isGGBPoint.js";
+import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNamesFromAnswer.js";
+import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
+import { Point } from "../../../../math/geometry/point.js";
 import { arrayEqual } from "../../../../utils/arrays/arrayEqual.js";
 const getInstruction = (identifiers) => {
     const { correctA, correctB, nameFunc } = identifiers;

package/lib/exercises/math/functions/basics/findZeroesProductQuotient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findZeroesProductQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/findZeroesProductQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAsBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AAkOF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}
+{"version":3,"file":"findZeroesProductQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/findZeroesProductQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAuBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA6QF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}

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

@@ -153,17 +153,44 @@ $$
 const getKeys = () => {
     return ["S", "equal", "lbrace", "semicolon", "rbrace"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
         const parsed = discreteSetParser(ans);
         if (!parsed)
             return false;
-        return "S=" + parsed.simplify().toTex() === answer;
+        const roots = getRoots(identifiers).map((r) => r.simplify());
+        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;
+};
 const getFindZeroesProductQuotientQuestion = () => {
     const type = randint(0, 3);
     let a = 0;

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAuNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAyOF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}

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/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"}