math-exercises 2.0.0 → 2.0.2

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythagore = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const lengthNode_1 = require("../../../tree/nodes/geometry/lengthNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const getPythagore = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.7,
+        maxRapport: 1.3,
+        names: vertices,
+    });
+    const sideA = triangle.getSideAName();
+    const sideB = triangle.getSideBName();
+    const sideC = triangle.getSideCName();
+    const answer = `${sideA}^2=${sideB}^2+${sideC}^2`;
+    const question = {
+        instruction: "Écrire l'égalité de Pythagore pour le triangle rectangle suivant : ",
+        answer,
+        keys: [...vertices, "equal"],
+        commands: triangle.generateCommands({}),
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { sideA, sideB, sideC },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, sideA, sideB, sideC }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA} = ${sideB} + ${sideC}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB}^2 - ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideB}^2 = ${sideA}^2 + ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideC}^2 = ${sideA}^2 + ${sideB}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB} + ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB}^2 + ${sideC}`);
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { sideA, sideB, sideC }) => {
+    const answer = new equalNode_1.EqualNode(new powerNode_1.SquareNode(new lengthNode_1.LengthNode(sideA)), new addNode_1.AddNode(new powerNode_1.SquareNode(new lengthNode_1.LengthNode(sideB)), new powerNode_1.SquareNode(new lengthNode_1.LengthNode(sideC))));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.pythagore = {
+    id: "pythagore",
+    connector: "=",
+    label: "Écrire l'égalité de Pythagore",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Théorème de Pythagore", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagore, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/pythagore/pythagoreCalcul.d.ts

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

package/lib/exercises/geometry/pythagore/pythagoreCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/pythagore/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,WAAW,CAYrD,CAAC"}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythagoreCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const real_1 = require("../../../math/numbers/reals/real");
+const randint_1 = require("../../../math/utils/random/randint");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const isInt_1 = require("../../../utils/isInt");
+const shuffle_1 = require("../../../utils/shuffle");
+const getPythagoreCalcul = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 3; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+        minRapport: 0.7,
+        maxRapport: 1.3,
+        names: vertices,
+    });
+    const sides = [
+        triangle.getSideCName(),
+        triangle.getSideBName(),
+        triangle.getSideAName(),
+    ];
+    const sideLengths = [
+        triangle.getSideCnumber(),
+        triangle.getSideBnumber(),
+        triangle.getSideAnumber(),
+    ].map((el) => Math.round(el / 2));
+    const zeroOrOne = (0, shuffle_1.shuffle)([0, 1]);
+    const randoms = (0, coinFlip_1.coinFlip)() ? [...zeroOrOne, 2] : [2, ...zeroOrOne];
+    // le but est d'avoir une chance sur 2 d'avoir un hépoténus et une 1 chance sur 2 d'avoir un a des 2 autres cote
+    let answer;
+    let square;
+    if (randoms[2] === 2) {
+        // cas de l'hypoténus
+        square = sideLengths[0] ** 2 + sideLengths[1] ** 2;
+    }
+    else {
+        // les deux autres cotés
+        square = sideLengths[randoms[0]] ** 2 - sideLengths[randoms[1]] ** 2;
+    }
+    const sqrt = Math.sqrt(square);
+    answer = (0, isInt_1.isInt)(sqrt) ? sqrt + "" : `\\sqrt{${square}}`;
+    const commands = [
+        ...triangle.generateCommands({
+            showLabels: [...sides, sides[randoms[2]]],
+            setCaptions: [...sideLengths.map((el) => el + ""), "?"],
+            highlightedSide: sides[randoms[2]],
+        }),
+    ];
+    answer = answer + "";
+    const question = {
+        instruction: `Dans le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$, on sait que $${sides[randoms[0]]} = ${sideLengths[randoms[0]]}$ et que $${sides[randoms[1]]} = ${sideLengths[randoms[1]]}$. Calculer la longueur exacte $${sides[randoms[2]]}$.`,
+        answer,
+        keys: [...vertices, "equal"],
+        commands,
+        coords: triangle.generateCoords(),
+        answerFormat: "tex",
+        identifiers: { square, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const temp = (0, randint_1.randint)(2, 300);
+        const squareRoot = new real_1.SquareRoot(temp);
+        const wrongAnswer = Math.sqrt(temp) === Math.floor(Math.sqrt(temp))
+            ? Math.sqrt(temp).toString()
+            : squareRoot.toTree().toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { square }) => {
+    const sqrt = Math.sqrt(square);
+    const answer = (0, isInt_1.isInt)(sqrt)
+        ? new numberNode_1.NumberNode(sqrt)
+        : new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(square), { allowSimplifySqrt: true });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.pythagoreCalcul = {
+    id: "pythagoreCalcul",
+    connector: "=",
+    label: "Utiliser le théoreme de Pythagore pour faire des calculs",
+    levels: ["4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Théorème de Pythagore", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagoreCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,3 @@
+export * from "./thales";
+export * from "./thalesCalcul";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/thales/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./thales"), exports);
+__exportStar(require("./thalesCalcul"), exports);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAsIF,eAAO,MAAM,MAAM,EAAE,YAAY,CAAC,WAAW,CAY5C,CAAC"}

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thales = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const multiEqualNode_1 = require("../../../tree/nodes/equations/multiEqualNode");
+const lengthNode_1 = require("../../../tree/nodes/geometry/lengthNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getThales = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 5; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const [xA, yA] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
+    let xB, yB, xC, yC;
+    let d1, d2; // distance entre le point A et B
+    let theta = 0; // angle entre AB et AC
+    do {
+        [xB, yB, xC, yC] = [
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+        ];
+        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
+        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
+        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
+    } while (!theta ||
+        theta < 0.35 ||
+        theta > 2.1 ||
+        d1 / d2 > 1.3 ||
+        d1 / d2 < 0.7);
+    const factor = (0, randint_1.randint)(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
+    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
+    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
+    const xMin = Math.min(xA, xB, xC, xD, xE);
+    const xMax = Math.max(xA, xB, xC, xD, xE);
+    const yMin = Math.min(yA, yB, yC, yD, yE);
+    const yMax = Math.max(yA, yB, yC, yD, yE);
+    const commands = [
+        `${vertices[0]} = Point({${xA}, ${yA}})`,
+        `${vertices[1]} = Point({${xB}, ${yB}})`,
+        `${vertices[2]} = Point({${xC}, ${yC}})`,
+        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
+        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
+        `l = Segment(${vertices[0]}, ${vertices[1]})`,
+        `i = Segment(${vertices[0]}, ${vertices[2]})`,
+        `j = Segment(${vertices[1]}, ${vertices[2]})`,
+        `k = Segment(${vertices[3]}, ${vertices[4]})`,
+        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
+        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
+        `ShowAxes(false)`,
+        `ShowGrid(false)`,
+        `ShowLabel(${vertices[0]}, true)`,
+        `ShowLabel(${vertices[1]}, true)`,
+        `ShowLabel(${vertices[2]}, true)`,
+        `ShowLabel(${vertices[3]}, true)`,
+        `ShowLabel(${vertices[4]}, true)`,
+    ];
+    const answer = `\\frac{${vertices[0]}${vertices[3]}}{${vertices[0]}${vertices[1]}}=\\frac{${vertices[0]}${vertices[4]}}{${vertices[0]}${vertices[2]}}=\\frac{${vertices[3]}${vertices[4]}}{${vertices[1]}${vertices[2]}}`;
+    const question = {
+        instruction: `En utilisant le théoreme de Thalès, écrire l'égalité des quotients sachant que  $(${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})$.`,
+        answer,
+        keys: [...vertices, "equal"],
+        commands,
+        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+        answerFormat: "tex",
+        identifiers: { vertices },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, vertices }) => {
+    const propositions = [];
+    const wrongQuotients = [
+        vertices[0] + vertices[3],
+        vertices[0] + vertices[1],
+        vertices[0] + vertices[4],
+        vertices[0] + vertices[2],
+        vertices[3] + vertices[4],
+        vertices[1] + vertices[2],
+        vertices[1] + vertices[3],
+        vertices[2] + vertices[4],
+    ];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const indexRange = Array.from({ length: 8 }, (_, i) => i);
+    while (propositions.length < n) {
+        const rands = (0, shuffle_1.shuffle)(indexRange).slice(0, 6);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\frac{${wrongQuotients[rands[0]]}}{${wrongQuotients[rands[1]]}} = 
+    \\frac{${wrongQuotients[rands[2]]}}{${wrongQuotients[rands[3]]}} = 
+    \\frac{${wrongQuotients[rands[4]]}}{${wrongQuotients[rands[5]]}}`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { vertices }) => {
+    const lengths = [
+        new lengthNode_1.LengthNode(`${vertices[0]}${vertices[3]}`),
+        new lengthNode_1.LengthNode(`${vertices[0]}${vertices[1]}`),
+        new lengthNode_1.LengthNode(`${vertices[0]}${vertices[4]}`),
+        new lengthNode_1.LengthNode(`${vertices[0]}${vertices[2]}`),
+        new lengthNode_1.LengthNode(`${vertices[3]}${vertices[4]}`),
+        new lengthNode_1.LengthNode(`${vertices[1]}${vertices[2]}`),
+    ];
+    const fractions = [
+        new fractionNode_1.FractionNode(lengths[0], lengths[1]),
+        new fractionNode_1.FractionNode(lengths[2], lengths[3]),
+        new fractionNode_1.FractionNode(lengths[4], lengths[5]),
+    ];
+    const answers = [
+        new multiEqualNode_1.MultiEqualNode(fractions),
+        new multiEqualNode_1.MultiEqualNode(fractions.map((frac) => frac.toInversed())),
+    ];
+    const texs = [...answers[0].toAllValidTexs(), ...answers[1].toAllValidTexs()];
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.thales = {
+    id: "thales",
+    connector: "=",
+    label: "Ecrire l'égalité de Thalès",
+    levels: ["5ème", "4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Théorème de Thalès", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/thales/thalesCalcul.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    sideLengths: number[];
+    rand: number;
+    rand2: number;
+    isAskingC: boolean;
+};
+export declare const thalesCalcul: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=thalesCalcul.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAgLF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAYlD,CAAC"}

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thalesCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getThales = () => {
+    const vertices = [];
+    const code = 65 + (0, randint_1.randint)(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
+    for (let i = 0; i < 5; i++)
+        vertices.push(String.fromCharCode(code + i));
+    const [xA, yA] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
+    let xB, yB, xC, yC;
+    let d1, d2, d3; // distance entre le point A et B
+    let theta = 0; // angle entre AB et AC
+    do {
+        [xB, yB, xC, yC] = [
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+            (0, randint_1.randint)(-10, 11),
+        ];
+        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
+        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
+        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
+    } while (!theta ||
+        theta < 0.35 ||
+        theta > 2.1 ||
+        d1 / d2 > 1.3 ||
+        d1 / d2 < 0.7);
+    d3 = Math.sqrt(d1 ** 2 + d2 ** 2 - 2 * d1 * d2 * Math.cos(theta)); // Calculer la distance entre C et B
+    // CB² = AB² * AC² - 2*AB*AC*cos(theta)  : pythagore généralisé
+    const factor = (0, randint_1.randint)(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
+    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
+    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
+    const xMin = Math.min(xA, xB, xC, xD, xE);
+    const xMax = Math.max(xA, xB, xC, xD, xE);
+    const yMin = Math.min(yA, yB, yC, yD, yE);
+    const yMax = Math.max(yA, yB, yC, yD, yE);
+    // AB AC BC AD AE
+    const sides = [
+        `${vertices[0]}${vertices[1]}`,
+        `${vertices[0]}${vertices[3]}`,
+        `${vertices[0]}${vertices[2]}`,
+        `${vertices[0]}${vertices[4]}`,
+        `${vertices[1]}${vertices[2]}`,
+        `${vertices[3]}${vertices[4]}`,
+    ];
+    // round pour avoir des valeurs dans N tout en gardant les proportions pour que ça soit cohérent. sides[i] a pour longueur sideLengths[i]
+    const sideLengths = [d1, factor * d1, d2, factor * d2, d3, factor * d3].map((el) => Math.round(Math.abs(el)));
+    const rand = (0, randint_1.randint)(0, 3);
+    let rand2 = (0, randint_1.randint)(0, 3, [rand]);
+    if (sideLengths[2 * rand] === sideLengths[2 * rand2])
+        rand2 = (0, randint_1.randint)(0, 3, [rand, rand2]); // condition pour pas prendre 2 longueurs identiques
+    let instruction = `Dans la figure ci-dessous, on a $(${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})$, `;
+    let statement;
+    let startStatement;
+    const isAskingC = (0, coinFlip_1.coinFlip)();
+    if (isAskingC) {
+        // a/b = c/d on cherche c
+        instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${sides[2 * rand + 1]} = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2]} = ${sideLengths[2 * rand2]}$. Déterminer $${sides[2 * rand2 + 1]}$.`;
+        startStatement = `${sides[2 * rand2 + 1]}`;
+        statement = new rational_1.Rational(sideLengths[2 * rand2] * sideLengths[2 * rand + 1], sideLengths[2 * rand])
+            .simplify()
+            .toTree();
+    }
+    else {
+        // a/b = c/d on cherche d
+        instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${sides[2 * rand + 1]} = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2 + 1]} = ${sideLengths[2 * rand2 + 1]}$. Déterminer $${sides[2 * rand2]}$.`;
+        startStatement = `${sides[2 * rand2]}`;
+        statement = new rational_1.Rational(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand], sideLengths[2 * rand + 1])
+            .simplify()
+            .toTree();
+    }
+    const commands = [
+        `${vertices[0]} = Point({${xA}, ${yA}})`,
+        `${vertices[1]} = Point({${xB}, ${yB}})`,
+        `${vertices[2]} = Point({${xC}, ${yC}})`,
+        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
+        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
+        `l = Segment(${vertices[0]}, ${vertices[1]})`,
+        `i = Segment(${vertices[0]}, ${vertices[2]})`,
+        `j = Segment(${vertices[1]}, ${vertices[2]})`,
+        `k = Segment(${vertices[3]}, ${vertices[4]})`,
+        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
+        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
+        `ShowAxes(false)`,
+        `ShowGrid(false)`,
+        `ShowLabel(${vertices[0]}, true)`,
+        `ShowLabel(${vertices[1]}, true)`,
+        `ShowLabel(${vertices[2]}, true)`,
+        `ShowLabel(${vertices[3]}, true)`,
+        `ShowLabel(${vertices[4]}, true)`,
+    ];
+    const answer = statement.toTex();
+    const question = {
+        instruction,
+        startStatement,
+        answer,
+        keys: [],
+        commands,
+        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+        answerFormat: "tex",
+        identifiers: { isAskingC, rand, rand2, sideLengths },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational((0, randint_1.randint)(2, 30), (0, randint_1.randint)(2, 30)).simplify().toTree().toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { isAskingC, rand, rand2, sideLengths }) => {
+    let answer;
+    if (isAskingC)
+        answer = new rational_1.Rational(sideLengths[2 * rand2] * sideLengths[2 * rand + 1], sideLengths[2 * rand])
+            .simplify()
+            .toTree();
+    else
+        answer = new rational_1.Rational(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand], sideLengths[2 * rand + 1])
+            .simplify()
+            .toTree();
+    const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.thalesCalcul = {
+    id: "thalesCalcul",
+    connector: "=",
+    label: "Utiliser le théoreme de Thalès pour faire des calculs",
+    levels: ["5ème", "4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Théorème de Thalès", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -1,9 +1,8 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
     randLetters: string[];
+    vectors: string[];
 };
-type VEAProps = {};
-export declare const chasles: MathExercise<QCMProps, VEAProps>;
+export declare const chasles: MathExercise<Identifiers>;
 export {};
 //# sourceMappingURL=chasles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA4CnB,eAAO,MAAM,OAAO,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWpD,CAAC"}
+{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,YAAY,CAAC,WAAW,CAY7C,CAAC"}

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAsDnB,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW/D,CAAC"}
+{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,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;AAgEF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAaxD,CAAC"}