math-exercises 2.1.8 → 2.1.10

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.affineAdjustmentRsquaredExercise = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+function generateLinearData(n) {
+    const slope = (0, randint_1.randint)(-500, 500, [0]) / 100;
+    const intercept = (0, randint_1.randint)(100, 5000) / 100;
+    let data = [];
+    let generatedXs = new Set();
+    while (data.length < n) {
+        let x = (0, randint_1.randint)(1, 100);
+        while (generatedXs.has(x)) {
+            x = (0, randint_1.randint)(1, 100);
+        }
+        generatedXs.add(x);
+        let noise = Math.random() * 100;
+        let y = (0, round_1.round)(slope * x + intercept + noise, 2);
+        data.push({ x, y });
+    }
+    return data;
+}
+function calculateRSquared(xValues, yValues) {
+    const n = xValues.length;
+    const sumX = xValues.reduce((acc, x) => acc + x, 0);
+    const sumY = yValues.reduce((acc, y) => acc + y, 0);
+    const sumXY = xValues.reduce((acc, x, i) => acc + x * yValues[i], 0);
+    const sumX2 = xValues.reduce((acc, x) => acc + x * x, 0);
+    const sumY2 = yValues.reduce((acc, y) => acc + y * y, 0);
+    const numerator = n * sumXY - sumX * sumY;
+    const denominator = Math.sqrt((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY));
+    const r = numerator / denominator;
+    const rSquared = r * r;
+    return rSquared;
+}
+const getAffineAdjustmentRsquaredQuestion = () => {
+    const data = generateLinearData(10);
+    data.sort((a, b) => a.x - b.x);
+    const xValues = data.map((point) => (0, round_1.round)(point.x, 2));
+    const yValues = data.map((point) => (0, round_1.round)(point.y, 2));
+    const rSquared = calculateRSquared(xValues, yValues);
+    const answer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (0, round_1.round)(rSquared, 2).toTree()).toTex();
+    let dataTable = `
+| | | | | | | | | | | |
+|-|-|-|-|-|-|-|-|-|-|-|
+| x | ${xValues.join(" | ")} |
+| y | ${yValues.join(" | ")} |
+  `;
+    const question = {
+        answer: answer,
+        instruction: `À partir des données fournies ci-dessous, déterminez la valeur du coefficient de détermination : ${dataTable}
+`,
+        keys: ["R", "equal"],
+        answerFormat: "tex",
+        identifiers: { rSquared },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, rSquared }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const wrongAnswer1 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), (0, round_1.round)(rSquared, 2).toTree()).toTex();
+    const wrongAnswer2 = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (-(0, round_1.round)(rSquared, 2)).toTree()).toTex();
+    const wrongAnswer3 = new equalNode_1.EqualNode(new variableNode_1.VariableNode("R"), (-(0, round_1.round)(rSquared, 2)).toTree()).toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer1);
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer2);
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer3);
+    while (propositions.length < n) {
+        const wrongAnswer = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (0, round_1.round)(Math.random(), 2).toTree()).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { rSquared }) => {
+    const valid = new equalNode_1.EqualNode(new powerNode_1.PowerNode(new variableNode_1.VariableNode("R"), new numberNode_1.NumberNode(2)), (0, round_1.round)(rSquared, 2).toTree());
+    const latexs = valid.toAllValidTexs({
+        allowRawRightChildAsSolution: true,
+        allowFractionToDecimal: true,
+    });
+    return latexs.includes(ans);
+};
+exports.affineAdjustmentRsquaredExercise = {
+    id: "affineAdjustmentRsquared",
+    label: "Déterminer le coefficient de détermination à partir d'un tableau de données",
+    levels: ["1rePro"],
+    isSingleStep: true,
+    sections: ["Statistiques"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAffineAdjustmentRsquaredQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+};
+export declare const algebricExpressionOfAffine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=algebricExpressionOfAffine.d.ts.map

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

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

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.algebricExpressionOfAffine = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../../math/polynomials/affine");
+const getAlgebricExpressionOfAffineQuestion = () => {
+    const f = affine_1.AffineConstructor.random();
+    const a = f.a;
+    const b = f.b;
+    const question = {
+        answer: f.toTex(),
+        instruction: `Soit une fonction affine $f$ dont le coefficient directeur vaut $${a}$ et l'ordonnée à l'origine vaut $${b}$. Écrire l'expression algébrique de $f(x)$.`,
+        keys: ["x", "equal"],
+        answerFormat: "tex",
+        identifiers: { a, b },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generatePropositions(a, b).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value));
+    let random;
+    while (propositions.length < n) {
+        random = affine_1.AffineConstructor.random();
+        (0, exercise_1.tryToAddWrongProp)(propositions, random.toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { a, b }) => {
+    const f = new affine_1.Affine(a, b, "x");
+    return f.toTree().toAllValidTexs().includes(ans);
+};
+const generatePropositions = (a, b) => {
+    const firstProposition = new affine_1.Affine(b, a, "x");
+    const secondProposition = new affine_1.Affine(a, -b, "x");
+    return [
+        firstProposition.toTree().toTex(),
+        secondProposition.toTree().toTex(),
+    ];
+};
+exports.algebricExpressionOfAffine = {
+    id: "algebricExpressionOfAffine",
+    label: "Écrire l'expression algébrique d'une fonction affine connaissant les valeurs de son coefficient directeur et de son ordonnée à l'origine",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAlgebricExpressionOfAffineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/functions/affines/index.d.ts

@@ -4,4 +4,9 @@ export * from "./leadingCoefficientCalculV2";
 export * from "./signFunction";
 export * from "./affineExpressionReading";
 export * from "./interceptReading";
+export * from "./algebricExpressionOfAffine";
+export * from "./leadingCoeffAndOriginOrdinate";
+export * from "./affineAdjustment";
+export * from "./affineAdjustmentRsquared";
+export * from "./affineAdjustmentComplete";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,iCAAiC,CAAC;AAChD,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC"}

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

@@ -20,3 +20,8 @@ __exportStar(require("./leadingCoefficientCalculV2"), exports);
 __exportStar(require("./signFunction"), exports);
 __exportStar(require("./affineExpressionReading"), exports);
 __exportStar(require("./interceptReading"), exports);
+__exportStar(require("./algebricExpressionOfAffine"), exports);
+__exportStar(require("./leadingCoeffAndOriginOrdinate"), exports);
+__exportStar(require("./affineAdjustment"), exports);
+__exportStar(require("./affineAdjustmentRsquared"), exports);
+__exportStar(require("./affineAdjustmentComplete"), exports);

package/lib/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    a: number;
+    b: number;
+    isAskingA: boolean;
+};
+export declare const leadingCoeffAndOriginOrdinate: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=leadingCoeffAndOriginOrdinate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"leadingCoeffAndOriginOrdinate.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoeffAndOriginOrdinate.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leadingCoeffAndOriginOrdinate = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../../math/polynomials/affine");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const getLeadingCoeffAndOriginOrdinateQuestion = () => {
+    const exercise = generateExercise();
+    const isAskingA = +exercise.correctAnwer === exercise.f.a ? true : false;
+    const question = {
+        answer: exercise.correctAnwer,
+        instruction: exercise.instruction,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a: exercise.f.a, b: exercise.f.b, isAskingA },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, isAskingA }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, isAskingA ? b + "" : a + "");
+    let random;
+    let flip;
+    while (propositions.length < n) {
+        flip = (0, coinFlip_1.coinFlip)();
+        random = flip ? (0, randint_1.randint)(a - 5, a + 6, [a]) : (0, randint_1.randint)(b - 5, b + 6, [b]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, random + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateExercise = () => {
+    const flip = (0, coinFlip_1.coinFlip)();
+    const f = affine_1.AffineConstructor.random();
+    const instruction = `Soit la fonction affine $f(x)=${f.toTex()}$. ${flip
+        ? `Déterminer la valeur du coefficient directeur`
+        : `Déterminer la valeur de l'ordonnée à l'origine.`}`;
+    return {
+        instruction,
+        correctAnwer: flip ? f.a + "" : f.b + "",
+        f,
+    };
+};
+exports.leadingCoeffAndOriginOrdinate = {
+    id: "leadingCoeffAndOriginOrdinate",
+    label: "A partir de l'expression algébrique d'une fonction affine, déterminer la valeur du coefficient directeur ou de l'ordonnée à l'origine.",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions affines"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLeadingCoeffAndOriginOrdinateQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    aX: number;
+    aY: number;
+    bX: number;
+    bY: number;
+};
+export declare const cartesianEquationOfLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianEquationOfLine.d.ts.map

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

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

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

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cartesianEquationOfLine = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
+const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
+const zero = new numberNode_1.NumberNode(0);
+const getCartesianEquationOfLineQuestion = () => {
+    const a = new point_1.Point("A", new numberNode_1.NumberNode((0, randint_1.randint)(-5, 6)), new numberNode_1.NumberNode((0, randint_1.randint)(-5, 6)));
+    const b = new point_1.Point("B", new numberNode_1.NumberNode((0, randint_1.randint)(-5, 6, [a.getXnumber()])), new numberNode_1.NumberNode((0, randint_1.randint)(-5, 6, [a.getXnumber()])));
+    const line = new line_1.Line(a, b);
+    const commands = [
+        `d = Line((${a.getXnumber()},${a.getYnumber()}),(${b.getXnumber()},${b.getYnumber()}))`,
+        `SetCaption(d, "$d$")`,
+        `ShowLabel(d,true)`,
+        `SetFixed(d,true)`,
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, { isGridSimple: true });
+    const correctAnswer = line.getCartesianEquation();
+    const instruction = `Déterminer l'equation cartesienne de la droite $d$`;
+    const aX = a.getXnumber();
+    const aY = a.getYnumber();
+    const bX = b.getXnumber();
+    const bY = b.getYnumber();
+    const question = {
+        answer: correctAnswer.toTex(),
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({
+            xMin: Math.min(aX, bX) - 5,
+            xMax: Math.max(bX, aX) + 5,
+            yMin: Math.min(aY, bY) - 5,
+            yMax: Math.max(bY, aY) + 5,
+        }),
+        instruction: instruction,
+        keys: ["x", "y", "equal"],
+        answerFormat: "tex",
+        identifiers: { aX, aY, bX, bY },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, aX, aY, bX, bY }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    generateProposition(aX, aY, bX, bY).forEach((value) => (0, exercise_1.tryToAddWrongProp)(propositions, value.toTex()));
+    let aXrand;
+    let aYrand;
+    while (propositions.length < n) {
+        aXrand = (0, randint_1.randint)(-10, 11, [aX]);
+        aYrand = (0, randint_1.randint)(-10, 11, [aY]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, getCorrectAnswer(aXrand, aYrand, bX, bY).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getCorrectAnswer = (aX, aY, bX, bY) => {
+    const a = new point_1.Point("A", new numberNode_1.NumberNode(aX), new numberNode_1.NumberNode(aY));
+    const b = new point_1.Point("B", new numberNode_1.NumberNode(bX), new numberNode_1.NumberNode(bY));
+    const line = new line_1.Line(a, b);
+    return line.getCartesianEquation();
+};
+const generateProposition = (aX, aY, bX, bY) => {
+    const x = new variableNode_1.VariableNode("x");
+    const y = new variableNode_1.VariableNode("y");
+    const firstProposition = getFirstProposition(x, y, aX, aY, bX, bY);
+    const secondProposition = getSecondPropoition(x, y, aX, aY, bX, bY);
+    return [firstProposition, secondProposition];
+};
+const getFirstProposition = (x, y, aX, aY, bX, bY) => {
+    const u = new vector_1.Vector("u", new numberNode_1.NumberNode(bX - aX), new numberNode_1.NumberNode(bY - aY));
+    const b = u.getXAsNumber();
+    const a = -u.getYAsNumber();
+    const c = -a * aX - b * aY;
+    return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), x).simplify(), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(b), y).simplify()), new numberNode_1.NumberNode(c)), zero);
+};
+const getSecondPropoition = (x, y, aX, aY, bX, bY) => {
+    const u = new vector_1.Vector("u", new numberNode_1.NumberNode(aX - bX), new numberNode_1.NumberNode(aY - bY));
+    const b = -u.getXAsNumber();
+    const a = u.getYAsNumber();
+    const c = a * aX + b * aY;
+    return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(b), x).simplify(), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), y).simplify()), new numberNode_1.NumberNode(c)), zero);
+};
+const isAnswerValid = (ans, { aX, aY, bX, bY }) => {
+    let userAns = getEquationNodeFromString(ans);
+    if (userAns === undefined)
+        return false;
+    userAns = userAns;
+    if (userAns.evaluate({ x: aX, y: aY }) !== 0)
+        return false;
+    if (userAns.evaluate({ x: bX, y: bY }) !== 0)
+        return false;
+    return true;
+};
+const getEquationNodeFromString = (ans) => {
+    if (!isValidFormat(ans))
+        return undefined;
+    const leftSide = ans.split("=")[0];
+    let op = leftSide.charAt(0) === "-" ? leftSide.replace("-", "minus") : leftSide;
+    op = op.includes("+") ? op : op.replaceAll("-", "+minus");
+    return getNodeFromString(op.split("+"));
+};
+const isValidFormat = (ans) => {
+    if (!ans.includes("="))
+        return false;
+    const splitted = ans.split("=");
+    if (splitted.length !== 2 || splitted[1] !== "0")
+        return false;
+    return true;
+};
+const getNodeFromString = (tab) => {
+    if (tab.length === 1) {
+        let varStr = tab[0];
+        const operator = findOpInSimpleOpString(varStr);
+        if (operator !== undefined) {
+            const modified = operator === "-" ? varStr.replaceAll("-", "+minus") : varStr;
+            const separated = modified.split("+");
+            return getNodeFromString(separated).simplify();
+        }
+        varStr = varStr.replace("minus", "-");
+        if (varStr.includes("x")) {
+            return getNodeFromVariableString(varStr, "x");
+        }
+        if (varStr.includes("y")) {
+            return getNodeFromVariableString(varStr, "y");
+        }
+        return isNaN(+varStr) ? new numberNode_1.NumberNode(0) : new numberNode_1.NumberNode(+varStr);
+    }
+    else {
+        const middle = Math.floor(tab.length / 2);
+        const leftSide = tab.slice(0, middle);
+        const rightSide = tab.slice(middle);
+        return new addNode_1.AddNode(getNodeFromString(leftSide).simplify(), getNodeFromString(rightSide).simplify()).simplify();
+    }
+};
+const findOpInSimpleOpString = (str) => {
+    if (str.includes("+"))
+        return "+";
+    if (str.includes("-"))
+        return "-";
+    return undefined;
+};
+const getNodeFromVariableString = (str, splitter) => {
+    if (str === splitter)
+        return new variableNode_1.VariableNode(splitter);
+    const splitted = str.split(splitter);
+    if (splitted[0] === "-") {
+        return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-1), new variableNode_1.VariableNode(splitter)).simplify();
+    }
+    return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(+splitted[0]), new variableNode_1.VariableNode(splitter)).simplify();
+};
+exports.cartesianEquationOfLine = {
+    id: "cartesianEquationOfLine",
+    label: "Déterminer une equation cartesienne de droite",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCartesianEquationOfLineQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xValue: number;
+    yValue: number;
+};
+export declare const directionVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=directionVector.d.ts.map

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

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

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directionVector = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+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;
+}
+const getDirectionVectorQuestion = () => {
+    let x1 = (0, randint_1.randint)(-8, 8);
+    let x2 = (0, randint_1.randint)(-8, 8);
+    while (x2 === x1) {
+        x2 = (0, randint_1.randint)(-8, 8);
+    }
+    let y1 = (0, randint_1.randint)(-8, 8);
+    let y2 = (0, randint_1.randint)(-8, 8);
+    while (y2 === y1) {
+        y2 = (0, randint_1.randint)(-8, 8);
+    }
+    const xValue = x2 - x1;
+    const yValue = y2 - y1;
+    const vector = new vector_1.Vector("v", xValue.toTree(), yValue.toTree());
+    const instruction = `Soit la droite tracée ci-dessous dans le plan cartésien. Déterminez les coordonnées d'un vecteur directeur $\\overrightarrow{v}$ de cette droite.`;
+    const commands = [`line = Line((${x1}, ${y1}), (${x2}, ${y2}))`];
+    const xMin = Math.min(x1, x2);
+    const yMin = Math.min(y1, y2);
+    const xMax = Math.max(x1, x2);
+    const yMax = Math.max(y1, y2);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+    });
+    const question = {
+        answer: vector.toInlineCoordsTex(),
+        instruction,
+        commands: ggb.commands,
+        coords: [xMin - 10, xMax + 10, yMin - 10, yMax + 10],
+        options: ggb.getOptions(),
+        keys: ["semicolon", "x", "y"],
+        answerFormat: "tex",
+        identifiers: { xValue, yValue },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xValue, yValue }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const vector = new vector_1.Vector("v", xValue.toTree(), yValue.toTree());
+    const wrongAnswer1 = new vector_1.Vector("v", (xValue - 1).toTree(), (yValue - 1).toTree());
+    const wrongAnswer2 = new vector_1.Vector("v", (xValue + 1).toTree(), (yValue + 1).toTree());
+    const wrongAnswer3 = new vector_1.Vector("v", yValue.toTree(), xValue.toTree());
+    if (wrongAnswer1.isColinear(vector) === false) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer1.toInlineCoordsTex());
+    }
+    if (wrongAnswer2.isColinear(vector) === false) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer2.toInlineCoordsTex());
+    }
+    if (wrongAnswer3.isColinear(vector) === false) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer3.toInlineCoordsTex());
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = new vector_1.Vector("v", (0, randint_1.randint)(-5, 5).toTree(), (0, randint_1.randint)(-5, 5).toTree());
+        if (wrongAnswer.isColinear(vector) === false) {
+            (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toInlineCoordsTex());
+        }
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, xValue, yValue }) => {
+    const parsed = parseVector(ans);
+    if (!parsed) {
+        return false;
+    }
+    const { x, y } = parsed;
+    const correctVector = new vector_1.Vector("v", xValue.toTree(), yValue.toTree());
+    const studentVector = new vector_1.Vector("v", x.toTree(), y.toTree());
+    if (!studentVector.isColinear(correctVector)) {
+        return false;
+    }
+    return true;
+};
+exports.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) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDirectionVectorQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xValue: number;
+    yValue: number;
+};
+export declare const directionVectorEquation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=directionVectorEquation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"directionVectorEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/directionVectorEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}