math-exercises 1.3.30 → 1.3.32

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

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const thales: Exercise;
+export declare function getThales(): Question;
+//# sourceMappingURL=thales.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAI9D,eAAO,MAAM,MAAM,EAAE,QASpB,CAAC;AAEF,wBAAgB,SAAS,IAAI,QAAQ,CAyDpC"}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThales = exports.thales = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+exports.thales = {
+    id: 'thales',
+    connector: '=',
+    instruction: '',
+    label: "Ecrire l'égalité de Thalès",
+    levels: ['5', '4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+};
+function 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 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: `\\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]}}`,
+        keys: [...vertices, 'equal'],
+        commands,
+        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+    };
+    return question;
+}
+exports.getThales = getThales;

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

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const thalesCalcul: Exercise;
+export declare function getThales(): Question;
+//# sourceMappingURL=thalesCalcul.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQ9D,eAAO,MAAM,YAAY,EAAE,QAS1B,CAAC;AAEF,wBAAgB,SAAS,IAAI,QAAQ,CAgHpC"}

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

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThales = exports.thalesCalcul = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const simplify_1 = require("../../../tree/parsers/simplify");
+const coinFlip_1 = require("../../../utils/coinFlip");
+exports.thalesCalcul = {
+    id: 'thalesCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser le théoreme de Thalès pour faire des calculs',
+    levels: ['5', '4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+};
+function 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, nous avons (${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]}), `;
+    let statement;
+    let startStatement;
+    if ((0, coinFlip_1.coinFlip)()) {
+        // 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 = (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(sideLengths[2 * rand2] * sideLengths[2 * rand + 1]), new numberNode_1.NumberNode(sideLengths[2 * rand])));
+    }
+    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 = (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand]), new numberNode_1.NumberNode(sideLengths[2 * rand + 1])));
+    }
+    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 question = {
+        instruction,
+        startStatement,
+        answer: statement.toTex(),
+        keys: [],
+        commands,
+        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+    };
+    return question;
+}
+exports.getThales = getThales;

package/lib/exercises/geometry/euclidean/trigonometry.d.ts

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const trigonometry: Exercise;
+export declare function getTrigonometry(): Question;
+//# sourceMappingURL=trigonometry.d.ts.map

package/lib/exercises/geometry/euclidean/trigonometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAK9D,eAAO,MAAM,YAAY,EAAE,QAS1B,CAAC;AAEF,wBAAgB,eAAe,IAAI,QAAQ,CA2C1C"}

package/lib/exercises/geometry/euclidean/trigonometry.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrigonometry = exports.trigonometry = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+exports.trigonometry = {
+    id: 'trigonometry',
+    connector: '=',
+    instruction: '',
+    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometry, nb),
+};
+function getTrigonometry() {
+    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 trigo = ['le cosinus', 'le sinus', 'la tangente'];
+    const randTrigo = (0, randint_1.randint)(0, 3);
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    let quotient;
+    switch (randAngle) {
+        case 0:
+            quotient = [
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideCName()}}`,
+            ];
+            break;
+        case 1:
+            quotient = [
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideBName()}}`,
+            ];
+            break;
+        default:
+            quotient = [''];
+    }
+    const question = {
+        instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angle[randAngle]}}$?`,
+        answer: quotient[randTrigo],
+        keys: [...vertices, 'equal'],
+        commands: [...triangle.generateCommands({ highlightedAngle: angle[randAngle] })],
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getTrigonometry = getTrigonometry;

package/lib/exercises/geometry/euclidean/trigonometryAngleCalcul.d.ts

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const trigonometryAngleCalcul: Exercise;
+export declare function getTrigonometryAngleCalcul(): Question;
+//# sourceMappingURL=trigonometryAngleCalcul.d.ts.map

package/lib/exercises/geometry/euclidean/trigonometryAngleCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAO9D,eAAO,MAAM,uBAAuB,EAAE,QASrC,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,QAAQ,CAoCrD"}

package/lib/exercises/geometry/euclidean/trigonometryAngleCalcul.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrigonometryAngleCalcul = exports.trigonometryAngleCalcul = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const shuffle_1 = require("../../../utils/shuffle");
+exports.trigonometryAngleCalcul = {
+    id: 'trigonometryAngleCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser la trigonométrie pour calculer un angle',
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+};
+function getTrigonometryAngleCalcul() {
+    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.5, maxRapport: 1.5, names: vertices });
+    const sides = [triangle.getSideCName(), triangle.getSideBName(), triangle.getSideAName()];
+    const sideLengths = [triangle.getSideCnumber(), triangle.getSideBnumber(), triangle.getSideAnumber()].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randSides = (0, shuffle_1.shuffle)([0, 1, 2]);
+    const answer = randAngle === 0
+        ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
+        : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
+    const question = {
+        instruction: `Le triangle ${triangle.getTriangleName()} rectangle en ${triangle.getRightAngle()} est tel que ${sides[randSides[0]]} = $${sideLengths[randSides[0]]}$ cm et ${sides[randSides[1]]} = $${sideLengths[randSides[1]]}$ cm.$\\\\$ Calculer $\\widehat{${angle[randAngle]}}$ à 1° près.`,
+        answer: answer + '°',
+        keys: [...vertices, 'equal', '°', 'cos', 'sin', 'tan', 'arccos', 'arcsin', 'arctan'],
+        commands: [...triangle.generateCommands({ highlightedAngle: angle[randAngle] })],
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getTrigonometryAngleCalcul = getTrigonometryAngleCalcul;

package/lib/exercises/geometry/euclidean/trigonometrySideCalcul.d.ts

@@ -0,0 +1,4 @@
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const trigonometrySideCalcul: Exercise;
+export declare function getTrigonometrySideCalcul(): Question;
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/geometry/euclidean/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAM9D,eAAO,MAAM,sBAAsB,EAAE,QASpC,CAAC;AAEF,wBAAgB,yBAAyB,IAAI,QAAQ,CA+CpD"}

package/lib/exercises/geometry/euclidean/trigonometrySideCalcul.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrigonometrySideCalcul = exports.trigonometrySideCalcul = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+exports.trigonometrySideCalcul = {
+    id: 'trigonometrySideCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser la trigonométrie pour calculer un côté',
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+};
+function getTrigonometrySideCalcul() {
+    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.5, maxRapport: 1.5, names: vertices });
+    const sides = [triangle.getSideCName(), triangle.getSideBName(), triangle.getSideAName()];
+    const sideLengths = [triangle.getSideCnumber(), triangle.getSideBnumber(), triangle.getSideAnumber()].map((el) => (0, round_1.round)(el / 2, 2));
+    const angle = [triangle.vertexB.name, triangle.vertexC.name];
+    const randAngle = (0, randint_1.randint)(0, 2);
+    const randside = (0, randint_1.randint)(0, 3); // valeurs possible : 0 1 2
+    const randsideQuestion = (0, randint_1.randint)(0, 3, [randside]); // si rand = 0, valeurs possible 1 2
+    const angleValue = [
+        (0, round_1.round)((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI, 1),
+        (0, round_1.round)((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI, 1),
+    ];
+    const commands = [
+        ...triangle.generateCommands({
+            highlightedAngle: angle[randAngle],
+            colorHighlightedAngle: 'Black',
+            showLabels: [sides[randsideQuestion]],
+            setCaptions: ['?'],
+            highlightedSide: sides[randsideQuestion],
+        }),
+    ];
+    const question = {
+        instruction: `Le triangle ${triangle.getTriangleName()} rectangle en ${triangle.getRightAngle()} tel que ${sides[randside]} = $${sideLengths[randside]}$ cm et $\\widehat{${angle[randAngle]}}$ = $${angleValue[randAngle]}$°.$\\\\$ Calculer ${sides[randsideQuestion]} à $0,1$ cm près.`,
+        answer: `${(0, round_1.round)(sideLengths[randsideQuestion], 1)}`,
+        keys: [...vertices, 'equal', '°', 'cos', 'sin', 'tan', 'arccos', 'arcsin', 'arctan'],
+        commands,
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getTrigonometrySideCalcul = getTrigonometrySideCalcul;

package/lib/exercises/proba/probabilityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../src/exercises/proba/probabilityTree.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGjD,eAAO,MAAM,eAAe,EAAE,QAS7B,CAAC;AAEF,wBAAgB,kBAAkB,IAAI,QAAQ,CAwF7C"}
+{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../src/exercises/proba/probabilityTree.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGjD,eAAO,MAAM,eAAe,EAAE,QAS7B,CAAC;AAOF,wBAAgB,kBAAkB,IAAI,QAAQ,CAwF7C"}

package/lib/exercises/proba/probabilityTree.js

@@ -16,6 +16,11 @@ exports.probabilityTree = {
     section: 'Probabilités',
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProbabilityTree, nb),
 };
+function pgcd(a, b) {
+    while (b)
+        [a, b] = [b, a % b];
+    return a;
+}
 function getProbabilityTree() {
     const A = (0, randint_1.randint)(2, 9);
     const B = (0, randint_1.randint)(2, 10 - A);
@@ -74,12 +79,12 @@ function getProbabilityTree() {
         'Segment(B,BD)',
         'ShowAxes(false)',
         'ShowGrid(false)',
-        `Text("\\scriptsize${A}/${A + B}", (0.3, 2.1), true, true)`,
-        `Text("\\scriptsize${AC}/${AC + AD}", (2.8, 3.5), true, true)`,
-        `Text("\\scriptsize${AD}/${AC + AD}", (2.8, 1.4), true, true)`,
-        `Text("\\scriptsize${B}/${A + B}", (0.3, -1.2), true, true)`,
-        `Text("\\scriptsize${BC}/${BC + BD}", (2.8, -0.6), true, true)`,
-        `Text("\\scriptsize${BD}/${BC + BD}", (2.8, -2.5), true, true)`,
+        `Text("\\scriptsize${A / pgcd(A, A + B)}/${(A + B) / pgcd(A, A + B)}", (0.3, 2.1), true, true)`,
+        `Text("\\scriptsize${AC / pgcd(AC, AC + AD)}/${(AC + AD) / pgcd(AC, AC + AD)}", (2.8, 3.5), true, true)`,
+        `Text("\\scriptsize${AD / pgcd(AD, AC + AD)}/${(AC + AD) / pgcd(AD, AC + AD)}", (2.8, 1.4), true, true)`,
+        `Text("\\scriptsize${B / pgcd(B, A + B)}/${(A + B) / pgcd(B, A + B)}", (0.3, -1.2), true, true)`,
+        `Text("\\scriptsize${BC / pgcd(BC, BC + BD)}/${(BC + BD) / pgcd(BC, BC + BD)}", (2.8, -0.6), true, true)`,
+        `Text("\\scriptsize${BD / pgcd(BD, BC + BD)}/${(BC + BD) / pgcd(BD, BC + BD)}", (2.8, -2.5), true, true)`,
         'Text("A", (1.85 , 2.5))',
         'Text("B", (1.85 , -2.8))',
         'Text("C", (5.5 , 2.85))',

package/lib/math/geometry/droite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"droite.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/droite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,MAAM;IAM5D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;IAI/D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;CAKpE;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBAEI,IAAI,oBAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAOxC,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,oBAAoB,IAAI,MAAM;IAI9B,UAAU,IAAI,MAAM;IAKpB,qBAAqB,IAAI,MAAM;IAI/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,KAAK,GAAG,IAAI;CAMlD"}
+{"version":3,"file":"droite.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/droite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAIhC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,MAAM;IAM5D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;IAI/D,MAAM,CAAC,iBAAiB,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,SAAM,GAAG,MAAM;CAKpE;AAED,qBAAa,MAAM;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBAEI,IAAI,oBAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAOxC,KAAK,IAAI,MAAM;IAIf,cAAc,IAAI,MAAM;IAIxB,oBAAoB,IAAI,MAAM;IAI9B,UAAU,IAAI,MAAM;IAKpB,qBAAqB,IAAI,MAAM;IAI/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,SAAM,GAAG,KAAK,GAAG,IAAI;CAMlD"}

package/lib/math/geometry/droite.js

@@ -10,6 +10,7 @@ const simplify_1 = require("../../tree/parsers/simplify");
 const mathjs_1 = require("mathjs");
 const point_1 = require("./point");
 const polynomial_1 = require("../polynomials/polynomial");
+const round_1 = require("../utils/round");
 class DroiteConstructor {
     static fromTwoPoints(A, B, name = 'd') {
         const a = new fractionNode_1.FractionNode(new substractNode_1.SubstractNode(B.y, A.y), new substractNode_1.SubstractNode(B.x, A.x));
@@ -20,7 +21,7 @@ class DroiteConstructor {
         return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x))));
     }
     static fromPointAndAngle(A, theta, name = 'd') {
-        const m = new numberNode_1.NumberNode((0, mathjs_1.round)(Math.tan(parseFloat(theta.toMathString())), 2));
+        const m = new numberNode_1.NumberNode((0, round_1.round)(Math.tan(parseFloat(theta.toMathString())), 2));
         const b = new substractNode_1.SubstractNode(A.y, new multiplyNode_1.MultiplyNode(m, A.x));
         return new Droite(name, (0, simplify_1.simplifyNode)(m), (0, simplify_1.simplifyNode)(b));
     }
@@ -43,7 +44,7 @@ class Droite {
         return `(${this.name}) : y = ${this.toEquationForm()}`; // (D) : y = ax + b
     }
     toPolynome() {
-        const polynome = new polynomial_1.Polynomial([parseFloat(this.b.toMathString()), parseFloat(this.a.toMathString())], 'x');
+        const polynome = new polynomial_1.Polynomial([(0, mathjs_1.evaluate)(this.b.toMathString()), (0, mathjs_1.evaluate)(this.a.toMathString())], 'x');
         return polynome.toTex();
     }
     getLeadingCoefficient() {

package/lib/math/geometry/point.d.ts

@@ -8,7 +8,11 @@ export declare class Point {
     constructor(name: string, x: Node, y: Node);
     toTex(): string;
     toTexWithCoords(): string;
+    getXnumber(): number;
+    getYnumber(): number;
     midpoint(B: Point, name?: string): Point;
+    distanceTo(B: Point): number;
+    equalTo(B: Point): boolean;
 }
 /**
  * Droite{

package/lib/math/geometry/point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAM7C,8BAAsB,gBAAgB;CAMrC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAM1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAIzB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;CAOtC;AAED;;;;;;;;;;;;GAYG"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAO7C,8BAAsB,gBAAgB;CAMrC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;gBACI,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI;IAM1C,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAIzB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAQrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,OAAO,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;CAG3B;AAED;;;;;;;;;;;;GAYG"}

package/lib/math/geometry/point.js

@@ -5,6 +5,7 @@ const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const simplify_1 = require("../../tree/parsers/simplify");
+const mathjs_1 = require("mathjs");
 class PointConstructor {
 }
 exports.PointConstructor = PointConstructor;
@@ -20,9 +21,23 @@ class Point {
     toTexWithCoords() {
         return `${this.name}\\left(${this.x.toTex()}; ${this.y.toTex()}\\right)`;
     }
+    getXnumber() {
+        return (0, mathjs_1.evaluate)(this.x.toMathString());
+    }
+    getYnumber() {
+        return (0, mathjs_1.evaluate)(this.y.toMathString());
+    }
     midpoint(B, name = 'I') {
         return new Point(name, (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.x, B.x), new numberNode_1.NumberNode(2))), (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new addNode_1.AddNode(this.y, B.y), new numberNode_1.NumberNode(2))));
     }
+    distanceTo(B) {
+        const dx = this.getXnumber() - B.getXnumber();
+        const dy = this.getYnumber() - B.getYnumber();
+        return Math.sqrt(dx ** 2 + dy ** 2);
+    }
+    equalTo(B) {
+        return this.getXnumber() === B.getXnumber() && this.getYnumber() === B.getYnumber();
+    }
 }
 exports.Point = Point;
 /**

package/lib/math/geometry/triangles.d.ts

@@ -0,0 +1,54 @@
+import { Point } from './point';
+import { Node } from '../../tree/nodes/node';
+export declare abstract class TriangleConstructor {
+    static createRandomRightTriangle({ minRapport, maxRapport, names }: {
+        minRapport?: number | undefined;
+        maxRapport?: number | undefined;
+        names?: string[] | undefined;
+    }): Triangle;
+    static createRandomTriangle({ minAngle, maxAngle, names }: {
+        minAngle?: number | undefined;
+        maxAngle?: number | undefined;
+        names?: string[] | undefined;
+    }): Triangle;
+}
+type GenerateCommandsProps = {
+    highlightedAngle?: string;
+    colorHighlightedAngle?: string;
+    highlightedSide?: string;
+    colorHighlightedSide?: string;
+    showLabels?: string[];
+    setCaptions?: string[];
+    showAxes?: boolean;
+    showGrid?: boolean;
+};
+export declare class Triangle {
+    vertexA: Point;
+    vertexB: Point;
+    vertexC: Point;
+    constructor(vertexA: Point, vertexB: Point, vertexC: Point);
+    getSideAnumber(): number;
+    getSideBnumber(): number;
+    getSideCnumber(): number;
+    getTriangleName(): string;
+    getSideAnode(): Node;
+    getSideBnode(): Node;
+    getSideCnode(): Node;
+    getAngleA(): number;
+    getAngleB(): number;
+    getAngleC(): number;
+    getPerimeter(): number;
+    getArea(): number;
+    isRight(): Boolean;
+    isEquilateral(): Boolean;
+    isIsosceles(): Boolean;
+    isScalene(): boolean;
+    getRightAngle(): string;
+    generateCommands({ highlightedAngle: highlightedAngle, colorHighlightedAngle: colorHighlightedAngle, showLabels: showLabels, setCaptions: setCaptions, highlightedSide: highlightedSide, colorHighlightedSide: colorHighlightedSide, showAxes, showGrid, }: GenerateCommandsProps): string[];
+    generateCoords(): number[];
+    getSideAName(): string;
+    getSideBName(): string;
+    getSideCName(): string;
+}
+export {};
+//# sourceMappingURL=triangles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangles.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAO7C,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,yBAAyB,CAAC,EAAE,UAAc,EAAE,UAAc,EAAE,KAAuB,EAAE;;;;KAAA,GAAG,QAAQ;IAkBvG,MAAM,CAAC,oBAAoB,CAAC,EAAE,QAAe,EAAE,QAAc,EAAE,KAAuB,EAAE;;;;KAAA,GAAG,QAAQ;CAmBpG;AAED,KAAK,qBAAqB,GAAG;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,qBAAa,QAAQ;IACnB,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;IACf,OAAO,EAAE,KAAK,CAAC;gBAEH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK;IAM1D,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAOxB,cAAc,IAAI,MAAM;IAIxB,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,IAAI;IASpB,YAAY,IAAI,IAAI;IASpB,YAAY,IAAI,IAAI;IASpB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM;IAOnB,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IAKjB,OAAO,IAAI,OAAO;IAOlB,aAAa,IAAI,OAAO;IAIxB,WAAW,IAAI,OAAO;IAQtB,SAAS,IAAI,OAAO;IAQpB,aAAa,IAAI,MAAM;IAOvB,gBAAgB,CAAC,EACf,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB,EAC5C,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,eAAe,EAChC,oBAAoB,EAAE,oBAAoB,EAC1C,QAAQ,EACR,QAAQ,GACT,EAAE,qBAAqB,GAAG,MAAM,EAAE;IAiDnC,cAAc,IAAI,MAAM,EAAE;IAS1B,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;IAItB,YAAY,IAAI,MAAM;CAGvB"}