math-exercises 3.0.99 → 3.0.100

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

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        throw Error("QCM not implemented");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { isEqui, side, base } = identifiers;
+    if (isEqui) {
+        return sqrt(multiply(frac(3, 4), square(side)))
+            .simplify()
+            .toTex();
+    }
+    else {
+        return sqrt(substract(square(side), frac(square(base), 4)))
+            .simplify()
+            .toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isEqui, side, base } = identifiers;
+    if (isEqui) {
+        return `Le triangle équilatéral ci-dessous a pour côté $${side}$.
+      
+Calculer sa hauteur $h$.`;
+    }
+    return `Le triangle isocèle ci-dessous a deux côtés valant $${side}$ et son troisième côté vaut $${base}$.
+    
+Calculer sa hauteur $h$.`;
+};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1, 1, -1, 1],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getTriangleHeightQuestion = (opts) => {
+    const isEqui = coinFlip();
+    const side = randint(1, 11);
+    const base = isEqui ? undefined : randint(1, 11, [side]);
+    const identifiers = {
+        isEqui,
+        side,
+        base,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const triangleHeight = {
+    id: "triangleHeight",
+    label: "Calculer la hauteur d'un triangle équilatéral ou isocèle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTriangleHeightQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -1,3 +1,5 @@
 export * from "./quadrilateralRecognition.js";
 export * from "./parallelogramAngles.js";
+export * from "./parallelogramRhombus.js";
+export * from "./parallelogramRectangle.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC"}

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

@@ -1,2 +1,4 @@
 export * from "./quadrilateralRecognition.js";
 export * from "./parallelogramAngles.js";
+export * from "./parallelogramRhombus.js";
+export * from "./parallelogramRectangle.js";

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRectangle.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    BC: NodeIdentifiers;
+    BA: NodeIdentifiers;
+    AC: NodeIdentifiers;
+    isRectangle: boolean;
+};
+export declare const parallelogramRectangle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramRectangle.d.ts.map

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRectangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramRectangle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/parallelogramRectangle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AA8IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAoBxD,CAAC"}

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRectangle.js

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `${identifiers.isRectangle ? "Oui" : "Non"}`;
+};
+const getInstruction = (identifiers) => {
+    const { AC, BA, BC } = identifiers;
+    return `$ABCD$ est un parallélogramme, tel que $BC = ${reifyAlgebraic(BC).toTex()}$, $BA = ${reifyAlgebraic(BA).toTex()}$ et $AC = ${reifyAlgebraic(AC).toTex()}$. 
+  
+$ABCD$ est-il un rectangle ?`;
+};
+const getHint = (identifiers) => {
+    return `Un parallélogramme est un rectangle si et seulement s'il possède au moins un angle droit.`;
+};
+const getCorrection = (identifiers) => {
+    const AC = reifyAlgebraic(identifiers.AC);
+    const BA = reifyAlgebraic(identifiers.BA);
+    const BC = reifyAlgebraic(identifiers.BC);
+    return `Un parallélogramme est un un rectangle si et seulement s'il possède au moins un angle droit. On cherche donc à déterminer si $ABC$ est un triangle rectangle en $B$. 
+  
+Pour cela, on vérifie si le carré de l'hypoténuse ($AC$) est égal à la somme des carrés des deux autres côtés. D'une part, on a :
+
+$$
+AC^2 = ${square(AC).toTex()} = ${square(AC).simplify().toTex()}
+$$
+
+et d'autre part 
+
+$$
+BA^2 + BC^2 = ${add(square(BA), square(BC)).toTex()} = ${add(square(BA), square(BC))
+        .simplify()
+        .toTex()}.
+$$
+
+${identifiers.isRectangle
+        ? `Puisque $AC^2 = BA^2 + BC^2$, d'après la réciproque du théorème de Pythagore, le triangle $ABC$ est rectangle en $B$. Le parallélogramme possède donc un angle droit : $ABCD$ est donc un rectangle.`
+        : `Puisque $AC^2$ n'est pas égal à $BA^2 + BC^2$, d'après la contraposée du théorème de Pythagore, le triangle $ABC$ n'est pas rectangle en $B$. Le parallélogramme ne possède donc pas $4$ angles droits : $ABCD$ n'est donc pas un rectangle.`}
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const AC = reifyAlgebraic(identifiers.AC);
+    const BA = reifyAlgebraic(identifiers.BA);
+    const BC = reifyAlgebraic(identifiers.BC);
+    const commands = [
+        "B = (-2, -2)",
+        `ShowLabel(B, true)`,
+        `SetFixed(B, true)`,
+        "A = (-2, 2)",
+        `ShowLabel(A, true)`,
+        `SetFixed(A, true)`,
+        "D = (1, 2)",
+        `ShowLabel(D, true)`,
+        `SetFixed(D, true)`,
+        "C= (1, -2)",
+        `ShowLabel(C, true)`,
+        `SetFixed(C, true)`,
+        "SA = Segment(A, B)",
+        "SB = Segment(B, C)",
+        "SC = Segment(C, D)",
+        "SD = Segment(D, A)",
+        "SF = Segment(C, A)",
+        "SetLineStyle(SF, 2)",
+        `Text("\\tiny \\text{${AC.toTex()}}", (-0.5, 0.6), true, true)`,
+        `Text("\\tiny \\text{${BC.toTex()}}", (-0.7, -1.8), true, true)`,
+        `Text("\\tiny \\text{${BA.toTex()}}", (-2.5, 0.5), true, true)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        hideAxes: true,
+        hideFullScreenButton: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-3, 3, -3, 3],
+    });
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getParallelogramLozengeQuestion = (opts) => {
+    const isRectangle = coinFlip();
+    const BA = randint(4, 10);
+    const BC = randint(1, BA);
+    const AC = isRectangle
+        ? sqrt(BA ** 2 + BC ** 2)
+        : sqrt(BA ** 2 + BC ** 2 + randint(-3, 4, [0]));
+    const identifiers = {
+        isRectangle,
+        BA: BA.toTree().toIdentifiers(),
+        BC: BC.toTree().toIdentifiers(),
+        AC: AC.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const parallelogramRectangle = {
+    id: "parallelogramRectangle",
+    label: "Déterminer si un parallélogramme est un rectangle en utilisant Pythagore",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramLozengeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRhombus.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    CB: NodeIdentifiers;
+    CO: NodeIdentifiers;
+    BO: NodeIdentifiers;
+    isLosange: boolean;
+};
+export declare const parallelogramRhombus: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramRhombus.d.ts.map

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRhombus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramRhombus.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/parallelogramRhombus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAoBtD,CAAC"}

package/lib/exercises/math/geometry/quadrilaterals/parallelogramRhombus.js

@@ -0,0 +1,144 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `${identifiers.isLosange ? "Oui" : "Non"}`;
+};
+const getInstruction = (identifiers) => {
+    const { BO, CB, CO } = identifiers;
+    return `$ABCD$ est un parallélogramme de centre $O$, tel que $CO = ${reifyAlgebraic(CO).toTex()}$, $BO = ${reifyAlgebraic(BO).toTex()}$ et $CB = ${reifyAlgebraic(CB).toTex()}$. 
+  
+$ABCD$ est-il un losange ?`;
+};
+const getHint = (identifiers) => {
+    return `Un parallélogramme est un losange si et seulement si ses diagonales sont perpendiculaires. Il faut donc déterminer si $COB$ est un triangle rectangle.`;
+};
+const getCorrection = (identifiers) => {
+    const CO = reifyAlgebraic(identifiers.CO);
+    const BO = reifyAlgebraic(identifiers.BO);
+    const CB = reifyAlgebraic(identifiers.CB);
+    return `Un parallélogramme est un losange si et seulement si ses diagonales sont perpendiculaires. On cherche donc à déterminer si $COB$ est un triangle rectangle. 
+  
+Pour cela, on vérifie si le carré de l'hypoténuse ($CB$) est égal à la somme des carrés des deux autres côtés. D'une part, on a :
+
+$$
+CB^2 = ${square(CB).toTex()} = ${square(CB).simplify().toTex()}
+$$
+
+et d'autre part 
+
+$$
+CO^2 + BO^2 = ${add(square(CO), square(BO)).toTex()} = ${add(square(CO), square(BO))
+        .simplify()
+        .toTex()}.
+$$
+
+${identifiers.isLosange
+        ? `Puisque $CB^2 = CO^2 + BO^2$, d'après la réciproque du théorème de Pythagore, le triangle $COB$ est rectangle en $O$. Les diagonales du parallalélogramme sont donc perpendiculaires : $ABCD$ est donc un losange.`
+        : `Puisque $CB^2$ n'est pas égal à $CO^2 + BO^2$, d'après la contraposée du théorème de Pythagore, le triangle $COB$ n'est rectangle en $O$. Les diagonales du parallalélogramme ne sont donc pas perpendiculaires : $ABCD$ n'est donc pas un losange.`}
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const CO = reifyAlgebraic(identifiers.CO);
+    const BO = reifyAlgebraic(identifiers.BO);
+    const CB = reifyAlgebraic(identifiers.CB);
+    const commands = [
+        "C = (-6, -6)",
+        `ShowLabel(C, true)`,
+        `SetFixed(C, true)`,
+        "D = (-3, 3)",
+        `ShowLabel(D, true)`,
+        `SetFixed(D, true)`,
+        "A = (6, 6)",
+        `ShowLabel(A, true)`,
+        `SetFixed(A, true)`,
+        "B = (3, -3)",
+        `ShowLabel(B, true)`,
+        `SetFixed(B, true)`,
+        "SA = Segment(A, B)",
+        "SB = Segment(B, C)",
+        "SC = Segment(C, D)",
+        "SD = Segment(D, A)",
+        "SE = Segment(B, D)",
+        "SF = Segment(C, A)",
+        "O = Intersect(SE, SF)",
+        `ShowLabel(O, true)`,
+        "SetLineStyle(SE, 2)",
+        "SetLineStyle(SF, 2)",
+        `Text("\\tiny \\text{${BO.toTex()}}", (1, 0.6), true, true)`,
+        `Text("\\tiny \\text{${CO.toTex()}}", (-4.5, -1), true, true)`,
+        `Text("\\tiny \\text{${CB.toTex()}}", (-2.33, -4.33), true, true)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        hideAxes: true,
+        hideFullScreenButton: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-8, 8, -8, 8],
+    });
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getParallelogramLozengeQuestion = (opts) => {
+    const isLosange = coinFlip();
+    const CO = randint(4, 10);
+    const BO = randint(1, CO);
+    const CB = isLosange
+        ? sqrt(CO ** 2 + BO ** 2)
+        : sqrt(CO ** 2 + BO ** 2 + randint(-3, 4, [0]));
+    const identifiers = {
+        isLosange,
+        CO: CO.toTree().toIdentifiers(),
+        BO: BO.toTree().toIdentifiers(),
+        CB: CB.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const parallelogramRhombus = {
+    id: "parallelogramRhombus",
+    label: "Déterminer si un parallélogramme est un losange en utilisant Pythagore",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramLozengeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    firstVec: PointIdentifiers[];
+    secondVec: PointIdentifiers[];
+};
+export declare const colinearityFromPicture: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=colinearityFromPicture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colinearityFromPicture.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/colinearityFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAQtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B,CAAC;AA2NF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

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

@@ -0,0 +1,201 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const firstPoints = identifiers.firstVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const secondPoints = identifiers.secondVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const firstVec = VectorConstructor.fromPoints(firstPoints[0], firstPoints[1]);
+    const secondVec = VectorConstructor.fromPoints(secondPoints[0], secondPoints[1]);
+    return firstVec.isColinear(secondVec) ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const firstPoints = identifiers.firstVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const secondPoints = identifiers.secondVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const firstVec = VectorConstructor.fromPoints(firstPoints[0], firstPoints[1]);
+    const secondVec = VectorConstructor.fromPoints(secondPoints[0], secondPoints[1]);
+    return `On considère la figure suivante : 
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/pointsOnParallelogram.png)
+
+Les vecteurs $${firstVec.toTex()}$ et $${secondVec.toTex()}$ sont-ils colinéaires ?
+`;
+};
+const getHint = (identifiers) => {
+    return `Deux vecteurs sont colinéaires si les droites qui les portent sont parallèles.`;
+};
+const getCorrection = (identifiers) => {
+    const firstPoints = identifiers.firstVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const secondPoints = identifiers.secondVec.map((ids) => PointConstructor.fromIdentifiers(ids));
+    const firstVec = VectorConstructor.fromPoints(firstPoints[0], firstPoints[1]);
+    const secondVec = VectorConstructor.fromPoints(secondPoints[0], secondPoints[1]);
+    const isColinear = firstVec.isColinear(secondVec);
+    if (isColinear) {
+        // if(memedroite){}//
+        if (firstPoints[0].isAligned(secondPoints[0], secondPoints[1]) &&
+            firstPoints[1].isAligned(secondPoints[0], secondPoints[1])) {
+            return `Puisque les vecteurs $${firstVec.toTex()}$ et $${secondVec.toTex()}$ appartiennent à la même droite, ils sont colinéaires.`;
+        }
+        return `Puisque les droites $(${firstVec.name})$ et $(${secondVec.name})$ sont parallèles, les vecteurs $${firstVec.toTex()}$ et $${secondVec.toTex()}$ sont colinéaires.`;
+    }
+    return `Puisque les droites $(${firstVec.name})$ et $(${secondVec.name})$ ne sont pas parallèles, les vecteurs $${firstVec.toTex()}$ et $${secondVec.toTex()}$ ne sont pas colinéaires.`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getColinearityFromPictureQuestion = (ops) => {
+    const points = [];
+    let letterIndex = 65; //"A"
+    for (let j = 0; j < 4; j++) {
+        for (let i = 0; i < 3; i++) {
+            points.push(new Point(String.fromCharCode(letterIndex), i, j));
+            letterIndex++;
+        }
+    }
+    //!mama mia
+    //pardon au moi du futur
+    //en gros l'idée est qu'on construit deux paires de coordonnées de vecteurs colinéaires (ou non colinéaires) puis on boucle à l'infini sur les points pour trouver des points correspondants aux coordonnées des vecteurs choisis
+    let firstVecCoords, secondVecCoords;
+    const isColinear = coinFlip();
+    if (isColinear) {
+        const choices = [
+            [
+                [1, 0],
+                [2, 0],
+            ],
+            [
+                [0, 1],
+                [0, 2],
+                [0, 3],
+            ],
+            [
+                [1, 1],
+                [2, 2],
+            ],
+            [[2, 1]],
+            [[1, 2]],
+            [[1, 3]],
+        ];
+        let choice = random(choices);
+        let firstVecIndex = randint(0, choice.length);
+        firstVecCoords = choice[firstVecIndex];
+        if (choice.length === 1) {
+            firstVecCoords = choice[0];
+            secondVecCoords = choice[0];
+            const reverseFirst = coinFlip();
+            reverseFirst
+                ? (firstVecCoords = firstVecCoords.map((e) => -e))
+                : (secondVecCoords = secondVecCoords.map((e) => -e));
+        }
+        else {
+            let secondVecIndex = randint(0, choice.length);
+            secondVecCoords = choice[secondVecIndex];
+            const mustReverseOne = secondVecIndex === firstVecIndex;
+            const willReverse = mustReverseOne || coinFlip();
+            if (willReverse) {
+                const reverseFirst = coinFlip();
+                reverseFirst
+                    ? (firstVecCoords = firstVecCoords.map((e) => -e))
+                    : (secondVecCoords = secondVecCoords.map((e) => -e));
+            }
+        }
+    }
+    else {
+        //choix précédents + (2,3)
+        const choices = [
+            [
+                [1, 0],
+                [2, 0],
+            ],
+            [
+                [0, 1],
+                [0, 2],
+                [0, 3],
+            ],
+            [
+                [1, 1],
+                [2, 2],
+            ],
+            [[2, 1]],
+            [[1, 2]],
+            [[1, 3]],
+            [[2, 3]],
+        ];
+        const firstChoiceIndex = randint(0, choices.length);
+        const secondChoiceIndex = randint(0, choices.length, [firstChoiceIndex]);
+        firstVecCoords = random(choices[firstChoiceIndex]);
+        secondVecCoords = random(choices[secondChoiceIndex]);
+        const reverseFirst = coinFlip();
+        reverseFirst
+            ? (firstVecCoords = firstVecCoords.map((e) => -e))
+            : (secondVecCoords = secondVecCoords.map((e) => -e));
+    }
+    let firstVec, secondVec;
+    while (true) {
+        const A = random(points);
+        const B = random(points);
+        if (B.x.evaluate() - A.x.evaluate() === firstVecCoords[0] &&
+            B.y.evaluate() - A.y.evaluate() === firstVecCoords[1]) {
+            firstVec = [A.toIdentifiers(), B.toIdentifiers()];
+            break;
+        }
+    }
+    while (true) {
+        const C = random(points);
+        const D = random(points);
+        if (D.x.evaluate() - C.x.evaluate() === secondVecCoords[0] &&
+            D.y.evaluate() - C.y.evaluate() === secondVecCoords[1]) {
+            secondVec = [C.toIdentifiers(), D.toIdentifiers()];
+            break;
+        }
+    }
+    const identifiers = {
+        firstVec,
+        secondVec,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const colinearityFromPicture = {
+    id: "colinearityFromPicture",
+    label: "Reconnaître des vecteurs colinéaires (à partir d'une figure)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getColinearityFromPictureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA6GF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}