math-exercises 3.0.52 → 3.0.53

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

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

@@ -1,50 +1,69 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { Vector } from "../../../../math/geometry/vector.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";
-function parseVector(input) {
-    const tex = input.replace("\\left", "");
-    const latex = tex.replace("\\right", "");
-    const regex = /\((-?\d+)\s*[;,]\s*(-?\d+)\)/;
-    const match = latex.match(regex);
-    if (match && match.length === 3) {
-        return {
-            x: parseInt(match[1], 10),
-            y: parseInt(match[2], 10),
-        };
-    }
-    return null;
-}
-function normalizeVector(x, y) {
-    const divisor = 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 = randint(-8, 8);
-    let x2 = randint(-8, 8);
-    while (x2 === x1) {
-        x2 = randint(-8, 8);
-    }
-    let y1 = randint(-8, 8);
-    let y2 = randint(-8, 8);
-    while (y2 === y1) {
+import { isBinomialCoefficientNode } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.x1 !== undefined)
+        return oldIds;
+    const xValue = oldIds.xValue;
+    const yValue = oldIds.yValue;
+    let x1, x2, y1, y2;
+    do {
+        x1 = randint(-8, 8);
+        x2 = randint(-8, 8, [x1]);
+        y1 = randint(-8, 8);
         y2 = randint(-8, 8);
-    }
-    const rawXValue = x2 - x1;
-    const rawYValue = y2 - y1;
-    const { x: xValue, y: yValue } = normalizeVector(rawXValue, rawYValue);
-    const vector = new Vector("v", xValue.toTree(), yValue.toTree());
-    const instruction = `Lire les coordonnées d'un vecteur directeur de la droite représentée ci-dessous :`;
+    } while (x2 - x1 !== xValue || y2 - y1 !== yValue);
+    return {
+        x1,
+        x2,
+        y1,
+        y2,
+    };
+};
+const getInstruction = (identifiers) => {
+    const instruction = `Lire les coordonnées d'un vecteur directeur de la droite $d$ représentée ci-dessous :`;
+    return instruction;
+};
+const getVector = (identifiers) => {
+    const { x1, x2, y1, y2 } = identifiers;
+    const vector = new Vector("v", (x2 - x1).toTree(), (y2 - y1).toTree());
+    return vector;
+};
+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.";
+};
+const getCorrection = (identifiers) => {
+    const { x1, x2, y1, y2 } = identifiers;
+    const vector = new Vector("AB", substract(x2, x1), substract(y2, y1));
+    const simp = vector.simplify();
+    return `On lit graphiquement que la droite passe par les points $A(${x1}; ${y1})$ et $B(${x2};${y2})$.
+
+Le vecteur $\\overrightarrow{AB}$ est donc un vecteur directeur de $d$. 
+
+Ses coordonnées sont : 
+
+$$
+${vector.toTexWithBinomCoords()}=${simp.toBinomCoords().toTex()}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { x1, x2, y1, y2 } = identifiers;
     const commands = [
         `line = Line((${x1}, ${y1}), (${x2}, ${y2}))`,
+        `SetColor(line, "${randomColor()}")`,
         `SetFixed(line, true)`,
     ];
     const xMin = Math.min(x1, x2);
@@ -54,64 +73,73 @@ const getDirectionVectorQuestion = () => {
     const ggb = new GeogebraConstructor({
         commands,
     });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getDirectionVectorQuestion = () => {
+    let x1, x2, y1, y2;
+    do {
+        x1 = randint(-8, 8);
+        x2 = randint(-8, 8, [x1]);
+        y1 = randint(-8, 8);
+        y2 = randint(-8, 8);
+    } while (gcd(x2 - x1, y2 - y1) !== 1);
+    if (x1 > x2) {
+        [x1, x2] = [x2, x1];
+        [y1, y2] = [y2, y1];
+    }
+    const identifiers = { x1, x2, y1, y2 };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: vector.toInlineCoordsTex(),
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: [xMin - 10, xMax + 10, yMin - 10, yMax + 10],
-        }),
-        keys: ["semicolon", "x", "y"],
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: ["binom", "semicolon"],
         answerFormat: "tex",
-        identifiers: { xValue, yValue },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
-const getPropositions = (n, { answer, xValue, yValue }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    const vector = new Vector("v", xValue.toTree(), yValue.toTree());
-    const wrongAnswer1 = new Vector("v", (xValue - 1).toTree(), (yValue - 1).toTree());
-    const wrongAnswer2 = new Vector("v", (xValue + 1).toTree(), (yValue + 1).toTree());
-    const wrongAnswer3 = new Vector("v", yValue.toTree(), xValue.toTree());
-    if (wrongAnswer1.isColinear(vector) === false) {
-        tryToAddWrongProp(propositions, wrongAnswer1.toInlineCoordsTex());
-    }
-    if (wrongAnswer2.isColinear(vector) === false) {
-        tryToAddWrongProp(propositions, wrongAnswer2.toInlineCoordsTex());
-    }
-    if (wrongAnswer3.isColinear(vector) === false) {
-        tryToAddWrongProp(propositions, wrongAnswer3.toInlineCoordsTex());
-    }
+    const vector = getVector(identifiers);
     while (propositions.length < n) {
-        const randomX = randint(-5, 5);
-        const randomY = randint(-5, 5);
-        const { x: wrongX, y: wrongY } = normalizeVector(randomX, randomY);
-        const wrongAnswer = new Vector("v", wrongX.toTree(), wrongY.toTree());
-        if (wrongAnswer.isColinear(vector) === false) {
-            tryToAddWrongProp(propositions, wrongAnswer.toInlineCoordsTex());
-        }
+        const fakeVec = doWhile(() => VectorConstructor.random("v"), (v) => vector.isColinear(v));
+        tryToAddWrongProp(propositions, fakeVec.toBinomCoords().toTex());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, xValue, yValue }) => {
-    const parsed = parseVector(ans);
-    if (!parsed) {
-        return false;
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const solVector = getVector(identifiers);
+        if (ans.includes("binom")) {
+            const parsed = parseAlgebraic(ans);
+            if (!isBinomialCoefficientNode(parsed))
+                return false;
+            const vec = new Vector("u", parsed.leftChild, parsed.rightChild);
+            return solVector.isColinear(vec);
+        }
+        else {
+            const vec = vectorParser(ans);
+            if (!vec)
+                return false;
+            return solVector.isColinear(vec);
+        }
     }
-    const { x, y } = parsed;
-    const correctVector = new Vector("v", xValue.toTree(), yValue.toTree());
-    const studentVector = new Vector("v", x.toTree(), y.toTree());
-    if (!studentVector.isColinear(correctVector)) {
-        return false;
+    catch (err) {
+        return handleVEAError(err);
     }
-    return true;
 };
 export const directionVector = {
     id: "directionVector",
     label: "Lire les coordonnées d'un vecteur directeur d'une droite",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Géométrie cartésienne"],
     generator: (nb) => getDistinctQuestions(getDirectionVectorQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -119,4 +147,7 @@ export const directionVector = {
     isAnswerValid,
     subject: "Mathématiques",
     hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    rebuildIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA+HF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}
+{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA+HF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

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,EAST,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA6EF,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;AAoGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

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

@@ -8,6 +8,17 @@ import { arrayEqual } from "../../../../utils/arrays/arrayEqual.js";
 import { deleteObjectNamesFromAnswer } from "../../../../geogebra/deleteObjectNamesFromAnswer.js";
 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.`;
+};
+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})$.
+
+On place donc les deux points de coordonnées $(0; ${correctB})$ et $(1; ${correctA})$, puis on les relie.`;
+};
 const getInstruction = (identifiers) => {
     const { correctA, correctB } = identifiers;
     const f = new Affine(correctA, correctB);
@@ -38,6 +49,9 @@ const getGGBAnswer = (identifiers) => {
 const getDrawAlineInGgbQuestion = () => {
     const f = AffineConstructor.random({ min: -3, max: 3 });
     const identifiers = { correctA: f.a, correctB: f.b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -45,6 +59,8 @@ const getDrawAlineInGgbQuestion = () => {
         answerFormat: "tex",
         studentGgbOptions: getStudentGGBOptions(identifiers),
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -73,10 +89,8 @@ const getPoint = (command, pointName) => {
 export const drawAlineInGGB = {
     id: "drawAlineInGGB",
     label: "Tracer une droite à partir de son équation réduite",
-    levels: ["2nde"],
     isSingleStep: true,
     answerType: "GGB",
-    sections: ["Géométrie cartésienne"],
     generator: (nb) => getDistinctQuestions(getDrawAlineInGgbQuestion, nb),
     ggbTimer: 60,
     isGGBAnswerValid,
@@ -84,4 +98,6 @@ export const drawAlineInGGB = {
     getGGBAnswer,
     getInstruction,
     getStudentGGBOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -11,4 +11,6 @@ export * from "./readAbscissOnLine.js";
 export * from "./readAbscissOnSemiLine.js";
 export * from "./placeAbscissOnLine.js";
 export * from "./placeAbscissOnSemiLine.js";
+export * from "./cartesianFromVectorAndPoint.js";
+export * from "./cartesianFromTwoPoints.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}