math-exercises 3.0.52 → 3.0.54

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.js

@@ -5,38 +5,128 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { random } from "../../../../utils/alea/random.js";
 import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
 import { sqrtVEA } from "../../../../exercises/vea/sqrtVEA.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { square } from "../../../../tree/nodes/operators/powerNode.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { round } from "../../../../math/utils/round.js";
-const getPythagoreCalcul = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+const getInstruction = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, on sait que $${triangle.sides[(sideAsked + 1) % 3].toLengthTex()}$ et que $${triangle.sides[(sideAsked + 2) % 3].toLengthTex()}$. 
+    
+Calculer la longueur exacte $${triangle.sides[sideAsked].toInsideName()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = triangle.sides[sideAsked].getLengthNode().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+  
+D'après le théorème de Pythagore, on a donc : 
+
+$$
+${triangle.getPythagorianTex()}
+$$
+
+Remplace les valeurs données dans l'énoncé dans cette égalité. Puis, isole le côté recherché. Enfin, utilise la racine carrée.`;
+};
+const getCorrection = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sidesNames = triangle.sides.map((e) => e.toInsideName());
+    const sidesSquared = sidesNames.map((e) => square(e));
+    const equality = new EqualNode(sidesSquared[0], add(sidesSquared[1], sidesSquared[2]));
+    const isolated = sideAsked === 0
+        ? equality
+        : new EqualNode(sidesSquared[sideAsked], substract(sidesSquared[0], sidesSquared[3 - sideAsked]));
+    const detailed = isolated.toDetailedEvaluation({
+        ...(sideAsked !== 0 && {
+            [sidesNames[0]]: triangle.sides[0].getLengthNode(),
+        }),
+        ...(sideAsked !== 1 && {
+            [sidesNames[1]]: triangle.sides[1].getLengthNode(),
+        }),
+        ...(sideAsked !== 2 && {
+            [sidesNames[2]]: triangle.sides[2].getLengthNode(),
+        }),
     });
-    //une chance sur deux d'avoir hypoténuse
-    const sideIndexAsked = random([0, random([1, 2])]);
-    const answer = triangle.sides[sideIndexAsked].getLengthNode().toTex();
-    triangle.showSidesLength([sideIndexAsked]);
+    const rightSimp = detailed.rightChild.simplify();
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+  
+D'après le théorème de Pythagore, on a donc : 
+
+$$
+${equality.toTex()}
+$$
+
+${sideAsked === 0
+        ? ""
+        : `On isole le côté recherché : 
+  
+$$
+${isolated.toTex()}
+$$`}
+
+On remplace par les valeurs données dans l'énoncé : 
+
+$$
+${detailed.toTex()} = ${rightSimp.toTex()}
+$$
+
+
+
+On applique enfin la racine carrée pour obtenir la valeur recherchée :
+
+$$
+${sidesNames[sideAsked]} = ${sqrt(rightSimp).toTex()} = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.showSidesLength([sideAsked]);
     const commands = [...triangle.commands];
     const ggb = new GeogebraConstructor({
         commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const triangleIdentifiers = triangle.toIdentifiers();
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, on sait que $${triangle.sides[(sideIndexAsked + 1) % 3].toLengthTex()}$ et que $${triangle.sides[(sideIndexAsked + 2) % 3].toLengthTex()}$. 
-    
-Calculer la longueur exacte $${triangle.sides[sideIndexAsked].toInsideName()}$.`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { sideAsked: sideIndexAsked, triangleIdentifiers },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getPythagoreCalcul = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    //une chance sur deux d'avoir hypoténuse
+    const sideIndexAsked = random([0, random([1, 2])]);
+    const triangleIdentifiers = triangle.toIdentifiers();
+    const identifiers = { sideAsked: sideIndexAsked, triangleIdentifiers };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, triangleIdentifiers, sideAsked }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -59,10 +149,8 @@ const isAnswerValid = (ans, { answer, sideAsked, triangleIdentifiers }) => {
 export const pythagoreCalcul = {
     id: "pythagoreCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Pythagore pour calculer un côté",
-    levels: ["4ème", "3ème", "2nde"],
+    label: "Utiliser le théorème de Pythagore pour calculer un côté",
     isSingleStep: false,
-    sections: ["Théorème de Pythagore", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getPythagoreCalcul, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -70,4 +158,6 @@ export const pythagoreCalcul = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/thales/thales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAuBnD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyFF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAoIF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjD,CAAC"}
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAuBnD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyFF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAoLF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBjD,CAAC"}

package/lib/exercises/math/geometry/thales/thales.js

@@ -106,17 +106,46 @@ const getThales = (opts) => {
         isPapillon,
         ratio,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getHint = (identifiers) => {
+    const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio: identifiers.ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    return `Puisque les droites $\\left(${identifiers.insidePointsNames.join("")}\\right)$ et $\\left(${triangle.sides[2].toInsideName()}\\right)$ sont parallèles, les triangles $${triangle.name}$ et $${subTriangle.name}$ sont semblables. Leurs côtés sont donc proportionnels deux à deux.`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Puisque les droites $\\left(${insidePointsNames.join("")}\\right)$ et $\\left(${triangle.sides[2].toInsideName()}\\right)$ sont parallèles, d'après le théorème de Thalès, on a : 
+  
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    return [
+        "equal",
+        ...triangle.points.map((p) => p.name),
+        ...insidePointsNames,
+    ];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
-        keys: [
-            "equal",
-            ...triangle.points.map((p) => p.name),
-            ...[dName, eName],
-        ],
+        keys: getKeys(identifiers),
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -195,4 +224,6 @@ export const thales = {
     getInstruction,
     getGGBOptions,
     options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/triangles/triangleNature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAqJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}
+{"version":3,"file":"triangleNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAoLF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAoBhD,CAAC"}

package/lib/exercises/math/geometry/triangles/triangleNature.js

@@ -39,8 +39,40 @@ const getInstruction = (identifiers) => {
   
 D'après les informations données sur la figure, quelle est la nature du triangle $${triangle.name}$ ? `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    const { triangleIdentifiers, type, useAngles } = identifiers;
+    return `Voici quelques rappels : 
+  
+- un triangle qui a un angle droit est un triangle rectangle ;
+- un triangle qui a deux côtés égaux (ou deux angles égaux) est un triangle isocèle ;
+- un triangle qiu a trois côtés égaux (ou trois angles égaux) est un triangle équilatéral.`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers, type, useAngles } = identifiers;
+    switch (type) {
+        case 0:
+            return "Il n'y a aucune information donnée par la figure sur les longueurs des côtés où les mesures des angles du triangle. On en conclut donc que ce triangle est quelconque.";
+        case 1:
+            if (useAngles) {
+                return `Le triangle possède deux angles égaux : c'est donc un triangle isocèle.`;
+            }
+            else {
+                return `Le triangle possède deux côtés égaux : c'est donc un triangle isocèle.`;
+            }
+        case 2:
+            if (useAngles) {
+                return `Le triangle possède trois angles égaux : c'est donc un triangle équilatéral.`;
+            }
+            else {
+                return `Le triangle possède trois côtés égaux : c'est donc un triangle équilatéral.`;
+            }
+        case 3:
+            return `Le triangle possède un angle droit : c'est donc un triangle rectangle.`;
+        case 4:
+        default:
+            return `Le triangle possède un angle droit : il est donc rectangle. De plus, il possède ${useAngles ? "deux angles égaux" : "deux côtés égaux"} : il est donc également isocèle. `;
+    }
+};
 const getGGBOptions = (identifiers) => {
     const { triangleIdentifiers, type, useAngles } = identifiers;
     let triangle;
@@ -84,12 +116,6 @@ const getGGBOptions = (identifiers) => {
         coords: triangle.generateCoords(),
     });
 };
-const getKeys = (identifiers) => {
-    return [];
-};
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
-};
 const getTriangleNatureQuestion = (opts) => {
     // const type = random(["scalène","isocèle","équilatéral", "rectangle", "rectangle et isocèle"]);
     const type = randint(0, 5);
@@ -129,13 +155,16 @@ const getTriangleNatureQuestion = (opts) => {
         type,
         useAngles,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
+        // keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -148,13 +177,15 @@ export const triangleNature = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
+    // isAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getInstruction,
     getGGBOptions,
     hasGeogebra: true,
     answerType: "QCM",
     isQCM: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,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;CACZ,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/alignementViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,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;CACZ,CAAC;AA0HF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

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

@@ -1,11 +1,69 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { PointConstructor } from "../../../../math/geometry/point.js";
-import { VectorConstructor } from "../../../../math/geometry/vector.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getPoints = (identifiers) => {
+    const { xA, xB, xC, yA, yB, yC } = identifiers;
+    return [
+        new Point("A", xA, yA),
+        new Point("B", xB, yB),
+        new Point("C", xC, yC),
+    ];
+};
+const getInstruction = (identifiers) => {
+    const points = getPoints(identifiers);
+    return `Soient trois points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$ et $${points[2].toTexWithCoords()}$ dans un repère orthonormé. 
+
+Les points $A$, $B$ et $C$ sont-ils alignés ?`;
+};
+const getAnswer = (identifiers) => {
+    const points = getPoints(identifiers);
+    const vec1 = VectorConstructor.fromPoints(points[0], points[1]);
+    const vec2 = VectorConstructor.fromPoints(points[0], points[2]);
+    const isAligned = vec1.isColinear(vec2);
+    const answer = isAligned ? "Oui" : "Non";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Les points $A$, $B$ est $C$ sont alignés si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ sont colinéaires.`;
+};
+const getCorrection = (identifiers) => {
+    const points = getPoints(identifiers);
+    const vec1 = new Vector("AB", substract(points[1].x, points[0].x), substract(points[1].y, points[0].y));
+    const vec1Simp = vec1.simplify();
+    const vec2 = new Vector("AC", substract(points[2].x, points[0].x), substract(points[2].y, points[0].y));
+    const vec2Simp = vec2.simplify();
+    const det = vec1Simp.determinant(vec2Simp);
+    const isAligned = vec1.isColinear(vec2);
+    return `Les points $A$, $B$ est $C$ sont alignés si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ sont colinéaires.
+  
+On calcule les coordonnées de ces vecteurs : 
+
+$$
+${vec1.toTexWithCoords()}=${vec1Simp.toBinomCoords().toTex()}
+$$
+
+et 
+
+$$
+${vec2.toTexWithCoords()}=${vec2Simp.toBinomCoords().toTex()}
+$$
+
+On calcule ensuite le déterminant des deux vecteurs : 
+
+$$
+\\det(${vec1.toTex()};${vec2.toTex()})=${det.toTex()}=${det.simplify().toTex()}
+$$
+
+${isAligned
+        ? `Puisque le déterminant est nul, les vecteurs sont colinéaires. Les points $A$, $B$ et $C$ sont donc alignés.`
+        : `Puisque le déterminant n'est pas nul, les vecteurs ne sont pas colinéaires. Les points $A$, $B$ et $C$ ne sont donc pas alignés.`}`;
+};
 const getAlignementViaColinearityQuestion = () => {
     const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = VectorConstructor.fromPoints(points[0], points[1]);
@@ -20,20 +78,25 @@ const getAlignementViaColinearityQuestion = () => {
             C = PointConstructor.random("C");
         } while (AB.isColinear(VectorConstructor.fromPoints(points[0], C)));
     }
-    const answer = isAligned ? "Oui" : "Non";
+    const identifiers = {
+        xA: points[0].x.evaluate({}),
+        xB: points[1].x.evaluate({}),
+        xC: C.x.evaluate({}),
+        yA: points[0].y.evaluate({}),
+        yB: points[1].y.evaluate({}),
+        yC: C.y.evaluate({}),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Soient trois points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$ et $${C.toTexWithCoords()}$. Les points $A$, $B$ et $C$ sont-ils alignés ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: {
-            xA: points[0].x.evaluate({}),
-            xB: points[1].x.evaluate({}),
-            xC: C.x.evaluate({}),
-            yA: points[0].y.evaluate({}),
-            yB: points[1].y.evaluate({}),
-            yC: C.y.evaluate({}),
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -48,13 +111,13 @@ const getPropositions = (n, { answer }) => {
 export const alignementViaColinearity = {
     id: "alignementViaColinearity",
     label: "Utiliser la colinéarité pour déterminer un alignement",
-    levels: ["2nde", "1reSpé"],
     isSingleStep: true,
-    sections: ["Vecteurs", "Droites"],
     generator: (nb) => getDistinctQuestions(getAlignementViaColinearityQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     answerType: "QCU",
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1,9 +1,10 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    xu: number;
-    yu: number;
-    xv: number;
-    yv: number;
+    xu: NodeIdentifiers;
+    yu: NodeIdentifiers;
+    xv: NodeIdentifiers;
+    yv: NodeIdentifiers;
 };
 export declare const colinearity: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,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,QAAQ,CAAC,WAAW,CAY7C,CAAC"}
+{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/colinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;CACrB,CAAC;AA4GF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}

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

@@ -1,16 +1,79 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const rebuildIdentifiers = (oldIds) => {
+    if (oldIds.xu?.id)
+        return oldIds;
+    return {
+        xu: oldIds.xu.toTree().toIdentifiers(),
+        yu: oldIds.yu.toTree().toIdentifiers(),
+        xv: oldIds.xv.toTree().toIdentifiers(),
+        yv: oldIds.yv.toTree().toIdentifiers(),
+    };
+};
+const getInstruction = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    return `Soit deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
+  
+Les vecteurs $${u.toTex()}$ et $${v.toTex()}$ sont-ils colinéaires ?`;
+};
+const getHint = (identifiers) => {
+    const u = new Vector("u", "x".toTree(), "y".toTree());
+    const v = new Vector("v", "x'".toTree(), "y'".toTree());
+    return `Deux vecteurs sont colinéaires si et seulement si leur déterminant est nul. 
+  
+Le déterminant de deux vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$ est :
+
+$$
+\\det(${u.toTex()}, ${v.toTex()}) = ${u.determinant(v).simplify().toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const det = u.determinant(v);
+    const detSimp = det.simplify();
+    const isCol = detSimp.evaluate() === 0;
+    return `On calcule le déterminant de $${u.toTex()}$ et $${v.toTex()}$ : 
+
+${alignTex([
+        ["", `\\det(${u.toTex()}, ${v.toTex()})`],
+        ["=", det.toTex()],
+        ["=", detSimp.toTex()],
+    ])}
+
+${isCol
+        ? `Puisque le déterminant est nul, les vecteurs sont bien colinéaires.`
+        : `Puisque le déterminant n'est pas nul, les vecteurs ne sont pas colinéaires.`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
 const getColinearityQuestion = () => {
     const u = VectorConstructor.random("u", false);
     const isColinear = coinFlip();
     let v;
     if (isColinear) {
-        const coeff = new NumberNode(randint(-5, 5));
+        const coeff = coinFlip()
+            ? new NumberNode(randint(-5, 5, [0, 1]))
+            : RationalConstructor.randomIrreductible(5).toTree();
         v = u.times(coeff, "v");
     }
     else {
@@ -18,25 +81,22 @@ const getColinearityQuestion = () => {
             v = 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({}),
-        },
+    const identifiers = {
+        xu: u.x.toIdentifiers(),
+        xv: v.x.toIdentifiers(),
+        yu: u.y.toIdentifiers(),
+        yv: v.y.toIdentifiers(),
     };
-    return question;
+    return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
-    addValidProp(propositions, answer, "raw");
+    // addValidProp(propositions, answer, "raw");
+    const { xu, yu, xv, yv } = identifiers;
+    const u = new Vector("u", reifyAlgebraic(xu), reifyAlgebraic(yu));
+    const v = new Vector("v", reifyAlgebraic(xv), reifyAlgebraic(yv));
+    const isCol = u.isColinear(v);
+    addValidProp(propositions, isCol ? "Oui" : "Non", "raw");
     tryToAddWrongProp(propositions, "Oui", "raw");
     tryToAddWrongProp(propositions, "Non", "raw");
     tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
@@ -44,14 +104,15 @@ const getPropositions = (n, { answer }) => {
 };
 export const colinearity = {
     id: "colinearity",
-    label: "Déterminer si deux vecteurs sont colinéaires",
-    levels: ["2nde", "1reSpé"],
+    label: "Déterminer si deux vecteurs sont colinéaires (par les coordonnées)",
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getColinearityQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     answerType: "QCU",
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    rebuildIdentifiers,
 };

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

@@ -7,7 +7,7 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getDeterminantQuestion = () => {
     const u = VectorConstructor.random("u");
     const v = VectorConstructor.random("v");
-    const answer = u.determinant(v);
+    const answer = u.determinant(v).simplify();
     const answerTex = answer.toTex();
     const question = {
         answer: answerTex,

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=findCoordForAligment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findCoordForAligment.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/findCoordForAligment.ts"],"names":[],"mappings":""}