math-exercises 3.0.88 → 3.0.90

package/lib/exercises/math/functions/variations/varTableFromGraph.js

@@ -0,0 +1,184 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getFunc = (identifiers) => {
+    const { coeffs } = identifiers;
+    const poly = new Polynomial(coeffs);
+    return (x) => coeffs;
+};
+const getRoots = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [d, c, b, a] = coeffs;
+    const sqrtDelta = 2 * Math.sqrt(b ** 2 - 3 * a * c);
+    const x1 = (-2 * b - sqrtDelta) / (6 * a);
+    const x2 = (-2 * b + sqrtDelta) / (6 * a);
+    return [x1, x2].sort((a, b) => a - b);
+};
+const getGGBOptions = (identifiers) => {
+    const { coeffs } = identifiers;
+    const poly = new Polynomial(coeffs);
+    const commands = [`f(x) =${poly.toMathString()}`];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+    });
+    const [x1, x2] = getRoots(identifiers);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: x1 - 2,
+            xMax: x2 + 2,
+            yMin: Math.min(fx1, fx2) - 2,
+            yMax: Math.max(fx1, fx2) + 2,
+        }),
+    });
+};
+const getAnswerTable = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [d, c, b, a] = coeffs;
+    const poly = new Polynomial(coeffs);
+    const [x1, x2] = getRoots(identifiers);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    const vars = coeffs[3] > 0
+        ? ["\\nearrow", "\\searrow", "\\nearrow"]
+        : ["\\searrow", "\\nearrow", "\\searrow"];
+    return [
+        [
+            "$x$",
+            "-\\infty",
+            "\\ ",
+            x1.toTree().toTex(),
+            "\\ ",
+            x2.toTree().toTex(),
+            "\\ ",
+            "+\\infty",
+        ],
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a > 0 ? fx1.toTree().toTex() : "\\ ",
+            "\\ ",
+            a > 0 ? "\\ " : fx1.toTree().toTex(),
+            "\\ ",
+            "\\ ",
+        ],
+        ["$f(x)$", "\\ ", vars[0], "\\ ", vars[1], "\\ ", vars[2], "\\ "],
+        [
+            "$\\ $",
+            "\\ ",
+            "\\ ",
+            a > 0 ? "\\ " : fx2.toTree().toTex(),
+            "\\ ",
+            a > 0 ? fx2.toTree().toTex() : "\\ ",
+            "\\ ",
+            "\\ ",
+        ],
+    ];
+};
+const getInstruction = (identifiers) => {
+    return `Dresser le tableau de variations de la fonction $f$ définie sur $\\mathbb{R}$ dont la courbe représentative est donnée ci-dessous :`;
+};
+const getHint = (identifiers) => {
+    return `La fonction est définie sur $\\mathbb{R}$, donc les valeurs de $x$ vont de $-\\infty$ à $+\\infty$.
+  
+Repère ensuite les points de la courbe auxquels le sens de variation change. Dans la première ligne du tableau, il faut mettre les abscisses de ces points, et dans la deuxième ligne, les ordonnées.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const [d, c, b, a] = coeffs;
+    const poly = new Polynomial(coeffs);
+    const [x1, x2] = getRoots(identifiers);
+    const fx1 = poly.calculate(x1);
+    const fx2 = poly.calculate(x2);
+    const words = a > 0
+        ? ["croissante", "décroissante", "croissante"]
+        : ["décroissante", "croissante", "décroissante"];
+    return `D'après le graphique, la fonction $f$ est ${words[0]} sur $]-\\infty; ${x1}]$, puis ${words[1]} sur $[${x1}; ${x2}]$, puis ${words[2]} sur $[${x2}; +\\infty[$.
+
+De plus, on lit graphiquement que l'image de $${x1}$ est $${fx1}$, et celle de $${x2}$ est $${fx2}$.
+
+
+`;
+};
+const getKeys = (identifiers) => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return ans.every((row, i) => row.every((cell, j) => cell === answerTable[i][j]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+// const lists = [
+//   "x^3 - 3x",
+//   "x^3 -6x^2 + 9x",
+//   "-x^3 + 3x^2 + 9x",
+//   "2x^3 - 9x^2 + 12x",
+//   "-x^3+6x^2-9x",
+//   "4x^3 -24x^2 + 36x",
+// ];
+const poly3Coeffs = [
+    [0, -3, 0, 1],
+    [0, 9, -6, 1],
+    // [0, 9, 3, -1],
+    [0, 12, -9, 2],
+    [0, -9, 6, -1],
+    // [0, 36, -24, 4],
+];
+const getTestSignTableQuestion = (ops) => {
+    const index = randint(0, 4);
+    const coeffs = coinFlip()
+        ? poly3Coeffs[index]
+        : poly3Coeffs[index].map((x) => -x);
+    const initTable = [
+        ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+        ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ["$\\ $", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ ", "\\ "],
+    ];
+    const identifiers = {
+        type: 0,
+        coeffs: [coeffs[0] + randint(-10, 10), ...coeffs.slice(1)],
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const varTableFromGraph = {
+    id: "varTableFromGraph",
+    label: "Dresser le tableau de variations d'une fonction à partir de sa représentation graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTestSignTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "varTable",
+    hasGeogebra: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"alignementViaColinearity.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/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;AA8HF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

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

@@ -0,0 +1,127 @@
+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 { 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$ et $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$ et $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 xA = randint(-10, 11);
+    const yA = randint(-10, 11);
+    const xB = randint(-10, 11, [xA]);
+    const yB = randint(-10, 11, [yA]);
+    const points = [new Point("A", xA, yA), new Point("B", xB, yB)];
+    const AB = VectorConstructor.fromPoints(points[0], points[1]);
+    let C;
+    const isAligned = coinFlip();
+    const coeff = new NumberNode(randint(-4, 4, [0, 1]));
+    if (isAligned) {
+        C = AB.times(coeff).getEndPoint(points[0], "C");
+    }
+    else {
+        do {
+            C = PointConstructor.random("C");
+        } while (AB.isColinear(VectorConstructor.fromPoints(points[0], C)));
+    }
+    const identifiers = {
+        xA,
+        xB,
+        xC: C.x.evaluate({}),
+        yA,
+        yB,
+        yC: C.y.evaluate({}),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+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 alignementViaColinearity = {
+    id: "alignementViaColinearity",
+    label: "Utiliser la colinéarité pour déterminer un alignement",
+    isSingleStep: true,
+    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/colinearity.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    xu: NodeIdentifiers;
+    yu: NodeIdentifiers;
+    xv: NodeIdentifiers;
+    yv: NodeIdentifiers;
+};
+export declare const colinearity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=colinearity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colinearity.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/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/colinearity.js

@@ -0,0 +1,118 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 = coinFlip()
+            ? new NumberNode(randint(-5, 5, [0, 1]))
+            : RationalConstructor.randomIrreductible(5).toTree();
+        v = u.times(coeff, "v");
+    }
+    else {
+        do {
+            v = VectorConstructor.random("v", false);
+        } while (u.isColinear(v));
+    }
+    const identifiers = {
+        xu: u.x.toIdentifiers(),
+        xv: v.x.toIdentifiers(),
+        yu: u.y.toIdentifiers(),
+        yv: v.y.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    // 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");
+    return shuffle(propositions);
+};
+export const colinearity = {
+    id: "colinearity",
+    label: "Déterminer si deux vecteurs sont colinéaires (par les coordonnées)",
+    isSingleStep: true,
+    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/colinearity/colinearityFromBasis.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    c: NodeIdentifiers;
+    d: NodeIdentifiers;
+};
+export declare const colinearityFromBasis: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=colinearityFromBasis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colinearityFromBasis.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/colinearityFromBasis.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IAEjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AAgKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

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

@@ -0,0 +1,158 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.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");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const coeffs = [a, b, c, d].map((e) => reifyAlgebraic(e));
+    const det = substract(multiply(coeffs[0], coeffs[3]), multiply(coeffs[1], coeffs[2])).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+    return Math.abs(det.evaluate()) < 0.001 ? "Oui" : "Non";
+};
+const getUNode = (identifiers) => {
+    const { a, b } = identifiers;
+    const coeffs = [a, b].map((e) => reifyAlgebraic(e));
+    return add(multiply(coeffs[0], "\\overrightarrow{AB}"), multiply(coeffs[1], "\\overrightarrow{AC}")).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+};
+const getVNode = (identifiers) => {
+    const { c, d } = identifiers;
+    const coeffs = [c, d].map((e) => reifyAlgebraic(e));
+    return add(multiply(coeffs[0], "\\overrightarrow{AB}"), multiply(coeffs[1], "\\overrightarrow{AC}")).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+};
+const getInstruction = (identifiers) => {
+    return `$A$, $B$ et $C$ sont trois points distincts et non alignés. 
+ 
+On considère les vecteurs : 
+
+$$
+\\overrightarrow{u} = ${getUNode(identifiers).toTex()} 
+$$
+
+et
+
+$$
+\\overrightarrow{v} = ${getVNode(identifiers).toTex()}
+$$
+
+Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ sont-ils colinéaires ?`;
+};
+const getHint = (identifiers) => {
+    return `Peux-tu trouver un nombre $k$ tel que $\\overrightarrow{u} = k \\overrightarrow{v}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const coeffs = [a, b, c, d].map((e) => reifyAlgebraic(e));
+    const det = substract(multiply(coeffs[0], coeffs[3]), multiply(coeffs[1], coeffs[2])).simplify({ forceDistributeFractions: true, forbidFactorize: true });
+    const isColinear = Math.abs(det.evaluate()) < 0.001;
+    const k = frac(coeffs[2], coeffs[0]).simplify();
+    const k2 = frac(coeffs[3], coeffs[1]).simplify();
+    return `On cherche un nombre $k$ tel que $\\overrightarrow{u} = k \\overrightarrow{v}$.
+  
+Puisque les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{AC}$ ne sont pas colinéaires, ce nombre $k$ doit vérifier :
+
+$$
+${multiply(coeffs[0], "\\overrightarrow{AB}").toTex()} \\times k = ${multiply(coeffs[2], "\\overrightarrow{AB}").toTex()}
+$$
+
+ce qui donne $k = ${k.toTex()}$, et : 
+
+$$
+${multiply(coeffs[1], "\\overrightarrow{AC}").toTex()} \\times k = ${multiply(coeffs[3], "\\overrightarrow{AC}").toTex()}
+$$
+
+ce qui donne $k = ${k2.toTex()}$.
+
+${isColinear
+        ? `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ sont donc colinéaires.
+`
+        : `
+On en conclut que les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ ne sont pas colinéaires.`}
+
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getColinearityFromBasisQuestion = (ops) => {
+    const isColinear = coinFlip();
+    let a;
+    let b;
+    let c;
+    let d;
+    if (isColinear) {
+        const k = coinFlip()
+            ? randint(-5, 5, [0, 1]).toTree()
+            : RationalConstructor.randomIrreductible().toTree();
+        a = randint(-8, 8, [0]).toTree();
+        b = randint(-8, 8, [0]).toTree();
+        c = multiply(a, k).simplify();
+        d = multiply(b, k).simplify();
+    }
+    else {
+        do {
+            a = randint(-8, 8, [0]).toTree();
+            b = randint(-8, 8, [0]).toTree();
+            c = randint(-8, 8, [0]).toTree();
+            d = randint(-8, 8, [0]).toTree();
+        } while (substract(multiply(a, d), multiply(b, c)).evaluate() === 0);
+    }
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b: b.toIdentifiers(),
+        c: c.toIdentifiers(),
+        d: d.toIdentifiers(),
+    };
+    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),
+    };
+};
+export const colinearityFromBasis = {
+    id: "colinearityFromBasis",
+    connector: "=",
+    label: "Reconnaître des vecteurs colinéaires (à partir d'expressions)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getColinearityFromBasisQuestion(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/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./colinearity.js";
+export * from "./alignementViaColinearity.js";
+export * from "./colinearityFromBasis.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/colinearity/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./colinearity.js";
+export * from "./alignementViaColinearity.js";
+export * from "./colinearityFromBasis.js";

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    expression: NodeIdentifiers;
+    type: number;
+};
+export declare const distributeAndReduceVectors: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=distributeAndReduceVectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"distributeAndReduceVectors.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/distributeAndReduceVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+MF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}