math-exercises 2.1.25 → 2.1.26

package/lib/exercises/geometry/vectors/chasles.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chasles = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/random");
+const shuffle_1 = require("../../../utils/shuffle");
+const letters = "ABCDEFGHIJKLMNPQRSTUVWXYZ";
+const invVec = (vec) => {
+    return `\\overrightarrow{${vec[1]}${vec[0]}}`;
+};
+const getChaslesQuestion = () => {
+    const nbOfVectors = (0, randint_1.randint)(2, 5);
+    const randLetters = (0, shuffle_1.shuffle)(letters.split("")).slice(0, nbOfVectors + 2);
+    let vectors = [];
+    for (let i = 0; i < nbOfVectors; i++) {
+        vectors.push(`${randLetters[i]}${randLetters[i + 1]}`);
+    }
+    const answer = `\\overrightarrow{${randLetters[0]}${randLetters[nbOfVectors]}}`;
+    vectors = (0, shuffle_1.shuffle)(vectors).map((vec) => Math.random() < 0.4 ? "-" + invVec(vec) : `+\\overrightarrow{${vec}}`);
+    let statement = vectors.join("");
+    if (statement[0] === "+")
+        statement = statement.slice(1, statement.length);
+    const question = {
+        answer: answer,
+        instruction: `Simplifier : $${statement}$`,
+        keys: [
+            "overrightarrow",
+            ...randLetters.sort((a, b) => a.localeCompare(b)),
+        ],
+        answerFormat: "tex",
+        identifiers: { randLetters, vectors },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randLetters }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const a = (0, random_1.random)(randLetters);
+        const b = (0, random_1.random)(randLetters);
+        const wrongAnswer = `\\overrightarrow{${a}${b}}`;
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.chasles = {
+    id: "chasles",
+    connector: "=",
+    label: "Relation de Chasles pour les vecteurs",
+    levels: ["2nde", "1reESM", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getChaslesQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/vectors/colinearity.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xu: number;
+    yu: number;
+    xv: number;
+    yv: number;
+};
+export declare const colinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=colinearity.d.ts.map

package/lib/exercises/geometry/vectors/colinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAQlC,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;AAyCF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAWjD,CAAC"}

package/lib/exercises/geometry/vectors/colinearity.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colinearity = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getColinearityQuestion = () => {
+    const u = vector_1.VectorConstructor.random("u", false);
+    const isColinear = (0, coinFlip_1.coinFlip)();
+    let v;
+    if (isColinear) {
+        const coeff = new numberNode_1.NumberNode((0, randint_1.randint)(-5, 5));
+        v = u.times(coeff, "v");
+    }
+    else {
+        do {
+            v = vector_1.VectorConstructor.random("v", false);
+        } while (u.isColinear(v));
+    }
+    // const isColinear = u.isColinear(v);
+    const answer = isColinear ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: {
+            xu: u.x.evaluate({}),
+            xv: v.x.evaluate({}),
+            yu: u.y.evaluate({}),
+            yv: v.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.colinearity = {
+    id: "colinearity",
+    label: "Déterminer si deux vecteurs sont colinéaires",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getColinearityQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/coordinatesReading.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    yA: number;
+    yB: number;
+};
+export declare const coordinatesReading: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=coordinatesReading.d.ts.map

package/lib/exercises/geometry/vectors/coordinatesReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAOlC,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;AAqEF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/geometry/vectors/coordinatesReading.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coordinatesReading = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../../geogebra/colors");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const randint_1 = require("../../../math/utils/random/randint");
+const getCoordinatesReadingQuestion = () => {
+    const [xA, yA] = integer_1.IntegerConstructor.randomDifferents(-5, 6, 2);
+    let xB, yB;
+    do {
+        [xB, yB] = integer_1.IntegerConstructor.randomDifferents(-5, 6, 2);
+    } while (xA === xB && yA === yB);
+    const xDelta = xB - xA;
+    const yDelta = yB - yA;
+    const answer = `\\left(${xDelta};${yDelta}\\right)`;
+    const commands = [
+        `u = Vector((${xA},${yA}), (${xB}, ${yB}))`,
+        'SetCaption(u, "$\\overrightarrow u$")',
+        "ShowLabel(u, true)",
+        `SetColor(u, "${(0, colors_1.randomColor)()}")`,
+    ];
+    const xMin = Math.min(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const xMax = Math.max(xA, xB);
+    const yMax = Math.max(yA, yB);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        gridDistance: [1, 1],
+        isGridSimple: true,
+        isGridBold: true,
+    });
+    const question = {
+        answer: answer,
+        instruction: `Lire les coordonnées du vecteur $\\overrightarrow u$ représenté ci-dessous :`,
+        keys: ["semicolon", "vectorU"],
+        answerFormat: "tex",
+        commands: ggb.commands,
+        coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+        options: ggb.getOptions(),
+        identifiers: { xA, xB, yA, yB },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${xA - xB};${yA - yB}\\right)`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${xA + xB};${yA + yB}\\right)`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${xA - yA};${xB - yB}\\right)`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${yA - xA};${yB - xB}\\right)`);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${(0, randint_1.randint)(-10, 10)};${(0, randint_1.randint)(-10, 10)}\\right)`);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, "\\overrightarrow{u}" + answer].includes(ans);
+};
+exports.coordinatesReading = {
+    id: "coordinatesReading",
+    connector: "=",
+    label: "Lire les coordonnées d'un vecteur",
+    levels: ["2nde", "1reESM"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCoordinatesReadingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/geometry/vectors/determinant.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    uCoords: string[];
+    vCoords: string[];
+};
+export declare const determinant: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=determinant.d.ts.map

package/lib/exercises/geometry/vectors/determinant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoDF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/geometry/vectors/determinant.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determinant = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getDeterminantQuestion = () => {
+    const u = vector_1.VectorConstructor.random("u");
+    const v = vector_1.VectorConstructor.random("v");
+    const answer = u.determinant(v);
+    const answerTex = answer.toTex();
+    const question = {
+        answer: answerTex,
+        instruction: `Soient les vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. Calculer le déterminant $\\det(\\overrightarrow u;\\overrightarrow v)$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            uCoords: [u.x.toTex(), u.y.toTex()],
+            vCoords: [v.x.toTex(), v.y.toTex()],
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, uCoords, vCoords }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const u = new vector_1.Vector("u", new numberNode_1.NumberNode(Number(uCoords[0])), new numberNode_1.NumberNode(Number(uCoords[1])));
+    const v = new vector_1.Vector("v", new numberNode_1.NumberNode(Number(vCoords[0])), new numberNode_1.NumberNode(Number(vCoords[1])));
+    (0, exercise_1.tryToAddWrongProp)(propositions, u.scalarProduct(v).toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(-20, 20) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.determinant = {
+    id: "determinant",
+    connector: "=",
+    label: "Calculer le déterminant de deux vecteurs",
+    levels: ["2nde", "1reESM", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDeterminantQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/vectors/equalCaracteristicFromGraph.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    caracAsked: string;
+    uPoints: number[][];
+    vPoints: number[][];
+};
+export declare const equalCaracteristicFromGraph: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=equalCaracteristicFromGraph.d.ts.map

package/lib/exercises/geometry/vectors/equalCaracteristicFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equalCaracteristicFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/equalCaracteristicFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;CACrB,CAAC;AAwLF,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/geometry/vectors/equalCaracteristicFromGraph.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalCaracteristicFromGraph = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const random_1 = require("../../../utils/random");
+/**
+ *
+ * Soient deux cercles C1 et C2 de rayon 3 et de centres (-4,0) et (4,0)
+ * on construit u dans C1 et v dans C2
+ */
+const getEqualCaracteristicFromGraphQuestion = () => {
+    let points = [];
+    // const caracAsked = random(["sens", "direction", "norme"]);
+    let instruction = "";
+    const caracAsked = (0, random_1.random)(["opposes"]);
+    // ["sens", "norme", "direction", "egaux", "opposes"]
+    const isTrue = (0, coinFlip_1.coinFlip)();
+    let uPoints = [];
+    let vPoints = [];
+    //On construit u dans C1
+    const theta = Math.random() * 2 * Math.PI;
+    uPoints.push([3 * Math.cos(theta) - 4, 3 * Math.sin(theta)]);
+    uPoints.push([
+        3 * Math.cos(theta + Math.PI) - 4,
+        3 * Math.sin(theta + Math.PI),
+    ]);
+    let thetaPrime;
+    let sameDirection;
+    let sameNorm;
+    let sameSens;
+    let rho;
+    switch (caracAsked) {
+        case "direction":
+            instruction = "avoir la même direction";
+            thetaPrime = isTrue
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            sameNorm = (0, coinFlip_1.coinFlip)();
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if ((0, coinFlip_1.coinFlip)())
+                uPoints = [uPoints[1], uPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "norme":
+            instruction = "avoir la même norme";
+            sameDirection = (0, coinFlip_1.coinFlip)();
+            thetaPrime = sameDirection ? theta : Math.random() * 2 * Math.PI;
+            if (isTrue) {
+                vPoints.push([3 * Math.cos(thetaPrime) + 4, 3 * Math.sin(thetaPrime)]);
+                vPoints.push([
+                    3 * Math.cos(thetaPrime + Math.PI) + 4,
+                    3 * Math.sin(thetaPrime + Math.PI),
+                ]);
+            }
+            else {
+                vPoints.push([Math.cos(thetaPrime) + 4, Math.sin(thetaPrime)]);
+                vPoints.push([
+                    Math.cos(thetaPrime + Math.PI) + 4,
+                    Math.sin(thetaPrime + Math.PI),
+                ]);
+            }
+            if ((0, coinFlip_1.coinFlip)())
+                uPoints = [uPoints[1], uPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "sens":
+            instruction = "avoir le même sens";
+            sameDirection = (0, coinFlip_1.coinFlip)();
+            sameNorm = (0, coinFlip_1.coinFlip)();
+            thetaPrime =
+                isTrue || sameDirection
+                    ? theta
+                    : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!isTrue)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "egaux":
+            instruction = "être égaux";
+            sameDirection = isTrue || (0, coinFlip_1.coinFlip)();
+            sameNorm = isTrue || (0, coinFlip_1.coinFlip)();
+            sameSens = isTrue || (sameDirection && sameNorm ? false : (0, coinFlip_1.coinFlip)());
+            thetaPrime = sameDirection
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!sameSens)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "opposes":
+            instruction = "être opposés";
+            sameDirection = isTrue || (0, coinFlip_1.coinFlip)();
+            sameNorm = isTrue || (0, coinFlip_1.coinFlip)();
+            sameSens = !isTrue || (sameDirection && sameNorm ? false : (0, coinFlip_1.coinFlip)());
+            thetaPrime = sameDirection
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!sameSens)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+    }
+    const commands = [
+        `u = Vector((${uPoints[0][0]},${uPoints[0][1]}), (${uPoints[1][0]},${uPoints[1][1]}))`,
+        `v = Vector((${vPoints[0][0]},${vPoints[0][1]}), (${vPoints[1][0]},${vPoints[1][1]}))`,
+        'SetCaption(u, "$\\overrightarrow u$")',
+        'SetCaption(v, "$\\overrightarrow v$")',
+        "ShowLabel(u, true)",
+        "ShowLabel(v,true)",
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        hideAxes: true,
+    });
+    const answer = isTrue ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ suivants semblent-ils ${instruction} ?`,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-8, 8, -4, 4],
+        answerFormat: "tex",
+        identifiers: { caracAsked, uPoints, vPoints },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.equalCaracteristicFromGraph = {
+    id: "equalCaracteristicFromGraph",
+    label: "Direction, sens, norme, égalité, opposés",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEqualCaracteristicFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    hasGeogebra: true,
+};

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const fourthParallelogramPoint: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=fourthParallelogramPoint.d.ts.map

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwDF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/geometry/vectors/fourthParallelogramPoint.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fourthParallelogramPoint = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const coordinatesKeys_1 = require("../../../exercises/utils/keys/coordinatesKeys");
+const point_1 = require("../../../math/geometry/point");
+const vector_1 = require("../../../math/geometry/vector");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getFourthParallelogramPointQuestion = () => {
+    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = point_1.PointConstructor.random("D");
+    } while (AB.isColinear(vector_1.VectorConstructor.fromPoints(D, points[0])));
+    const C = AB.getEndPoint(D, "C");
+    const answer = D.toCoords();
+    const question = {
+        answer,
+        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, et $${C.toTexWithCoords()}$. Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`,
+        keys: coordinatesKeys_1.coordinatesKeys,
+        answerFormat: "tex",
+        identifiers: {
+            xA: points[0].x.evaluate({}),
+            xB: points[1].x.evaluate({}),
+            xC: C.x.evaluate({}),
+            xD: D.x.evaluate({}),
+            yA: points[0].y.evaluate({}),
+            yB: points[1].y.evaluate({}),
+            yC: C.y.evaluate({}),
+            yD: D.y.evaluate({}),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, xA, xB, xC, yA, yB, yC, yD }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "tex");
+    const AB = new vector_1.Vector("u", new numberNode_1.NumberNode(xB - xA), new numberNode_1.NumberNode(yB - yA));
+    const C = new point_1.Point("C", new numberNode_1.NumberNode(xC), new numberNode_1.NumberNode(yC));
+    const fakeD = AB.getEndPoint(C);
+    (0, exercise_1.tryToAddWrongProp)(propositions, fakeD.toCoords());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\left(${(0, randint_1.randint)(-10, 10)};${(0, randint_1.randint)(-10, 10)}\\right)`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
+};
+exports.fourthParallelogramPoint = {
+    id: "fourthParallelogramPoint",
+    label: "Déterminer les coordonnées du quatrième point d'un parallélogramme",
+    levels: ["2nde", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Vecteurs", "Droites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFourthParallelogramPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/vectors/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./chasles";
+export * from "./coordinatesReading";
+export * from "./determinant";
+export * from "./scalarProductViaCoords";
+export * from "./vectorCoordinatesFromTwoPoints";
+export * from "./scalarProductViaCos";
+export * from "./colinearity";
+export * from "./alignementViaColinearity";
+export * from "./paralellismViaColinearity";
+export * from "./parallelogramViaEqualVectors";
+export * from "./fourthParallelogramPoint";
+export * from "./equalCaracteristicFromGraph";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/vectors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC"}

package/lib/exercises/geometry/vectors/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./chasles"), exports);
+__exportStar(require("./coordinatesReading"), exports);
+__exportStar(require("./determinant"), exports);
+__exportStar(require("./scalarProductViaCoords"), exports);
+__exportStar(require("./vectorCoordinatesFromTwoPoints"), exports);
+__exportStar(require("./scalarProductViaCos"), exports);
+__exportStar(require("./colinearity"), exports);
+__exportStar(require("./alignementViaColinearity"), exports);
+__exportStar(require("./paralellismViaColinearity"), exports);
+__exportStar(require("./parallelogramViaEqualVectors"), exports);
+__exportStar(require("./fourthParallelogramPoint"), exports);
+__exportStar(require("./equalCaracteristicFromGraph"), exports);

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts

@@ -0,0 +1,14 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const paralellismViaColinearity: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=paralellismViaColinearity.d.ts.map

package/lib/exercises/geometry/vectors/paralellismViaColinearity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralellismViaColinearity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/paralellismViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA2DF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAY/D,CAAC"}