math-exercises 3.0.62 → 3.0.63

package/lib/exercises/math/calculLitteral/distributivity/simpleDistri.js

@@ -29,7 +29,7 @@ const getAnswer = (identifiers) => {
     return affine.times(coeff).toTree().toTex();
 };
 const getHint = (identifiers) => {
-    return `Multiplie chaque terme dans la parenthèse par $${identifiers.coeff}$.`;
+    return `Multiplie chaque terme de la parenthèse par $${identifiers.coeff}$.`;
 };
 const getCorrection = (identifiers) => {
     const { a, b, coeff } = identifiers;

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

@@ -31,9 +31,9 @@ $$`;
 const getHint = (identifiers) => {
     return `L'équation $x^2 = k$ : 
     
-- n'admet pas de solution si $k<0$, 
-- admet une solution si $k=0$, qui est $0$
-- admet deux solutions si $k>0$, qui sont $-\\sqrt{k}$ et $\\sqrt{k}$
+- n'admet pas de solution si $k<0$ ;
+- admet une solution si $k=0$, qui est $0$ ;
+- admet deux solutions si $k>0$, qui sont $-\\sqrt{k}$ et $\\sqrt{k}$.
     `;
 };
 const getAnswer = (identifiers) => {

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.js

@@ -35,11 +35,11 @@ const getBasicSystemResolutionQuestion = () => {
     return getQuestionFromIdentifiers(identifiers);
 };
 const getHint = (identifiers) => {
-    return `On peut utilise la méthode par substitution ou bien celle par combinaison : 
+    return `Utilise la méthode par substitution ou bien celle par combinaison : 
   
-- Si une des variables est facile à isoler dans une des équations, alors on utilise la méthode par substitution : on isole cette variable, puis on injecte le résultat obtenu dans l'autre équation.
+- Si une des variables est facile à isoler dans une des équations, alors utilise la méthode par substitution : isole cette variable, puis injecte le résultat obtenu dans l'autre équation.
 
-- Sinon, on utilise la méthode par combinaison : on multiple une (ou les deux) équation(s) par un nombre, afin que lorsqu'on additionne les deux équations, une des variables disparaisse.`;
+- Sinon, utilise la méthode par combinaison : multiple une (ou les deux) équation(s) par un nombre, afin que, lorsqu'on additionne les deux équations, une des variables disparaisse.`;
 };
 const getCorrection = (identifiers) => {
     const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}
+{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.js

@@ -47,7 +47,7 @@ const getVerifySystemSolutionQuestion = () => {
 const getHint = (identifiers) => {
     return `On remplace $x$ par $${identifiers.x}$ et $y$ par $${identifiers.y}$ dans les deux équations.
   
-Si les deux égalités sont vraies, alors le couple est bien une solution du système. Sinon, ce n'en est pas une.`;
+Si les deux égalités sont vraies, alors le couple est bien une solution du système d'équations. Sinon, ce n'en est pas une.`;
 };
 const getCorrection = (identifiers) => {
     const { sysIds, x, y } = identifiers;
@@ -60,33 +60,31 @@ const getCorrection = (identifiers) => {
     const equasDetailedSimp = equasDetailed.map((e) => e.simplify());
     const firstIsTrue = equasDetailedSimp[0].isVerified();
     const secondIsTrue = equasDetailedSimp[1].isVerified();
-    return `On remplace $x$ par $${x}$ et $y$ par $${y}$ dans les deux équations :
+    return `On remplace $x$ par $${x}$ et $y$ par $${y}$ dans les deux équations.
   
 $$
 ${equasDetailed[0].leftChild.toTex()} = ${equasDetailedSimp[0].leftChild.toTex()}
 $$
 
 ${firstIsTrue
-        ? "La première équation est donc bien vérifiée."
-        : "La première équation n'est donc pas vérifiée : le couple n'est donc pas une solution du système."}
+        ? "La première égalité est donc vraie."
+        : "La première égalité n'est donc pas vraie : le couple n'est donc pas une solution du système d'équations."}
 
 ${firstIsTrue
         ? `
-  
-On vérifie maintenant la deuxième équation : 
 
 $$
 ${equasDetailed[1].leftChild.toTex()} = ${equasDetailedSimp[1].leftChild.toTex()}
 $$
 
 ${secondIsTrue
-            ? "La deuxième équation est donc bien vérifiée."
-            : "La deuxième équation n'est donc pas vérifiée : le couple n'est donc pas une solution du système."}
+            ? "La deuxième égalité est donc vraie."
+            : "La deuxième égalité n'est donc pas vraie : le couple n'est donc pas une solution du système d'équations."}
 `
         : ""}
 
 ${firstIsTrue && secondIsTrue
-        ? "Les deux équations sont donc bien vérifiées : le couple est bien une solution du système."
+        ? "Les deux égalités sont donc vraies : le couple est bien une solution du système d'équations."
         : ""}
 `;
 };

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

@@ -48,7 +48,7 @@ Il suffit alors de multiplier $${randomAera.frenchify()}$ par $${coeff.toTex()}$
 
 ${alignTex([
         [
-            `${randomAera.frenchify()} \\textrm{${unit}}^2 `,
+            `${randomAera.frenchify()}\\  \\textrm{${unit}}^2 `,
             "=",
             `${multiply(coeff, randomAera).toTex()}\\ \\textrm{${target}}^2`,
         ],

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

@@ -24,7 +24,7 @@ const getInstruction = (identifiers) => {
     return `Compléter : 
 
 $$
-${randomCapacity.frenchify()} \\textrm{${units[randomUnitIndex]}} = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}
+${randomCapacity.frenchify()}\\  \\textrm{${units[randomUnitIndex]}} = \\ldots\\  \\textrm{${units[randomUnitInstructionIndex]}}
 $$`;
 };
 const getAnswer = (identifiers) => {
@@ -61,7 +61,7 @@ Il suffit alors de multiplier $${randomCapacity.frenchify()}$ par $${coeff.toTex
 
 ${alignTex([
         [
-            `${randomCapacity.frenchify()} \\textrm{${unit}} `,
+            `${randomCapacity.frenchify()}\\  \\textrm{${unit}} `,
             "=",
             `${multiply(coeff, randomCapacity).toTex()}\\ \\textrm{${target}}`,
         ],

package/lib/exercises/math/derivation/tangent/derivativeTangentEquationReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derivativeTangentEquationReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeTangentEquationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAiQF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}
+{"version":3,"file":"derivativeTangentEquationReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeTangentEquationReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,GAAG,CAAC;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAwQF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}

package/lib/exercises/math/derivation/tangent/derivativeTangentEquationReading.js

@@ -12,6 +12,7 @@ import { MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js"
 import { SubstractNode, } from "../../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { random } from "../../../../utils/alea/random.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 const randomPente = () => {
     return random([
         0,
@@ -137,15 +138,19 @@ const getKeys = (identifiers) => {
     return ["y", "equal", "x"];
 };
 const isAnswerValid = (ans, { answer, trinomCoeffs, xA, yA, yPrimeA }) => {
-    const tree = getAnswerTree({ xA, yA, yPrimeA, trinomCoeffs });
-    const equalTree = new EqualNode("y".toTree(), getAnswerTree({ xA, yA, yPrimeA, trinomCoeffs }));
-    return equalTree
-        .toAllValidTexs({
-        allowMinusAnywhereInFraction: true,
-        allowFractionToDecimal: true,
-        allowRawRightChildAsSolution: true,
-    })
-        .includes(ans);
+    const splitted = ans.split("=");
+    if (splitted[0] !== "y" || splitted.length !== 2)
+        return false;
+    const parsed = parseAlgebraic(splitted[1]);
+    return ("y=" +
+        parsed
+            .simplify({
+            towardsDistribute: true,
+            forceDistributeFractions: true,
+            forbidFactorize: true,
+        })
+            .toTex() ===
+        answer);
 };
 const getDerivativeTangentEquationReadingQuestion = () => {
     const xA = randint(-8, 8);
@@ -170,6 +175,9 @@ const getDerivativeTangentEquationReadingQuestion = () => {
         yPrimeA: yPrimeA.toIdentifiers(),
         trinomCoeffs: [a, b, c],
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),

package/lib/exercises/math/derivation/variations/thirdDegreeFunctionVariation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwKF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}
+{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8KF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}

package/lib/exercises/math/derivation/variations/thirdDegreeFunctionVariation.js

@@ -101,6 +101,9 @@ const getThirdDegreeFunctionVariation = () => {
     const racine2 = randint(racine1 + 1, 6);
     const coin = coinFlip() ? -1 : 1;
     const identifiers = { racine1, racine2, coin, a, c };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: "S",

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

@@ -8,7 +8,7 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
 import { valueParser } from "../../../../tree/parsers/valueParser.js";
 const getInstruction = (identifiers) => {
-    return `Déterminer graphiquement l'ordonnée à l'origine $b$ de la droite tracée ci-dessous : `;
+    return `Déterminer graphiquement l'ordonnée à l'origine de la droite tracée ci-dessous : `;
 };
 const getAnswer = (identifiers) => {
     const { b, secondPoint } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAiBrC,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;AAkHF,KAAK,OAAO,GAAG;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAYF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB7D,CAAC"}
+{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAkBrC,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;AAuHF,KAAK,OAAO,GAAG;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAYF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB7D,CAAC"}

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

@@ -7,6 +7,7 @@ import { Rational, RationalConstructor, } from "../../../../math/numbers/rationa
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -20,11 +21,11 @@ $$
 \\frac{y_B - y_A}{x_B - x_A}
 $$
 
-Repère donc deux points appartenant à la droite, et utilise cette formule.`;
+Choisis deux points appartenant à la droite, et utilise cette formule.`;
 };
 const getCorrection = (identifiers) => {
     const { xA, yA, xB, yB } = identifiers;
-    return `On lit graphiquement que la droite passe par les deux points $A(${xA},${yA})$ et $B(${xB},${yB})$. 
+    return `On lit graphiquement que la droite passe par les points $A(${xA};${yA})$ et $B(${xB};${yB})$. 
   
 Le coefficient directeur est donc : 
 
@@ -96,6 +97,11 @@ const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     addValidProp(propositions, answer);
     if (yB - yA !== 0)
         tryToAddWrongProp(propositions, new Rational(xB - xA, yB - yA).simplify().toTree().toTex());
+    if (yB - yA !== 0) {
+        const a = frac(yB - yA, xB - xA).simplify();
+        const b = substract(yA, multiply(a, xA));
+        tryToAddWrongProp(propositions, b.simplify().toTex());
+    }
     while (propositions.length < n) {
         const wrongAnswer = new NumberNode(randint(-4, 5, [0]));
         tryToAddWrongProp(propositions, wrongAnswer.toTex());

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

@@ -23,7 +23,7 @@ $$`;
 };
 const getInstruction = (identifiers) => {
     const { xA, yA, xB, yB } = identifiers;
-    return `Soit $d$ une droite passant par les points $A(${xA};${yA})$ et $B(${xB};${yB})$.
+    return `Soit $d$ la droite passant par les points $A(${xA};${yA})$ et $B(${xB};${yB})$.
   
 Déterminer le coefficient directeur de $d$.`;
 };

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

@@ -27,7 +27,7 @@ const getAnswer = (identifiers) => {
     return correctAnswer.toTex();
 };
 const getHint = (identifiers) => {
-    return `Détermine un vecteur directeur de $d$. Cela permet de trouver les coefficients $a$ et $b$ dans l'équation cartésienne $ax+by+c=0$. Puis, utilise un point appartenant à $d$ pour obtenir $c$. `;
+    return `Détermine un vecteur directeur de $d$. Cela permet de trouver les coefficients $a$ et $b$ dans l'équation cartésienne $ax+by+c=0$. Puis utilise un point appartenant à $d$ pour obtenir $c$. `;
 };
 const getCorrection = (identifiers) => {
     const { aX, aY, bX, bY } = identifiers;

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

@@ -1 +1 @@
-{"version":3,"file":"cartesianFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAoBtC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,iBAAiB,EAAE,gBAAgB,CAAC;CACrC,CAAC;AA2JF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}
+{"version":3,"file":"cartesianFromTwoPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianFromTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAqBtC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,iBAAiB,EAAE,gBAAgB,CAAC;CACrC,CAAC;AAiKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

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

@@ -1,9 +1,10 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Line, LineConstructor } from "../../../../math/geometry/line.js";
-import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
 import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
 import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.js";
 import { isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
 import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
@@ -11,7 +12,7 @@ import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { parseLatex } from "../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     while (propositions.length < n) {
@@ -31,7 +32,7 @@ const getInstruction = (identifiers) => {
     const { pointBIdentifiers, pointIdentifiers } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIdentifiers);
     const pointB = PointConstructor.fromIdentifiers(pointBIdentifiers);
-    return `Soit $d$ une droite passant par les points $${point.toTexWithCoords()}$ et $${pointB.toTexWithCoords()}$.
+    return `Soit $d$ la droite passant par les points $${point.toTexWithCoords()}$ et $${pointB.toTexWithCoords()}$.
   
 Déterminer une équation cartésienne de $d$.`;
 };
@@ -43,9 +44,9 @@ $$
 ax+by+c = 0
 $$
 
-On remarque que $\\overrightarrow{AB}$ est un vecteur directeur de $d$.
+$\\overrightarrow{AB}$ est un vecteur directeur de $d$.
 
-Puis, on peut ensuite utiliser les coordonnées d'un point de la droite pour déterminer $c$.`;
+Utilise ensuite les coordonnées d'un point de la droite pour déterminer $c$.`;
 };
 const getCorrection = (identifiers) => {
     const { pointBIdentifiers, pointIdentifiers } = identifiers;
@@ -125,10 +126,13 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
     }
 };
 const getCartesianFromTwoPointsQuestion = (ops) => {
-    const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
+    const xA = randint(-10, 11);
+    const xB = randint(-10, 11, [xA]);
+    const yA = randint(-10, 11);
+    const yB = randint(-10, 11, [yA]);
     const identifiers = {
-        pointIdentifiers: points[0].toIdentifiers(),
-        pointBIdentifiers: points[1].toIdentifiers(),
+        pointIdentifiers: new Point("A", xA.toTree(), yA.toTree()).toIdentifiers(),
+        pointBIdentifiers: new Point("A", xB.toTree(), yB.toTree()).toIdentifiers(),
     };
     return getQuestionFromIdentifiers(identifiers);
 };

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

@@ -31,7 +31,7 @@ const getInstruction = (identifiers) => {
     const { vectorIdentifiers, pointIdentifiers } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIdentifiers);
     const vector = VectorConstructor.fromIdentifiers(vectorIdentifiers);
-    return `Soit $d$ une droite de vecteur directeur $${vector.toTexWithCoords()}$ et passant par le point $${point.toTexWithCoords()}$.
+    return `Soit $d$ la droite de vecteur directeur $${vector.toTexWithCoords()}$ et passant par le point $${point.toTexWithCoords()}$.
   
 Déterminer une équation cartésienne de $d$.`;
 };
@@ -43,7 +43,7 @@ $$
 ax+by+c = 0
 $$
 
-On peut ensuite utiliser les coordonnées d'un point de la droite pour déterminer $c$.`;
+Utilise ensuite les coordonnées d'un point de la droite pour déterminer $c$.`;
 };
 const getCorrection = (identifiers) => {
     const { vectorIdentifiers, pointIdentifiers } = identifiers;
@@ -64,7 +64,7 @@ $$
 ${nonCEq.toTex()}=0
 $$
 
-Pour déterminer $c$, on peut ensuite utiliser le fait que le point $${point.toTexWithCoords()}$ appartient à $d$ : 
+Pour déterminer $c$, on utilise le fait que le point $${point.toTexWithCoords()}$ appartient à $d$ : 
 
 $$
 ${nonCEq.toDetailedEvaluation({ x: point.x, y: point.y }).toTex()}=0

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

@@ -43,7 +43,7 @@ const getAnswer = (identifiers) => {
     return getVector(identifiers).toBinomCoords().toTex();
 };
 const getHint = (identifiers) => {
-    return "On repère deux points appartenant à la droite. Le vecteur formé par ces deux points est un vecteur directeur de la droite.";
+    return "Repère deux points appartenant à la droite. Le vecteur formé par ces deux points est un vecteur directeur de la droite.";
 };
 const getCorrection = (identifiers) => {
     const { x1, x2, y1, y2 } = identifiers;

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

@@ -23,7 +23,7 @@ const rebuildIdentifiers = (oldIds) => {
 const getInstruction = (identifiers) => {
     const { xValue, yValue, c } = identifiers;
     const equation = equal(add(add(multiply(yValue.toTree(), "x"), multiply((-xValue).toTree(), "y")).simplify({ forbidFactorize: true }), c.toTree()), new NumberNode(0)).toTex();
-    return `Soit une droite $d$ d'équation cartésienne : 
+    return `Soit la droite $d$ d'équation cartésienne : 
     
 $$
 ${equation}

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

@@ -1 +1 @@
-{"version":3,"file":"drawAlineInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/drawAlineInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"drawAlineInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/drawAlineInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAwGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

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

@@ -9,15 +9,15 @@ import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNa
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
 const getHint = (identifiers) => {
-    return `Détermine un premier point par lequel passe la droite en utilisant l'ordonnée à l'origine de la droite. Puis, à l'aide du coefficient directeur, détermine un deuxième point à partir du premier point.`;
+    return `Détermine un premier point par lequel passe la droite en utilisant l'ordonnée à l'origine de la droite. Puis, à l'aide du coefficient directeur, détermine un second point à partir du premier point.`;
 };
 const getCorrection = (identifiers) => {
     const { correctA, correctB } = identifiers;
     return `L'ordonnée à l'origine de la droite est $${correctB}$. La droite passe donc par le point de coordonnées $(0;${correctB})$.
   
-Puis, le coefficient directeur de $d$ est $${correctA}$. Donc, à partir du point $(0;${correctB})$, en se déplaçant d'une abscisse vers la droite, les ordonnées ${correctA < 0 ? "diminuent" : "augmentent"} de $${correctA}$ unité(s). La droite passe donc par le point de coordonnées $(1; ${correctA})$.
+Le coefficient directeur de $d$ est $${correctA}$. Donc, à partir du point $(0;${correctB})$, si l'on augmente l'abscisse de $1$ unité, l'ordonnée ${correctA < 0 ? "diminue" : "augmente"} de $${correctA}$ unité(s). La droite passe donc par le point de coordonnées $(1; ${correctB + correctA})$.
 
-On place donc les deux points de coordonnées $(0; ${correctB})$ et $(1; ${correctA})$, puis on les relie.`;
+On place donc les deux points de coordonnées $(0; ${correctB})$ et $(1; ${correctB + correctA})$, puis on trace la droite passant par ces deux points.`;
 };
 const getInstruction = (identifiers) => {
     const { correctA, correctB } = identifiers;

package/lib/exercises/math/geometry/lines/cartesianEquationToReduced.js

@@ -62,7 +62,7 @@ const getInstruction = (identifiers) => {
     const equation = toReduced
         ? `${getCartesianEquation(identifiers).toTex()}=0`
         : `y=${getReducedEquation(identifiers).toTex()}`;
-    return `Soit $d$ une droite d'équation ${toReduced ? "cartésienne" : "réduite"} : 
+    return `Soit $d$ la droite d'équation ${toReduced ? "cartésienne" : "réduite"} : 
   
 $$
 ${equation}
@@ -74,7 +74,7 @@ ${toReduced
 };
 const getHint = (identifiers) => {
     if (identifiers.toReduced)
-        return `Pour déterminer l'équation réduite de $d$, il faut isoler la variable $y$ à gauche de l'équation, afin d'obtenir une équation de la forme :
+        return `Pour déterminer l'équation réduite de $d$, il faut isoler la variable $y$ dans le membre de gauche de l'équation, afin d'obtenir une équation de la forme :
 
 $$
 y = ax+b
@@ -98,7 +98,7 @@ const getCorrection = (identifiers) => {
         });
         if (res.rightChild.toTex() !== resSimp.toTex())
             steps.push(new EqualNode("y".toTree(), resSimp).toTex());
-        return `On isole $y$ à gauche de l'équation :
+        return `On isole $y$ dans le membre de gauche de l'équation :
 
 ${alignTex(steps.map((e) => [e]))}`;
     }
@@ -118,12 +118,12 @@ ${alignTex(steps.map((e) => [e]))}`;
     const equaSteps = [[equaTex]];
     if (equaTex !== equaSimpTex)
         equaSteps.push([equaSimpTex]);
-    return `On regroupe tous les termes à gauche :
+    return `On regroupe tous les termes dans le membre de gauche :
   
 ${alignTex(equaSteps)}
 
 ${hasFracs
-        ? `On multiple les deux côtés par $${coeff}$ pour supprimer les fractions : 
+        ? `On multiplie les deux membres par $${coeff}$ pour obtenir des coefficients entiers : 
   
 $$
 ${cartesian.toTex()}

package/lib/exercises/math/geometry/lines/cartesianEquationsIntersection.js

@@ -42,13 +42,13 @@ const getInstruction = (identifiers) => {
     const { cartesianCoeffs1, cartesianCoeffs2 } = identifiers;
     const coeffs1 = cartesianCoeffs1.map((c) => reifyAlgebraic(c));
     const coeffs2 = cartesianCoeffs2.map((c) => reifyAlgebraic(c));
-    return `Soit $d_1$ une droite d'équation cartésienne : 
+    return `Soit $d_1$ la droite d'équation cartésienne : 
   
 $$
 ${getEquation(coeffs1).toTex()}
 $$
 
-et $d_2$ une droite d'équation cartésienne : 
+et $d_2$ la droite d'équation cartésienne : 
 
 $$
 ${getEquation(coeffs2).toTex()}

package/lib/exercises/math/geometry/lines/directorVectorFromAnother.js

@@ -39,7 +39,7 @@ const getHint = (identifiers) => {
 const getCorrection = (identifiers) => {
     return `Tout vecteur colinéaire à $\\overrightarrow{u}$ est également un vecteur directeur de $d$.
 
-On peut donc multiplier les coordonnées de $u$ par n'importe quel nombre pour obtenir un nouveau vecteur directeur de $d$.
+On peut donc multiplier les coordonnées de $\\overrightarrow{u}$ par n'importe quel nombre pour obtenir un nouveau vecteur directeur de $d$.
 
 Un autre vecteur directeur de $d$ est donc par exemple :
 

package/lib/exercises/math/geometry/lines/directorVectorFromReductEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directorVectorFromReductEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/directorVectorFromReductEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0GF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAsBlE,CAAC"}
+{"version":3,"file":"directorVectorFromReductEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/directorVectorFromReductEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAiHF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAsBlE,CAAC"}

package/lib/exercises/math/geometry/lines/directorVectorFromReductEquation.js

@@ -6,6 +6,7 @@ import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { binom, BinomialCoefficientNode, isBinomialCoefficientNode, } from "../../../../tree/nodes/operators/binomialCoefficientNode.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 { vectorParser } from "../../../../tree/parsers/vectorParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
@@ -17,13 +18,17 @@ const getEquationTex = (identifiers) => {
         .simplify({ forbidFactorize: true })
         .toTex()}`;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, aIds, bIds }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const a = reifyAlgebraic(aIds);
     while (propositions.length < n) {
-        const a = randint(-9, 10);
-        const b = randint(-9, 10);
-        tryToAddWrongProp(propositions, binom(a, b).toTex());
+        const x = randint(-9, 10);
+        const y = randint(-9, 10);
+        //colinéaires
+        if (substract(multiply(x, a), y).evaluate() === 0)
+            continue;
+        tryToAddWrongProp(propositions, binom(x, y).toTex());
     }
     return shuffleProps(propositions, n);
 };
@@ -33,7 +38,7 @@ const getAnswer = (identifiers) => {
     return new BinomialCoefficientNode((1).toTree(), a).toTex();
 };
 const getInstruction = (identifiers) => {
-    return `Soit $d$ la droite d'équation : 
+    return `Soit $d$ la droite d'équation réduite : 
   
 $$
 ${getEquationTex(identifiers)}
@@ -42,7 +47,7 @@ $$
 Donner les coordonnées d'un vecteur directeur de $d$.`;
 };
 const getHint = (identifiers) => {
-    return "Le coefficient directeur de la droite représente l'augmentation de l'ordonnée lorsque l'abscisse augmente de $1$. On peut donc en déduire un vecteur directeur de la droite d'abscisse $1$.";
+    return "Le coefficient directeur de la droite représente la variation de l'ordonnée lorsque l'abscisse augmente de $1$. On peut donc en déduire un vecteur directeur d'abscisse $1$ de la droite.";
 };
 const getCorrection = (identifiers) => {
     const { aIds, bIds } = identifiers;

package/lib/exercises/math/geometry/lines/drawLineFromCartesianEquation.js

@@ -25,9 +25,9 @@ $$`;
 };
 const getHint = (identifiers) => {
     const u = new Vector("u", opposite("b"), "a".toTree());
-    return `On peut commencer par chercher les coordonnées d'un point appartenant à la droite. Pour cela, on peut remplacer par exemple $x$ par $0$ et en déduire l'ordonnée $y$ du point d'abscisse $0$ de la droite.
+    return `Commence par chercher les coordonnées d'un point appartenant à la droite. Pour cela, remplace par exemple $x$ par $0$ et déduis-en l'ordonnée $y$ du point d'abscisse $0$ de la droite.
   
-Ensuite, on détermine les coordonnées d'un vecteur directeur de la droite. Une droite admettant une équation cartésienne de la forme :
+Ensuite, détermine les coordonnées d'un vecteur directeur de la droite. Une droite d'équation cartésienne de la forme :
 
 $$
 ax+by+c=0
@@ -52,9 +52,9 @@ const getCorrection = (identifiers) => {
   
 ${alignTex([[detailed.toTex()], [detailedSimp.toTex()], [y.toTex()]])}
 
-Le point $${point.toTexWithCoords()}$ appartient donc à la droite $d$ : on peut le placer sur le graphique.
+Le point $${point.toTexWithCoords()}$ appartient donc à la droite $d$ : on le place sur le graphique.
 
-Puis, on détermine les coordonnées d'un vecteur directeur de $d$. On sait qu'une droite admettant une équation cartésienne de la forme :
+Puis on détermine les coordonnées d'un vecteur directeur de $d$. On sait qu'une droite d'équation cartésienne de la forme :
 
 $$
 ax+by+c=0
@@ -64,7 +64,7 @@ admet le vecteur $${u.toTexWithCoords()}$ comme vecteur directeur.
 
 Ici, un vecteur directeur de $d$ est donc $${vector.toTexWithCoords()}$.
 
-Pour tracer la droite $d$, on peut donc partir du point $A$, puis tracer le vecteur $${vector.toTex()}$. Cela nous donne un deuxième point $B$. On relie alors les points $A$ et $B$ pour obtenir la droite $d$.`;
+Pour tracer la droite $d$, on peut donc partir du point $A$, puis tracer le vecteur $${vector.toTex()}$. En nommant $B$ l'extrémité de ce vecteur, on trace la droite passant par les points $A$ et $B$ : c'est la droite $d$.`;
 };
 const getGGBAnswer = (identifiers) => {
     const { pointIds, vectorIds } = identifiers;

package/lib/exercises/math/geometry/lines/drawLineFromPointAndVector.js

@@ -16,16 +16,16 @@ const getInstruction = (identifiers) => {
   Tracer la droite $d$.`;
 };
 const getHint = (identifiers) => {
-    return `Placer le point $A$. Puis, déterminer l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. La droite recherchée passe par ces deux points.`;
+    return `Place le point $A$. Puis détermine l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. La droite recherchée passe par ces deux points.`;
 };
 const getCorrection = (identifiers) => {
     const { pointIds, vectorIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const vector = VectorConstructor.fromIdentifiers(vectorIds);
     const B = vector.getEndPoint(point);
-    return `On place d'abord le point $A$. Puis, on détermine l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. Cela nous donne le point  $${B.toTexWithCoords()}$. 
+    return `On place d'abord le point $A$. Puis on détermine l'image du point $A$ par la translation de vecteur $\\overrightarrow{u}$. Cela nous donne le point  $${B.toTexWithCoords()}$. 
   
-On relie alors les points $A$ et $B$ par une droite.`;
+On trace alors la droite qui passe par les points $A$ et $B$.`;
 };
 const getGGBAnswer = (identifiers) => {
     const { pointIds, vectorIds } = identifiers;

package/lib/exercises/math/geometry/lines/findParallelLineFromCartesianEquation.js

@@ -44,16 +44,16 @@ const getInstruction = (identifiers) => {
     const equation = equal(add(add(multiply(a, "x"), multiply(b, "y")), c), 0).simplify({
         forbidFactorize: true,
     });
-    return `Soit $d$ une droite dont une équation cartésienne est : 
+    return `Soit $d$ la droite dont une équation cartésienne est : 
   
 $$
 ${equation.toTex()}
 $$
 
-Parmi les équations cartésiennes de droite suivantes, laquelle est celle d'une droite parallèle à $d$ ?`;
+Parmi les équations cartésiennes suivantes, laquelle est celle d'une droite parallèle à $d$ ?`;
 };
 const getHint = (identifiers) => {
-    return `Deux droites sont parallèles si un vecteur directeur de l'un est colinéaire à un vecteur directeur de l'autre. On peut donc déterminer un vecteur directeur $\\overrightarrow{u}$ de $d$, puis déterminer un vecteur directeur de chacune des droites proposées, afin de trouver celui qui est colinéaire à $\\overrightarrow{u}$.`;
+    return `Deux droites sont parallèles si un vecteur directeur de l'une est colinéaire à un vecteur directeur de l'autre. Détermine donc un vecteur directeur $\\overrightarrow{u}$ de $d$, puis un vecteur directeur de chacune des droites proposées, afin de trouver celui qui est colinéaire à $\\overrightarrow{u}$.`;
 };
 const getCorrection = (identifiers) => {
     const { aIds, bIds, cIds, colinearityCoeffIds, fakeCIds } = identifiers;

package/lib/exercises/math/geometry/lines/findParallelLineFromReductEquation.js

@@ -68,7 +68,7 @@ ${equal("y", add(multiply(a, "x"), fakeB))
         .toTex()}
 $$
 
-C'est donc cette équation qui représente une droite parallèle à $d$.
+C'est donc cette équation qui est celle d'une droite parallèle à $d$.
 `;
 };
 const getFindParallelLineFromReductEquationQuestion = (ops) => {