math-exercises 3.0.52 → 3.0.54

package/lib/exercises/math/geometry/areas/squareArea.js

@@ -2,19 +2,52 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getSquareArea = () => {
-    const side = randint(1, 21);
+const getInstruction = (identifiers) => {
+    const { side } = identifiers;
+    return `Calculer l'aire d'un carré de $${side}$ cm de côté.`;
+};
+const getAnswer = (identifiers) => {
+    const { side } = identifiers;
     const answer = side ** 2 + "";
     const answerTex = answer + "\\text{cm}^2";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return `L'aire d'un carré s'obtient en multipliant la longueur d'un côté par elle-même.`;
+};
+const getCorrection = (identifiers) => {
+    const { side } = identifiers;
+    return `L'aire d'un carré de côté $c$ est : 
+  
+$$
+A = c\\times c
+$$
+
+Ici, on a $c = ${side}$ cm.
+
+L'aire du carré vaut donc : 
+
+$$
+A = ${side}\\times${side} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer l'aire d'un carré de $${side}$ cm de côté.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { side },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getSquareArea = () => {
+    const side = randint(1, 21);
+    const identifiers = { side };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -31,9 +64,7 @@ export const squareArea = {
     id: "squareArea",
     connector: "=",
     label: "Calculer l'aire d'un carré",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Aires", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getSquareArea, nb, 20),
     qcmTimer: 60,
     freeTimer: 60,
@@ -41,4 +72,6 @@ export const squareArea = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/areas/triangleArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA6GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}
+{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

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,EAaT,MAAM,6BAA6B,CAAC;AAqBrC,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;AA0KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"cartesianEquationOfLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianEquationOfLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAqBrC,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;AAyNF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -3,12 +3,13 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Line } from "../../../../math/geometry/line.js";
 import { Point } from "../../../../math/geometry/point.js";
-import { Vector } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
@@ -24,6 +25,43 @@ const getAnswer = (identifiers) => {
     const correctAnswer = line.getCartesianEquation();
     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$. `;
+};
+const getCorrection = (identifiers) => {
+    const { aX, aY, bX, bY } = identifiers;
+    const A = new Point("A", aX, aY);
+    const B = new Point("B", bX, bY);
+    const vec = VectorConstructor.fromPoints(A, B);
+    const partial = add(multiply(opposite(vec.y), "x"), multiply(vec.x, "y")).simplify({
+        forbidFactorize: true,
+    });
+    const partialEv = partial.toDetailedEvaluation({ x: A.x, y: A.y });
+    const partialEvSimp = partialEv.simplify();
+    const c = opposite(partialEvSimp).simplify();
+    return `On lit graphiquement que la droite passe par les points $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. On en déduit qu'un vecteur directeur de $d$ est $${vec.toTexWithCoords()}$.
+  
+Une équation cartésienne de $d$ est donc de la forme : 
+
+$$
+${partial.toTex()}+c = 0
+$$
+
+Pour déterminer $c$, on utilise le fait que le point $${A.toTexWithCoords()}$ appartient à $d$ : 
+
+$$
+${partialEv.toTex()}+c = 0
+$$
+
+ce qui donne $c=${c.toTex()}$.
+
+Ainsi, une équation cartésienne de $d$ est : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
 const getGGBOptions = (identifiers) => {
     const { aX, aY, bX, bY } = identifiers;
     const a = new Point("a", aX, aY);
@@ -40,10 +78,14 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getCartesianEquationOfLineQuestion = () => {
-    const aX = randint(-5, 6);
-    const aY = randint(-5, 6);
-    const bX = randint(-5, 6, [aX]);
-    const bY = randint(-5, 6, [aY]);
+    let aX = randint(-5, 6);
+    let aY = randint(-5, 6);
+    let bX = randint(-5, 6, [aX]);
+    let bY = randint(-5, 6, [aY]);
+    if (aX > bX) {
+        [aX, bX] = [bX, aX];
+        [aY, bY] = [bY, aY];
+    }
     const identifiers = { aX, aY, bX, bY };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -55,6 +97,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "y", "equal"],
         answerFormat: "tex",
         identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -135,5 +179,6 @@ export const cartesianEquationOfLine = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    // hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIdentifiers: PointIdentifiers;
+    pointBIdentifiers: PointIdentifiers;
+};
+export declare const cartesianFromTwoPoints: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianFromTwoPoints.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,162 @@
+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 { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.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";
+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 propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const line = LineConstructor.random();
+        tryToAddWrongProp(propositions, line.getCartesianEquation().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pointBIdentifiers, pointIdentifiers } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+    const pointB = PointConstructor.fromIdentifiers(pointBIdentifiers);
+    const line = new Line(point, pointB);
+    return line.getCartesianEquation().toTex();
+};
+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()}$.
+  
+Déterminer une équation cartésienne de $d$.`;
+};
+const getHint = (identifiers) => {
+    const genVec = new Vector("u", opposite("b"), new VariableNode("a"));
+    return `Une droite de vecteur directeur $${genVec.toTexWithCoords()}$ admet une équation cartésienne de la forme : 
+  
+$$
+ax+by+c = 0
+$$
+
+On remarque que $\\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$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointBIdentifiers, pointIdentifiers } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+    const pointB = PointConstructor.fromIdentifiers(pointBIdentifiers);
+    const vector = VectorConstructor.fromPoints(point, pointB);
+    const nonCEq = add(add(multiply(vector.y, "x"), multiply(opposite(vector.x), "y")), "c").simplify({
+        forbidFactorize: true,
+    });
+    const line = LineConstructor.fromPointAndVector(point, vector);
+    const [a, b, c] = line.toCartesianCoeffs();
+    const [aEv, bEv, cEv] = [a.evaluate(), b.evaluate(), c.evaluate()];
+    const allNeg = aEv < 0 && bEv < 0 && cEv < 0;
+    const pgcd = gcd(aEv, bEv, cEv);
+    const hasSimplified = allNeg || pgcd !== 1;
+    return `Puisque $${vector.toTexWithCoords()}$ est un vecteur directeur de $d$, cette dernière admet une équation cartésienne de la forme : 
+  
+$$
+${nonCEq.toTex()}=0
+$$
+
+Pour déterminer $c$, on peut ensuite utiliser le fait que le point $${point.toTexWithCoords()}$ appartient à $d$ : 
+
+$$
+${nonCEq.toDetailedEvaluation({ x: point.x, y: point.y }).toTex()}=0
+$$
+
+On en déduit que $c=${c.simplify().toTex()}$.
+
+Ainsi, une équation cartésienne de $d$ est : 
+
+$$
+${add(add(multiply(a, "x"), multiply(b, "y")), c)
+        .simplify({
+        forbidFactorize: true,
+    })
+        .toTex()}=0
+$$
+
+${hasSimplified
+        ? `On peut alors simplifier cette équation en la divisant par $${allNeg ? opposite(pgcd).toTex() : pgcd}$ : 
+  
+$$
+${getAnswer(identifiers)}
+$$`
+        : ""}
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseLatex(ans);
+        if (!isEqualNode(parsed))
+            return false;
+        const { pointBIdentifiers, pointIdentifiers } = identifiers;
+        const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+        const pointB = PointConstructor.fromIdentifiers(pointBIdentifiers);
+        return (parsed.leftChild
+            .toDetailedEvaluation({
+            x: point.x,
+            y: point.y,
+        })
+            .simplify()
+            .toTex() === "0" &&
+            parsed.leftChild
+                .toDetailedEvaluation({
+                x: pointB.x,
+                y: pointB.y,
+            })
+                .simplify()
+                .toTex() === "0");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianFromTwoPointsQuestion = (ops) => {
+    const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
+    const identifiers = {
+        pointIdentifiers: points[0].toIdentifiers(),
+        pointBIdentifiers: points[1].toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const cartesianFromTwoPoints = {
+    id: "cartesianFromTwoPoints",
+    label: "Déterminer l'équation cartésienne d'une droite en connaissant deux points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianFromTwoPointsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/cartesian/cartesianFromVectorAndPoint.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { VectorIdentifiers } from "../../../../math/geometry/vector.js";
+type Identifiers = {
+    vectorIdentifiers: VectorIdentifiers;
+    pointIdentifiers: PointIdentifiers;
+};
+export declare const cartesianFromVectorAndPoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianFromVectorAndPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianFromVectorAndPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/cartesianFromVectorAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAevC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AAuJF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

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

@@ -0,0 +1,161 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { LineConstructor } from "../../../../math/geometry/line.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../math/geometry/vector.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.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";
+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 propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const line = LineConstructor.random();
+        tryToAddWrongProp(propositions, line.getCartesianEquation().toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { vectorIdentifiers, pointIdentifiers } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+    const vector = VectorConstructor.fromIdentifiers(vectorIdentifiers);
+    const line = LineConstructor.fromPointAndVector(point, vector);
+    return line.getCartesianEquation().toTex();
+};
+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()}$.
+  
+Déterminer une équation cartésienne de $d$.`;
+};
+const getHint = (identifiers) => {
+    const genVec = new Vector("u", opposite("b"), new VariableNode("a"));
+    return `Une droite de vecteur directeur $${genVec.toTexWithCoords()}$ admet une équation cartésienne de la forme : 
+  
+$$
+ax+by+c = 0
+$$
+
+On peut ensuite utiliser les coordonnées d'un point de la droite pour déterminer $c$.`;
+};
+const getCorrection = (identifiers) => {
+    const { vectorIdentifiers, pointIdentifiers } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+    const vector = VectorConstructor.fromIdentifiers(vectorIdentifiers);
+    const nonCEq = add(add(multiply(vector.y, "x"), multiply(opposite(vector.x), "y")), "c").simplify({
+        forbidFactorize: true,
+    });
+    const line = LineConstructor.fromPointAndVector(point, vector);
+    const [a, b, c] = line.toCartesianCoeffs();
+    const [aEv, bEv, cEv] = [a.evaluate(), b.evaluate(), c.evaluate()];
+    const allNeg = aEv < 0 && bEv < 0 && cEv < 0;
+    const pgcd = gcd(aEv, bEv, cEv);
+    const hasSimplified = allNeg || pgcd !== 1;
+    return `Puisque $${vector.toTexWithCoords()}$ est un vecteur directeur de $d$, cette dernière admet une équation cartésienne de la forme : 
+  
+$$
+${nonCEq.toTex()}=0
+$$
+
+Pour déterminer $c$, on peut ensuite utiliser le fait que le point $${point.toTexWithCoords()}$ appartient à $d$ : 
+
+$$
+${nonCEq.toDetailedEvaluation({ x: point.x, y: point.y }).toTex()}=0
+$$
+
+On en déduit que $c=${c.simplify().toTex()}$.
+
+Ainsi, une équation cartésienne de $d$ est : 
+
+$$
+${add(add(multiply(a, "x"), multiply(b, "y")), c)
+        .simplify({
+        forbidFactorize: true,
+    })
+        .toTex()}=0
+$$
+
+${hasSimplified
+        ? `On peut alors simplifier cette équation en la divisant par $${allNeg ? opposite(pgcd).toTex() : pgcd}$ : 
+  
+$$
+${getAnswer(identifiers)}
+$$`
+        : ""}
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "y", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseLatex(ans);
+        if (!isEqualNode(parsed))
+            return false;
+        const { vectorIdentifiers, pointIdentifiers } = identifiers;
+        const point = PointConstructor.fromIdentifiers(pointIdentifiers);
+        const vector = VectorConstructor.fromIdentifiers(vectorIdentifiers);
+        const secondPoint = vector.getEndPoint(point);
+        return (parsed.leftChild
+            .toDetailedEvaluation({
+            x: point.x,
+            y: point.y,
+        })
+            .simplify()
+            .toTex() === "0" &&
+            parsed.leftChild
+                .toDetailedEvaluation({
+                x: secondPoint.x,
+                y: secondPoint.y,
+            })
+                .simplify()
+                .toTex() === "0");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCartesianFromVectorAndPointQuestion = (ops) => {
+    const point = PointConstructor.random("A");
+    const vector = VectorConstructor.random("u");
+    const identifiers = {
+        pointIdentifiers: point.toIdentifiers(),
+        vectorIdentifiers: vector.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const cartesianFromVectorAndPoint = {
+    id: "cartesianFromVectorAndPoint",
+    label: "Déterminer l'équation cartésienne d'une droite en connaissant un point et un vecteur directeur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianFromVectorAndPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,7 +1,9 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
-    xValue: number;
-    yValue: number;
+    x1: number;
+    x2: number;
+    y1: number;
+    y2: number;
 };
 export declare const directionVector: Exercise<Identifiers>;
 export {};

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,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAyIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"directionVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IAIjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}