math-exercises 3.0.99 → 3.0.100

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

@@ -1 +1 @@
-{"version":3,"file":"equalCaracteristicFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/equalCaracteristicFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAuNF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}
+{"version":3,"file":"equalCaracteristicFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/equalCaracteristicFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AA6RF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAgB7D,CAAC"}

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

@@ -55,6 +55,56 @@ const getGGBOptions = (identifiers) => {
         coords: [-8, 8, -4, 4],
     });
 };
+const getHint = (identifiers) => {
+    return `- Deux vecteurs ont la même norme si les flèches qui les représentent sont de même longueur.
+- Deux vecteurs ont la même direction si les droites qui les portent sont parallèles.
+- Deux vecteurs ont le même sens s'ils ont la même direction et si les flèches qui les représentent sont orientées dans le même sens. 
+- Deux vecteurs sont égaux s'ils ont la même norme, la même direction et le même sens.
+- Deux vecteurs sont opposés s'ils ont la même norme, la meme direction et un sens opposé. `;
+};
+const getCorrection = (identifiers) => {
+    const { caracAsked, uPoints, vPoints, isTrue, sameDirection, sameNorm, sameSens, } = identifiers;
+    const u = `$\\overrightarrow{u}$`;
+    const v = `$\\overrightarrow{v}$`;
+    switch (caracAsked) {
+        case "direction":
+            return isTrue
+                ? `Les droites portant les vecteurs semblent être parallèles. Les vecteurs ${u} et ${v} semblent donc avoir la même direction.`
+                : `Les droites portant les vecteurs ne semblent pas être parallèles. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même direction.`;
+            break;
+        case "norme":
+            return isTrue
+                ? `Les flèches représentant les vecteurs semblent être de même longueur. Les vecteurs ${u} et ${v} semblent donc avoir la même norme.`
+                : `Les flèches représentant les vecteurs ne semblent pas être de même longueur. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même norme.`;
+            break;
+        case "sens":
+            return isTrue
+                ? `Les droites portant les vecteurs semblent être parallèles, et les flèches représentant les vecteurs sont orientées dans le même sens. Les vecteurs ${u} et ${v} semblent donc avoir le même sens.`
+                : !sameDirection
+                    ? `Les droites portant les vecteurs ne semblent pas être parallèles. Les vecteurs ${u} et ${v} ne peuvent donc pas avoir le même sens.`
+                    : `Les droites portant les vecteurs semblent bien être parallèles, mais les flèches représentant les vecteurs ne sont pas orientées dans le même sens. Les vecteurs ${u} et ${v} ne semblent donc pas avoir le même sens.`;
+            break;
+        case "egaux":
+            return isTrue
+                ? `Les vecteurs ${u} et ${v} semblent avoir la même norme, la même direction et le même sens. Ils semblent donc être égaux.`
+                : !sameDirection
+                    ? `Les droites portant les vecteurs ne semblent pas être parallèles. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même direction, et donc ne semblent pas être égaux.`
+                    : !sameSens
+                        ? `Les flèches représentant les vecteurs ne sont pas orientées dans le même sens. Les vecteurs ${u} et ${v} ne semblent donc pas avoir le même sens, et donc ne semblent pas être égaux.`
+                        : `Les flèches représentant les vecteurs ne semblent pas être de même longueur. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même norme, et donc ne semblent pas être égaux.`;
+            break;
+        case "opposes":
+        default:
+            return isTrue
+                ? `Les vecteurs ${u} et ${v} semblent avoir la même norme, la même direction mais un sens opposé. Ils semblent donc être opposés.`
+                : !sameDirection
+                    ? `Les droites portant les vecteurs ne semblent pas être parallèles. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même direction, et donc ne semblent pas être opposés.`
+                    : sameSens
+                        ? `Les flèches représentant les vecteurs sont orientées dans le même sens. Les vecteurs ${u} et ${v} semblent donc avoir le même sens, et donc ne semblent pas être opposés.`
+                        : `Les flèches représentant les vecteurs ne semblent pas être de même longueur. Les vecteurs ${u} et ${v} ne semblent donc pas avoir la même norme, et donc ne semblent pas être opposés.`;
+    }
+    return ``;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -63,6 +113,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -190,7 +242,15 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
     }
-    const identifiers = { caracAsked, uPoints, vPoints, isTrue };
+    const identifiers = {
+        caracAsked,
+        uPoints,
+        vPoints,
+        isTrue,
+        sameDirection,
+        sameNorm,
+        sameSens,
+    };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
@@ -205,7 +265,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 export const equalCaracteristicFromGraph = {
     id: "equalCaracteristicFromGraph",
-    label: "Direction, sens, norme, égalité, opposés",
+    label: "Caractéristiques des vecteurs : direction, sens, norme, égalité, opposés",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getEqualCaracteristicFromGraphQuestion, nb),
     qcmTimer: 60,
@@ -216,4 +276,5 @@ export const equalCaracteristicFromGraph = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1,21 +1,17 @@
 export * from "./chasles.js";
 export * from "./coordinatesReading.js";
-export * from "./determinant.js";
 export * from "./vectorCoordinatesFromTwoPoints.js";
 export * from "./paralellismViaColinearity.js";
-export * from "./parallelogramViaEqualVectors.js";
-export * from "./fourthParallelogramPoint.js";
 export * from "./equalCaracteristicFromGraph.js";
 export * from "./vectorLinearCombination.js";
 export * from "./vectorNormCalculation.js";
 export * from "./lineFromDirectorVector.js";
-export * from "./drawAVectorInGGB.js";
 export * from "./scalarProduct/index.js";
-export * from "./traceVectorSum.js";
-export * from "./traceVectorDifference.js";
-export * from "./traceOppositeVector.js";
-export * from "./traceVectorMultiple.js";
+export * from "./parallelogram/index.js";
 export * from "./findCoordForAligment.js";
 export * from "./colinearity/index.js";
 export * from "./distributeAndReduceVectors.js";
+export * from "./constructions/index.js";
+export * from "./translationFromPicture.js";
+export * from "./vectorRepresentative.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC"}

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

@@ -1,20 +1,16 @@
 export * from "./chasles.js";
 export * from "./coordinatesReading.js";
-export * from "./determinant.js";
 export * from "./vectorCoordinatesFromTwoPoints.js";
 export * from "./paralellismViaColinearity.js";
-export * from "./parallelogramViaEqualVectors.js";
-export * from "./fourthParallelogramPoint.js";
 export * from "./equalCaracteristicFromGraph.js";
 export * from "./vectorLinearCombination.js";
 export * from "./vectorNormCalculation.js";
 export * from "./lineFromDirectorVector.js";
-export * from "./drawAVectorInGGB.js";
 export * from "./scalarProduct/index.js";
-export * from "./traceVectorSum.js";
-export * from "./traceVectorDifference.js";
-export * from "./traceOppositeVector.js";
-export * from "./traceVectorMultiple.js";
+export * from "./parallelogram/index.js";
 export * from "./findCoordForAligment.js";
 export * from "./colinearity/index.js";
 export * from "./distributeAndReduceVectors.js";
+export * from "./constructions/index.js";
+export * from "./translationFromPicture.js";
+export * from "./vectorRepresentative.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/parallelogram/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,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;AA4EF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAY1D,CAAC"}

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

@@ -0,0 +1,78 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { coordinatesKeys } from "../../../../../exercises/utils/keys/coordinatesKeys.js";
+import { Point, PointConstructor } from "../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    return `Soient les points $${A.toTexWithCoords()}$, $${B.toTexWithCoords()}$, et $${C.toTexWithCoords()}$. 
+  
+Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`;
+};
+const getAnswer = (identifiers) => {
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const answer = D.toCoords();
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: coordinatesKeys,
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getFourthParallelogramPointQuestion = () => {
+    const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
+    const AB = VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = PointConstructor.random("D");
+    } while (AB.isColinear(VectorConstructor.fromPoints(D, points[0])));
+    const C = AB.getEndPoint(D, "C");
+    const 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 getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, xA, xB, xC, yA, yB, yC, yD }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const AB = new Vector("u", new NumberNode(xB - xA), new NumberNode(yB - yA));
+    const C = new Point("C", new NumberNode(xC), new NumberNode(yC));
+    const fakeD = AB.getEndPoint(C);
+    tryToAddWrongProp(propositions, fakeD.toCoords());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, `\\left(${randint(-10, 10)};${randint(-10, 10)}\\right)`);
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [ans, ans.replace(",", ";"), "\\left(" + ans + "\\right)"].includes(answer);
+};
+export const fourthParallelogramPoint = {
+    id: "fourthParallelogramPoint",
+    label: "Déterminer les coordonnées du quatrième point d'un parallélogramme",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getFourthParallelogramPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,4 @@
+export * from "./fourthParallelogramPoint.js";
+export * from "./parallelogramViaEqualVectors.js";
+export * from "./parallelogramCriterion.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/parallelogram/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./fourthParallelogramPoint.js";
+export * from "./parallelogramViaEqualVectors.js";
+export * from "./parallelogramCriterion.js";

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramCriterion.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    isAskingParallelogramName: boolean;
+    pointNames: string[];
+};
+export declare const parallelogramCriterion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramCriterion.d.ts.map

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramCriterion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramCriterion.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/parallelogram/parallelogramCriterion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,yBAAyB,EAAE,OAAO,CAAC;IACnC,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAwMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramCriterion.js

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
+const getPropositions = (n, { answer, isAskingParallelogramName, pointNames }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        if (isAskingParallelogramName) {
+            const reversed = answer.split("").reverse().join("");
+            let fake = "";
+            do {
+                fake = shuffle(pointNames).join("");
+            } while (isParaNameValid(fake, answer));
+            tryToAddWrongProp(propositions, fake);
+        }
+        else {
+            let vec1 = "";
+            let vec2 = "";
+            do {
+                const shuffled = shuffle(pointNames);
+                vec1 = shuffled[0] + shuffled[1];
+                vec2 = shuffled[2] + shuffled[3];
+            } while (isVectorEqualityValid(vec1, vec2, pointNames.join("")));
+            tryToAddWrongProp(propositions, `\\overrightarrow{${vec1}}=\\overrightarrow{${vec2}}`);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isParaNameValid = (name, expectedName) => {
+    //exemple ABCDABCD contient bien tous les noms possibles dans un sens, et DCBADCBA dans l'autre
+    const reversed = expectedName.split("").reverse().join("");
+    return ((expectedName + expectedName).includes(name) ||
+        (reversed + reversed).includes(name));
+};
+const isVectorEqualityValid = (vec1, vec2, expectedName) => {
+    const reversed = expectedName.split("").reverse().join("");
+    const name = vec1 + vec2.split("").reverse().join("");
+    return ((expectedName + expectedName).includes(name) ||
+        (reversed + reversed).includes(name));
+};
+const getAnswer = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        return pointNames.join("");
+    }
+    else {
+        const vec1 = `\\overrightarrow{${pointNames.slice(0, 2).join("")}}`;
+        const vec2 = `\\overrightarrow{${pointNames
+            .slice(2, 4)
+            .reverse()
+            .join("")}}`;
+        return `${vec1}=${vec2}`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        const vec1 = `\\overrightarrow{${pointNames.slice(0, 2).join("")}}`;
+        const vec2 = `\\overrightarrow{${pointNames
+            .slice(2, 4)
+            .reverse()
+            .join("")}}`;
+        return `Soient deux vecteurs $${vec1}$ et $${vec2}$ tels que $${vec1} = ${vec2}$.
+    
+Donner le nom du parallélogramme formé par ces vecteurs.`;
+    }
+    return `Soit un parallélogramme $${pointNames.join("")}$. 
+  
+Donner une égalité entre deux vecteurs issus de ce parallélogramme.`;
+};
+const getHint = (identifiers) => {
+    return `$ABCD$ est un parallélogramme si et seulemtne si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux.`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        return `On sait que $ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. 
+    
+Ici, le quadrilatère $${pointNames.join("")}$ est donc un parallélogramme.`;
+    }
+    return `On sait que $ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. 
+
+Ici, les vecteurs $${pointNames.slice(0, 2).join("")}$ et $${pointNames
+        .slice(2, 4)
+        .reverse()
+        .join("")}$ sont donc égaux.
+    `;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `${pointNames[0]} = (-1, 0)`,
+            `ShowLabel(${pointNames[0]}, true)`,
+            `SetFixed(${pointNames[0]}, true)`,
+            `${pointNames[1]} = (1,2)`,
+            `ShowLabel(${pointNames[1]}, true)`,
+            `SetFixed(${pointNames[1]}, true)`,
+            `${pointNames[2]} = (2, 0)`,
+            `ShowLabel(${pointNames[2]}, true)`,
+            `SetFixed(${pointNames[2]}, true)`,
+            `${pointNames[3]} = (0, -2)`,
+            `ShowLabel(${pointNames[3]}, true)`,
+            `SetFixed(${pointNames[3]}, true)`,
+            `Polygon(${pointNames.join(",")})`,
+            `Vector(${pointNames[0]}, ${pointNames[1]})`,
+            `Vector(${pointNames[3]}, ${pointNames[2]})`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: [-2, 3, -3, 3],
+    });
+};
+const getKeys = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    const sorted = [...pointNames].sort((a, b) => a.localeCompare(b));
+    if (isAskingParallelogramName) {
+        return sorted;
+    }
+    else {
+        return ["overrightarrow", "equal", ...sorted];
+    }
+    return [];
+};
+const isAnswerValid = (ans, { answer, isAskingParallelogramName, pointNames }) => {
+    try {
+        if (isAskingParallelogramName) {
+            if (ans.length !== 4)
+                return false;
+            return isParaNameValid(ans, answer);
+        }
+        else {
+            //on crée le nom du parallélogramme ici de l'égalité et on check comme au dessus
+            let splitted = ans.split("=");
+            if (splitted.length !== 2)
+                return false;
+            if (splitted.some((e) => !e.startsWith("\\overrightarrow")))
+                return false;
+            splitted = splitted.map((e) => e.replace("\\overrightarrow{", "").replace("}", ""));
+            if (splitted.some((e) => e.length !== 2))
+                return false;
+            return isVectorEqualityValid(splitted[0], splitted[1], pointNames.join(""));
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParallelogramCriterionQuestion = (ops) => {
+    const A = randomLetter(true);
+    const B = randomLetter(true, [A]);
+    const C = randomLetter(true, [A, B]);
+    const D = randomLetter(true, [A, B, C]);
+    const identifiers = {
+        isAskingParallelogramName: coinFlip(),
+        pointNames: [A, B, C, D],
+    };
+    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),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const parallelogramCriterion = {
+    id: "parallelogramCriterion",
+    label: "Utiliser la propriété caractéristique du parallélogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramCriterionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.d.ts

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

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,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;AA4GF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.js

@@ -0,0 +1,116 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor } from "../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { substract, } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    return `Soient les points $${A.toTexWithCoords()}$, $${B.toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. 
+  
+$ABCD$ est-il un parallélogramme ?`;
+};
+const getAnswer = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = VectorConstructor.fromPoints(A, B);
+    const vec2 = VectorConstructor.fromPoints(D, C);
+    const isParallelogram = vec1.equals(vec2);
+    const answer = isParallelogram ? "Oui" : "Non";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux.`;
+};
+const getCorrection = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = new Vector("AB", substract(B.x, A.x), substract(B.y, A.y));
+    const vec2 = new Vector("DC", substract(C.x, D.x), substract(C.y, D.y));
+    const vec1Simp = vec1.simplify();
+    const vec2Simp = vec2.simplify();
+    const isParallelogram = vec1Simp.equals(vec2Simp);
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. On calcule donc les coordonnées de ces vecteurs : 
+
+$$
+${vec1.toTexWithCoords()}=${vec1Simp.toBinomCoords().toTex()}
+$$
+
+$$
+${vec2.toTexWithCoords()}=${vec2Simp.toBinomCoords().toTex()}
+$$
+
+${isParallelogram
+        ? `Puisque les vecteurs sont égaux, $ABCD$ est un parallélogramme.`
+        : `Puisque les vecteurs ne sont pas égaux, $ABCD$ n'est pas un parallélogramme.`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getParallelogramViaEqualVectorsQuestion = () => {
+    const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
+    const AB = VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = PointConstructor.random("D");
+    } while (AB.isColinear(VectorConstructor.fromPoints(D, points[0])));
+    let C;
+    const isParallelogram = coinFlip();
+    if (isParallelogram) {
+        C = AB.getEndPoint(D, "C");
+    }
+    else {
+        do {
+            C = PointConstructor.random("C");
+        } while (AB.equals(VectorConstructor.fromPoints(D, C)));
+    }
+    const 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 getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const parallelogramViaEqualVectors = {
+    id: "parallelogramViaEqualVectors",
+    label: "Utiliser les vecteurs pour reconnaître un parallélogramme",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getParallelogramViaEqualVectorsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/translationFromPicture.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    points: string[][];
+    pointAskedIndex: number[];
+};
+export declare const translationFromPicture: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=translationFromPicture.d.ts.map

package/lib/exercises/math/geometry/vectors/translationFromPicture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translationFromPicture.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/translationFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;CAG3B,CAAC;AAqGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}