math-exercises 2.1.10 → 2.1.11

package/lib/exercises/math/calculLitteral/equation/binomialsTrinomialsProposedSolutions.js

@@ -44,7 +44,7 @@ const getBinomialsTrinomialsProposedSolutionsQuestion = () => {
     const answer = answertype ? "Oui" : "Non";
     const question = {
         answer: answer,
-        instruction: `Soit $x_0 = ${solution}$. Est-ce une solution de l'équation $${equation.toTex()}$ ?`,
+        instruction: `Le nombre $${solution}$ est-il une solution de l'équation $${equation.toTex()}$ ?`,
         keys: [],
         answerFormat: "raw",
         identifiers: {},
@@ -64,7 +64,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.binomialsTrinomialsProposedSolutions = {
     id: "binomialsTrinomialsProposedSolutions",
-    label: "Demander si un nombre est solution d'une équation",
+    label: "Vérifier si un nombre est solution d'une équation",
     levels: ["1rePro"],
     isSingleStep: true,
     sections: ["Équations"],

package/lib/exercises/math/calculLitteral/equation/equationFromSentenceExercise.js

@@ -127,18 +127,18 @@ const generateExercise = () => {
     switch (type) {
         case 1:
             instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver vaut $${resultNb}$"`;
+      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver vaut $${resultNb}$".`;
             break;
         case 2:
             randAdd = (0, randint_1.randint)(1, 11);
             instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `La somme` : `La différence`} du nombre à trouver et de $${randAdd}$ a pour résultat $${resultNb}$"`;
+      Traduire par une équation la phrase "${flip ? `La somme` : `La différence`} du nombre à trouver et de $${randAdd}$ a pour résultat $${resultNb}$".`;
             break;
         case 3:
             randAdd = (0, randint_1.randint)(1, 11);
             op2 = (0, coinFlip_1.coinFlip)() ? `augmenté` : `diminué`;
             instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver ${flip ? op2 : op2 + "e"} de $${randAdd}$ vaut $${resultNb}$"`;
+      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver ${flip ? op2 : op2 + "e"} de $${randAdd}$ vaut $${resultNb}$".`;
             break;
     }
     const vars = { randAdd, resultNb, op2, flip };
@@ -147,7 +147,7 @@ const generateExercise = () => {
 };
 exports.equationFromSentenceExericse = {
     id: "equationFromSentenceExercise",
-    label: "Traduire une phrase en une equation Mathématique.",
+    label: "Traduire une phrase en une équation mathématique",
     levels: ["5ème"],
     isSingleStep: true,
     sections: ["Calcul littéral"],

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

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeEquationIntType1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoEF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"firstDegreeEquationIntType1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoEF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAa7D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType1.js

@@ -52,7 +52,7 @@ const isAnswerValid = (ans, { answer, x }) => {
 };
 exports.firstDegreeEquationIntType1 = {
     id: "firstDegreeEquationIntType1",
-    label: "Résoudre une équation du premier degré du type $ax = b$ (solution entière)",
+    label: "Résoudre une équation du type $ax = b$ (solution entière)",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Équations"],

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

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeEquationIntType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6EF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"firstDegreeEquationIntType2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6EF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAa7D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType2.js

@@ -59,7 +59,7 @@ const isAnswerValid = (ans, { answer, x }) => {
 };
 exports.firstDegreeEquationIntType2 = {
     id: "firstDegreeEquationIntType2",
-    label: "Résoudre une équation du premier degré du type $ax + b = c$ (solution entière)",
+    label: "Résoudre une équation du type $ax + b = c$ (solution entière)",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Équations"],

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

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeEquationIntType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsFF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"firstDegreeEquationIntType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsFF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAa7D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquationIntType3.js

@@ -12,7 +12,7 @@ const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const getFirstDegreeEquationIntQuestion = () => {
     const a = (0, randint_1.randint)(-15, 15, [0]);
     const x = (0, randint_1.randint)(-15, 15, [0]);
-    const c = (0, randint_1.randint)(-15, 15, [0]);
+    const c = (0, randint_1.randint)(-15, 15, [0, a]);
     const d = (0, randint_1.randint)(-15, 15, [0]);
     const b = d - (a - c) * x;
     const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), x.toTree()).toTex();
@@ -65,7 +65,7 @@ const isAnswerValid = (ans, { answer, x }) => {
 };
 exports.firstDegreeEquationIntType3 = {
     id: "firstDegreeEquationIntType3",
-    label: "Résoudre une équation du premier degré du type $ax + b = cx + d$ (solution entière)",
+    label: "Résoudre une équation du type $ax + b = cx + d$ (solution entière)",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Équations"],

package/lib/exercises/math/derivation/derivative/convexityTrinomials.js

@@ -9,7 +9,7 @@ const getConvexityTrinomialsQuestion = () => {
     const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
     const question = {
         answer: isConvex,
-        instruction: `Soit la fonction $f(x) = ${trinom.toTex()}$. Est-elle :`,
+        instruction: `Soit la fonction $f(x) = ${trinom.toTex()}$. Sur $\\mathbb{R}$, $f$ est :`,
         keys: [],
         answerFormat: "raw",
         identifiers: { coeffs: trinom.coefficients },
@@ -30,7 +30,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.convexityTrinomials = {
     id: "convexityTrinomials",
-    label: "Convexité des fonctions quadratiques",
+    label: "Déterminer la convexité d'un trinôme",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/inflexionPointQuadrinomials.js

@@ -54,7 +54,7 @@ const getPropositions = (n, { answer, quadcoeffs }) => {
         }
     }
     while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-1, 2).toString());
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10).toString());
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
@@ -70,7 +70,7 @@ const isAnswerValid = (ans, { answer, quadcoeffs }) => {
 };
 exports.inflexionPointQuadrinomials = {
     id: "inflexionPointQuadrinomials",
-    label: "Calcul du point d'inflexion (quadrinôme)",
+    label: "Calcul du point d'inflexion",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/secondDerivativeOfExpoFunction.js

@@ -15,7 +15,7 @@ const getSecondDerivativeOfExpoFunctionQuestion = () => {
     const question = {
         answer: correctAnswer.toTex(),
         instruction: `Déterminer la fonction dérivée seconde $f''$ de la fonction $f$ définie par $f(x)=${funct.toTex()}$`,
-        keys: ["epower", "x"],
+        keys: ["epower", "x", "ln"],
         answerFormat: "tex",
         identifiers: { coeffs: polynom.coefficients },
     };
@@ -46,7 +46,7 @@ const generateProposition = (coeffs) => {
 };
 exports.secondDerivativeOfExpoFunction = {
     id: "secondDerivativeOfExpoFunction",
-    label: "Calcul de la dérivée seconde d'une fonction exp(u)",
+    label: "Dérivée seconde d'une fonction de type $\\exp(u)$",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/secondDerivativeOfThirdDegreeFunction.js

@@ -10,7 +10,7 @@ const getSecondDerivativeOfThirdDegreeFunction = () => {
     const correctAnswer = funct.secondDerivate().toTree();
     const instruction = `Déterminer la fonction dérivée seconde $f''$ de la fonction $f$ définie par $f(x)=${funct
         .toTree()
-        .toTex()}$`;
+        .toTex()}$.`;
     const coeff = {
         a: coefficients[3],
         b: coefficients[2],
@@ -20,7 +20,7 @@ const getSecondDerivativeOfThirdDegreeFunction = () => {
     const question = {
         answer: correctAnswer.toTex(),
         instruction: instruction,
-        keys: ["x", "power"],
+        keys: ["x"],
         answerFormat: "tex",
         identifiers: { ...coeff },
     };
@@ -47,7 +47,7 @@ const isAnswerValid = (ans, { a, b, c, d }) => {
 };
 exports.secondDerivativeOfThridDegreeFunction = {
     id: "secondDerivativeOfThirdDegreeFunction",
-    label: "Calcul de dérivée seconde d'une fonction (polynôme) de degré 3",
+    label: "Dérivée seconde d'un polynôme de degré 3",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/secondDerivativeOfTrinom.js

@@ -10,12 +10,12 @@ const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const getSecondDerivativeOfTrinomQuestion = () => {
     const trinom = trinom_1.TrinomConstructor.random();
     const trinomTree = trinom.toTree();
-    const instruction = `Déterminer la fonction dérivée seconde $f''$ de la fonction $f$ définie par $f(x)=${trinomTree.toTex()}$`;
+    const instruction = `Déterminer la fonction dérivée seconde $f''$ de la fonction $f$ définie par $f(x)=${trinomTree.toTex()}$.`;
     const correctAnswer = trinom.derivate().derivate().toTree();
     const question = {
         answer: correctAnswer.toTex(),
         instruction: instruction,
-        keys: ["power", "x"],
+        keys: ["x"],
         answerFormat: "tex",
         identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
     };
@@ -43,7 +43,7 @@ const generateProposition = (a, b, c) => {
 };
 exports.secondDerivativeOfTrinom = {
     id: "secondDerivativeOfTrinom",
-    label: "Calcul de Dérivée seconde d'un trinome",
+    label: "Dérivée seconde d'un trinôme",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/sinSecondDegreeDerivative.js

@@ -66,7 +66,7 @@ const isAnswerValid = (ans, { answer, affinecoeffs }) => {
 };
 exports.sinSecondDegreeDerivative = {
     id: "sinSecondDegreeDerivative",
-    label: "Dérivée seconde de sin(u)",
+    label: "Dérivée seconde de $\\sin(u)$",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

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

@@ -44,12 +44,12 @@ const getAffineAdjustmentQuestion = () => {
     let dataTable = `
 | | | | | | | | | | | |
 |-|-|-|-|-|-|-|-|-|-|-|
-| x | ${xValues.join(" | ")} |
-| y | ${yValues.join(" | ")} |
+| $x$ | ${xValues.join(" | ")} |
+| $y$ | ${yValues.map((n) => n.frenchify()).join(" | ")} |
   `;
     const question = {
         answer: answer,
-        instruction: `À partir des données fournies ci-dessous, déterminez l'équation de la droite d'ajustement : ${dataTable}
+        instruction: `On considère la série statistique ci-dessous. Déterminez l'équation de la droite d'ajustement obtenue par la méthode des moindres carrés. ${dataTable}
 `,
         keys: ["equal", "y", "x", "a", "b"],
         answerFormat: "tex",

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

@@ -61,12 +61,12 @@ const getAffineAdjustmentCompleteQuestion = () => {
     let dataTable = `
 | | | | | | | | | | | |
 |-|-|-|-|-|-|-|-|-|-|-|
-| x | ${xValues.join(" | ")} |
-| y | ${yValues.join(" | ")} |
+| $x$ | ${xValues.join(" | ")} |
+| $y$ | ${yValues.map((n) => n.frenchify()).join(" | ")} |
   `;
     const question = {
         answer: `${answerEq}\\qquad ${answerR}`,
-        instruction: `Déterminer l'équation de la droite d'ajustement et la valeur du coefficient de détermination avec la calculatrice. Arrondir au centième : ${dataTable}
+        instruction: `On considère la série statistique ci-dessous. A l'aide de la calculatrice, déterminer l'équation de la droite d'ajustement et la valeur du coefficient de détermination. Arrondir au centième. ${dataTable}
 `,
         keys: [],
         answerFormat: "tex",

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

@@ -49,12 +49,12 @@ const getAffineAdjustmentRsquaredQuestion = () => {
     let dataTable = `
 | | | | | | | | | | | |
 |-|-|-|-|-|-|-|-|-|-|-|
-| x | ${xValues.join(" | ")} |
-| y | ${yValues.join(" | ")} |
+| $x$ | ${xValues.join(" | ")} |
+| $y$ | ${yValues.map((n) => n.frenchify()).join(" | ")} |
   `;
     const question = {
         answer: answer,
-        instruction: `À partir des données fournies ci-dessous, déterminez la valeur du coefficient de détermination : ${dataTable}
+        instruction: `On considère la série statistique ci-dessous. Déterminez la valeur du coefficient de détermination. ${dataTable}
 `,
         keys: ["R", "equal"],
         answerFormat: "tex",

package/lib/exercises/math/functions/affines/algebricExpressionOfAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebricExpressionOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/algebricExpressionOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgDF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"algebricExpressionOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/algebricExpressionOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoDF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

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

@@ -4,6 +4,7 @@ exports.algebricExpressionOfAffine = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const affine_1 = require("../../../../math/polynomials/affine");
+const randint_1 = require("../../../../math/utils/random/randint");
 const getAlgebricExpressionOfAffineQuestion = () => {
     const f = affine_1.AffineConstructor.random();
     const a = f.a;
@@ -33,7 +34,7 @@ const isAnswerValid = (ans, { a, b }) => {
     return f.toTree().toAllValidTexs().includes(ans);
 };
 const generatePropositions = (a, b) => {
-    const firstProposition = new affine_1.Affine(b, a, "x");
+    const firstProposition = new affine_1.Affine(b !== 0 ? b : (0, randint_1.randint)(-10, 11, [0]), a, "x");
     const secondProposition = new affine_1.Affine(a, -b, "x");
     return [
         firstProposition.toTree().toTex(),
@@ -42,7 +43,7 @@ const generatePropositions = (a, b) => {
 };
 exports.algebricExpressionOfAffine = {
     id: "algebricExpressionOfAffine",
-    label: "Écrire l'expression algébrique d'une fonction affine connaissant les valeurs de son coefficient directeur et de son ordonnée à l'origine",
+    label: "Écrire l'expression algébrique d'une fonction affine",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Fonctions affines"],

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

@@ -48,7 +48,7 @@ const generateExercise = () => {
 };
 exports.leadingCoeffAndOriginOrdinate = {
     id: "leadingCoeffAndOriginOrdinate",
-    label: "A partir de l'expression algébrique d'une fonction affine, déterminer la valeur du coefficient directeur ou de l'ordonnée à l'origine.",
+    label: "Identifier le coefficient directeur ou l'ordonnée à l'origine d'une fonction affine",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Fonctions affines"],

package/lib/exercises/math/geometry/cartesian/cartesianEquationOfLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8NF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA+NF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/geometry/cartesian/cartesianEquationOfLine.js

@@ -26,7 +26,7 @@ const getCartesianEquationOfLineQuestion = () => {
     ];
     const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, { isGridSimple: true });
     const correctAnswer = line.getCartesianEquation();
-    const instruction = `Déterminer l'equation cartesienne de la droite $d$`;
+    const instruction = `Déterminer une équation cartesienne de la droite $d$ représentée ci-dessous :`;
     const aX = a.getXnumber();
     const aY = a.getYnumber();
     const bX = b.getXnumber();
@@ -52,36 +52,39 @@ const getPropositions = (n, { answer, aX, aY, bX, bY }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
     generateProposition(aX, aY, bX, bY).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value.toTex()));
-    let aXrand;
-    let aYrand;
+    let a;
+    let b;
+    const x = new variableNode_1.VariableNode("x");
+    const y = new variableNode_1.VariableNode("y");
+    let node;
     while (propositions.length < n) {
-        aXrand = (0, randint_1.randint)(-10, 11, [aX]);
-        aYrand = (0, randint_1.randint)(-10, 11, [aY]);
-        (0, exercise_1.tryToAddWrongProp)(propositions, getCorrectAnswer(aXrand, aYrand, bX, bY).toTex());
+        node = generateRandomWrongProp(aX, aY, bX, bY, x, y);
+        (0, exercise_1.tryToAddWrongProp)(propositions, node.toTex());
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const getCorrectAnswer = (aX, aY, bX, bY) => {
-    const a = new point_1.Point("A", new numberNode_1.NumberNode(aX), new numberNode_1.NumberNode(aY));
-    const b = new point_1.Point("B", new numberNode_1.NumberNode(bX), new numberNode_1.NumberNode(bY));
-    const line = new line_1.Line(a, b);
-    return line.getCartesianEquation();
+const generateRandomWrongProp = (aX, aY, bX, bY, x, y) => {
+    let a;
+    let b;
+    let c;
+    do {
+        a = (0, randint_1.randint)(-10, 11, [0]);
+        b = (0, randint_1.randint)(-10, 11, [0]);
+        c = (0, randint_1.randint)(-10, 11);
+    } while (a * aX + b * aY + c === 0 && a * bX + b * bY + c === 0);
+    return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(a.toTree(), x).simplify(), new multiplyNode_1.MultiplyNode(b.toTree(), y).simplify()), c.toTree()), zero);
 };
 const generateProposition = (aX, aY, bX, bY) => {
     const x = new variableNode_1.VariableNode("x");
     const y = new variableNode_1.VariableNode("y");
     const firstProposition = getFirstProposition(x, y, aX, aY, bX, bY);
-    const secondProposition = getSecondPropoition(x, y, aX, aY, bX, bY);
-    return [firstProposition, secondProposition];
+    return [firstProposition].filter((value) => {
+        const leftChild = value.leftChild;
+        return (leftChild.evaluate({ x: aX, y: aY }) !== 0 ||
+            leftChild.evaluate({ x: bX, y: bY }) !== 0);
+    });
 };
 const getFirstProposition = (x, y, aX, aY, bX, bY) => {
-    const u = new vector_1.Vector("u", new numberNode_1.NumberNode(bX - aX), new numberNode_1.NumberNode(bY - aY));
-    const b = u.getXAsNumber();
-    const a = -u.getYAsNumber();
-    const c = -a * aX - b * aY;
-    return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), x).simplify(), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(b), y).simplify()), new numberNode_1.NumberNode(c)), zero);
-};
-const getSecondPropoition = (x, y, aX, aY, bX, bY) => {
     const u = new vector_1.Vector("u", new numberNode_1.NumberNode(aX - bX), new numberNode_1.NumberNode(aY - bY));
     const b = -u.getXAsNumber();
     const a = u.getYAsNumber();
@@ -158,7 +161,7 @@ const getNodeFromVariableString = (str, splitter) => {
 };
 exports.cartesianEquationOfLine = {
     id: "cartesianEquationOfLine",
-    label: "Déterminer une equation cartesienne de droite",
+    label: "Déterminer une équation cartesienne de droite par lecture graphique",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Droites"],

package/lib/exercises/math/geometry/cartesian/directionVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directionVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAyHF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"directionVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAyIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/geometry/cartesian/directionVector.js

@@ -5,6 +5,7 @@ const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
 const vector_1 = require("../../../../math/geometry/vector");
+const gcd_1 = require("../../../../math/utils/arithmetic/gcd");
 const randint_1 = require("../../../../math/utils/random/randint");
 function parseVector(input) {
     const tex = input.replace("\\left", "");
@@ -19,6 +20,16 @@ function parseVector(input) {
     }
     return null;
 }
+function normalizeVector(x, y) {
+    const divisor = (0, gcd_1.gcd)(Math.abs(x), Math.abs(y));
+    let newX = x / divisor;
+    let newY = y / divisor;
+    if (newX < 0) {
+        newX = -newX;
+        newY = -newY;
+    }
+    return { x: newX, y: newY };
+}
 const getDirectionVectorQuestion = () => {
     let x1 = (0, randint_1.randint)(-8, 8);
     let x2 = (0, randint_1.randint)(-8, 8);
@@ -30,11 +41,15 @@ const getDirectionVectorQuestion = () => {
     while (y2 === y1) {
         y2 = (0, randint_1.randint)(-8, 8);
     }
-    const xValue = x2 - x1;
-    const yValue = y2 - y1;
+    const rawXValue = x2 - x1;
+    const rawYValue = y2 - y1;
+    const { x: xValue, y: yValue } = normalizeVector(rawXValue, rawYValue);
     const vector = new vector_1.Vector("v", xValue.toTree(), yValue.toTree());
-    const instruction = `Soit la droite tracée ci-dessous dans le plan cartésien. Déterminez les coordonnées d'un vecteur directeur $\\overrightarrow{v}$ de cette droite.`;
-    const commands = [`line = Line((${x1}, ${y1}), (${x2}, ${y2}))`];
+    const instruction = `Lire les coordonnées d'un vecteur directeur de la droite représentée ci-dessous :`;
+    const commands = [
+        `line = Line((${x1}, ${y1}), (${x2}, ${y2}))`,
+        `SetFixed(line, true)`,
+    ];
     const xMin = Math.min(x1, x2);
     const yMin = Math.min(y1, y2);
     const xMax = Math.max(x1, x2);
@@ -71,7 +86,10 @@ const getPropositions = (n, { answer, xValue, yValue }) => {
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer3.toInlineCoordsTex());
     }
     while (propositions.length < n) {
-        const wrongAnswer = new vector_1.Vector("v", (0, randint_1.randint)(-5, 5).toTree(), (0, randint_1.randint)(-5, 5).toTree());
+        const randomX = (0, randint_1.randint)(-5, 5);
+        const randomY = (0, randint_1.randint)(-5, 5);
+        const { x: wrongX, y: wrongY } = normalizeVector(randomX, randomY);
+        const wrongAnswer = new vector_1.Vector("v", wrongX.toTree(), wrongY.toTree());
         if (wrongAnswer.isColinear(vector) === false) {
             (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toInlineCoordsTex());
         }

package/lib/exercises/math/geometry/cartesian/directionVectorEquation.js

@@ -41,7 +41,7 @@ const getDirectionVectorEquationQuestion = () => {
     const equation = new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(yValue.toTree(), new variableNode_1.VariableNode("x")), new multiplyNode_1.MultiplyNode((-xValue).toTree(), new variableNode_1.VariableNode("y"))).simplify({ forbidFactorize: true }), c.toTree()), new numberNode_1.NumberNode(0)).toTex();
     const question = {
         answer: vector.toInlineCoordsTex(),
-        instruction: `Soit l'équation cartésienne $${equation}$. Déterminez les coordonnées d'un vecteur directeur $\\overrightarrow{v}$ de cette équation.`,
+        instruction: `Soit une droite $d$ d'équation cartésienne $${equation}$. Déterminez les coordonnées d'un vecteur directeur de $d$.`,
         keys: ["semicolon", "x", "y"],
         answerFormat: "tex",
         identifiers: { xValue, yValue },

package/lib/exercises/math/geometry/cartesian/pointCoordinates.js

@@ -13,7 +13,7 @@ const getPointCoordinatesQuestion = () => {
     const xMax = Math.max(x) + 5;
     const yMin = Math.min(y) - 5;
     const yMax = Math.max(y) + 5;
-    const instruction = `Déterminez les coordonnées du point A dans le repère ci-dessous : `;
+    const instruction = `Lire les coordonnées du point $A$ représenté dans le repère ci-dessous : `;
     const commands = [
         `A = (${x}, ${y})`,
         `ShowLabel(A, true)`,
@@ -63,7 +63,7 @@ const isAnswerValid = (ans, { answer, x, y }) => {
 };
 exports.pointCoordinates = {
     id: "pointCoordinates",
-    label: "Déterminer les coordonnées d'un point dans un repère",
+    label: "Lire les coordonnées d'un point",
     levels: ["1rePro"],
     isSingleStep: true,
     sections: ["Géométrie cartésienne"],

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
     askConvex: boolean;
     quadcoeffs: number[];
+    inflexionPoint: number;
 };
 export declare const convexityQuadrinomialsGeo: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAoBlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAkMF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"convexityQuadrinomialsGeo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAoBlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAmMF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/geometry/convexity/convexityQuadrinomialsGeo.js

@@ -61,7 +61,7 @@ const getConvexityQuadrinomialsGeoQuestion = () => {
                 : new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, inflexionPointX.toTree(), closure_1.ClosureType.OO).toTex();
     }
     const questionType = askConvex ? "convexe" : "concave";
-    const instruction = `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$. Sur quel intervalle est-elle ${questionType} ?`;
+    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur quel intervalle $f$ est-elle ${questionType} ?`;
     const commands = [
         `f(x) = ${quadrinomial.toString()}`,
         `SetColor(f, "${colors_1.blueMain}")`,
@@ -80,7 +80,7 @@ const getConvexityQuadrinomialsGeoQuestion = () => {
         options: ggb.getOptions(),
         keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
         answerFormat: "tex",
-        identifiers: { askConvex, quadcoeffs },
+        identifiers: { askConvex, quadcoeffs, inflexionPoint: inflexionPointX },
     };
     return question;
 };
@@ -101,8 +101,7 @@ const getPropositions = (n, { answer, quadcoeffs }) => {
     (0, exercise_1.tryToAddWrongProp)(propositions, wrongInterval4);
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { askConvex, quadcoeffs }) => {
-    const inflexionPoint = -quadcoeffs[2] / (3 * quadcoeffs[3]);
+const isAnswerValid = (ans, { askConvex, quadcoeffs, inflexionPoint }) => {
     let interval;
     if (askConvex) {
         interval =
@@ -116,12 +115,12 @@ const isAnswerValid = (ans, { askConvex, quadcoeffs }) => {
                 ? new intervalNode_1.IntervalNode(inflexionPoint.toTree(), infiniteNode_1.PlusInfinityNode, closure_1.ClosureType.OO)
                 : new intervalNode_1.IntervalNode(infiniteNode_1.MinusInfinityNode, inflexionPoint.toTree(), closure_1.ClosureType.OO);
     }
-    const latexs = interval.toAllValidTexs({ allowFractionToDecimal: true });
+    const latexs = interval.toAllValidTexs({});
     return latexs.includes(ans);
 };
 exports.convexityQuadrinomialsGeo = {
     id: "convexityQuadrinomialsGeo",
-    label: "Convexité des fonctions polynomiales de degré 3 (Geogebra)",
+    label: "Déterminer graphiquement la convexité d'un polynôme de degré $3$",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/geometry/convexity/convexityTrinomialsGeo.js

@@ -8,7 +8,7 @@ const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor"
 const trinom_1 = require("../../../../math/polynomials/trinom");
 const getConvexityTrinomialsGeoQuestion = () => {
     const trinom = trinom_1.TrinomConstructor.random();
-    const instruction = `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$. Est-elle :`;
+    const instruction = `Ci-dessous est tracée la courbe représentative $\\mathcal C_f$ d'une fonction $f$. Sur $\\mathbb{R}$, la fonction $f$ est :`;
     const commands = [
         `f(x) = ${trinom.toString()}`,
         `SetColor(f, "${colors_1.blueMain}")`,
@@ -46,7 +46,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.convexityTrinomialsGeo = {
     id: "convexityTrinomialsGeo",
-    label: "Convexité des fonctions quadratiques (GeoGebra)",
+    label: "Déterminer graphiquement la convexité d'un trinôme",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

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

@@ -20,7 +20,7 @@ const getLineFromDirectorVectorQuestion = () => {
     const b = new point_1.Point("b", new numberNode_1.NumberNode(a.getXnumber() - u.getXAsNumber()), new numberNode_1.NumberNode(a.getYnumber() - u.getYAsNumber()));
     const line = new line_1.Line(b, a);
     const correctAnswer = line.getEquation(u, a);
-    const instruction = `Soit $d$ une droite de vecteur directeur $${u.toTexWithCoords()}$ passant par le point $${a.toTexWithCoords()}$. Déterminer l'équation réduite de la droite $d$`;
+    const instruction = `Soit $d$ une droite de vecteur directeur $${u.toTexWithCoords()}$ passant par le point $${a.toTexWithCoords()}$. Déterminer l'équation réduite de la droite $d$.`;
     const question = {
         answer: correctAnswer.toTex(),
         instruction: instruction,
@@ -99,7 +99,7 @@ const getCorrecAnswer = (uX, uY, aX, aY) => {
 };
 exports.lineFromDirectorVector = {
     id: "lineFromDirectorVector",
-    label: "Équation réduite de droite connaissant un point et un vecteur directeur",
+    label: "Équation réduite d'une droite connaissant un point et un vecteur directeur",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Droites"],

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

@@ -1 +1 @@
-{"version":3,"file":"vectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"vectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+CF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

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

@@ -8,7 +8,6 @@ const real_1 = require("../../../../math/numbers/reals/real");
 const sqrtNode_1 = require("../../../../tree/nodes/functions/sqrtNode");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
-const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const getVectorNormCalculationQuestion = () => {
     const u = vector_1.VectorConstructor.random("u", false);
     const x = u.x.simplify().value;
@@ -43,8 +42,10 @@ const generateProposition = (x, y) => {
     return [firstProposition];
 };
 const isAnswerValid = (ans, { x, y }) => {
-    const correctAnswer = new sqrtNode_1.SqrtNode(new addNode_1.AddNode(new powerNode_1.SquareNode(new numberNode_1.NumberNode(x)), new powerNode_1.SquareNode(new numberNode_1.NumberNode(y))));
-    return correctAnswer.simplify().toAllValidTexs().includes(ans);
+    const correctAnswer = new sqrtNode_1.SqrtNode((x ** 2 + y ** 2).toTree());
+    return correctAnswer
+        .toAllValidTexs({ allowSimplifySqrt: true })
+        .includes(ans);
 };
 exports.vectorNormCalculation = {
     id: "vectorNormCalculation",

package/lib/exercises/math/probaStat/stats2var/fineAdjustementExercise.js

@@ -33,7 +33,7 @@ const getFineAdjustementExerciseQuestion = () => {
     const yMax = Math.max(...yValues);
     const question = {
         answer: exercise.correctAnswer,
-        instruction: `À l'aide du graphique ci-dessous, choisir la bonne réponse`,
+        instruction: `On considère le nuage de points ci-dessous. Choisir la bonne réponse.`,
         commands: ggb.commands,
         options: ggb.getOptions(),
         coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),

package/lib/exercises/math/python/conditionIf.d.ts

@@ -3,6 +3,7 @@ type Identifiers = {
     a: number;
     b: number;
     opresult: number;
+    condition: string;
 };
 export declare const conditionIf: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/python/conditionIf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditionIf.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/conditionIf.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA8DF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"conditionIf.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/conditionIf.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiEF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}

package/lib/exercises/math/python/conditionIf.js

@@ -16,7 +16,11 @@ const getConditionIfQuestion = () => {
     const opIndex = (0, randint_1.randint)(0, operations.length);
     const operation = operations[opIndex];
     const opresult = operation.func(a, b);
-    const answer = opresult <= b ? b : opresult;
+    // Choisir aléatoirement entre les deux conditions
+    const condition = (0, randint_1.randint)(0, 2) === 0 ? "a <= b" : "b <= a";
+    const answer = (condition === "a <= b" ? opresult <= b : opresult >= b)
+        ? b
+        : opresult;
     const question = {
         answer: answer.toString(),
         instruction: `Quel sera l'affichage du code suivant ?
@@ -24,14 +28,14 @@ const getConditionIfQuestion = () => {
 a = ${a}
 b = ${b}
 a = a ${operation.name} b
-if a<=b :
+if ${condition} :
     a = b
 print(a)
 \`\`\`
 `,
         keys: ["a", "b", "equal"],
         answerFormat: "tex",
-        identifiers: { a, b, opresult },
+        identifiers: { a, b, opresult, condition },
     };
     return question;
 };
@@ -42,9 +46,7 @@ const getPropositions = (n, { answer, a, b, opresult }) => {
     (0, exercise_1.tryToAddWrongProp)(propositions, b.toString());
     (0, exercise_1.tryToAddWrongProp)(propositions, opresult.toString());
     while (propositions.length < n) {
-        while (propositions.length < n) {
-            (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(0, 10).toString());
-        }
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(0, 10).toString());
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };

package/lib/exercises/math/python/pyForLoop1Exercise.js

@@ -131,7 +131,7 @@ const isAnswerValid = (ans, { exercise }) => {
 };
 exports.pythonForLoop1Exercise = {
     id: "pyForLoop1Exercise",
-    label: "Exercice python sur les boucle for 1",
+    label: "Boucles for 1",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/pyNestedForLoopExercise.js

@@ -71,7 +71,7 @@ const getCorrectAnswer = (exo) => {
 };
 exports.pyNestedForLoopExercise = {
     id: "pyNestedForLoopExercise",
-    label: "Exercise sur les boucles for imbriquée en python",
+    label: "Boucles for imbriquées",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/pyWhileLoop1Exercise.js

@@ -101,7 +101,7 @@ const generateType17Instruction = (a, b, op) => {
 };
 exports.pyWhileLoop1Exercise = {
     id: "pyWhileLoop1Exercise",
-    label: "Exercise sur les boules while 1 en python",
+    label: "Boucles while 1",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/index.d.ts

@@ -836,6 +836,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     askConvex: boolean;
     quadcoeffs: number[];
+    inflexionPoint: number;
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;
@@ -1245,6 +1246,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     opresult: number;
+    condition: string;
 }> | import("./exercises/exercise").Exercise<{
     exercise: {
         op: string;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/tree/nodes/functions/sqrtNode.d.ts

@@ -12,7 +12,7 @@ export declare class SqrtNode implements FunctionNode {
     toMathString(): string;
     toTex(): string;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
-    toAllValidTexs(): string[];
+    toAllValidTexs(opts?: NodeOptions): string[];
     evaluate(vars: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;
     equals(node: AlgebraicNode): boolean;

package/lib/tree/nodes/functions/sqrtNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AACD,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,IAAI,MAAM,EAAE;IAG1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAmC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}
+{"version":3,"file":"sqrtNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/sqrtNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK5E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAElE,wBAAgB,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,QAAQ,CAEjD;AACD,qBAAa,QAAS,YAAW,YAAY;IAC3C,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,WAAW;IAOpD,YAAY,IAAI,MAAM;IAMtB,KAAK,IAAI,MAAM;IAIf,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAwBtD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGrC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAmC/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;CAGrC"}

package/lib/tree/nodes/functions/sqrtNode.js

@@ -49,8 +49,8 @@ class SqrtNode {
         }
         return res;
     }
-    toAllValidTexs() {
-        return this.toEquivalentNodes().map((node) => node.toTex());
+    toAllValidTexs(opts) {
+        return this.toEquivalentNodes(opts).map((node) => node.toTex());
     }
     evaluate(vars) {
         return Math.sqrt(this.child.evaluate(vars));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [