math-exercises 1.3.32 → 1.3.34

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

@@ -1,104 +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;
+"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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const trigonometry: Exercise;
-export declare function getTrigonometry(): Question;
+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.js

@@ -1,55 +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;
+"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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const trigonometryAngleCalcul: Exercise;
-export declare function getTrigonometryAngleCalcul(): Question;
+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.js

@@ -1,42 +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;
+"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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const trigonometrySideCalcul: Exercise;
-export declare function getTrigonometrySideCalcul(): Question;
+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.js

@@ -1,52 +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;
+"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/geometry/vectors/scalarProductViaCoords.d.ts

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

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

@@ -1,30 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScalarProductViaCoordsQuestion = exports.scalarProductViaCoords = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const vector_1 = require("../../../math/geometry/vector");
-const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-exports.scalarProductViaCoords = {
-    id: 'scalarProductViaCoords',
-    connector: '=',
-    instruction: '',
-    isSingleStep: false,
-    label: "Calculer un produit scalaire à l'aide des coordonnées",
-    levels: ['1, 0'],
-    section: 'Vecteurs',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getScalarProductViaCoordsQuestion, nb),
-    keys: [],
-};
-function getScalarProductViaCoordsQuestion() {
-    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
-    const u = new vector_1.Vector('u', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
-    const v = new vector_1.Vector('v', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
-    return {
-        instruction: `Soit $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. Calculer $${u.toTex()}\\cdot ${v.toTex()}$.`,
-        startStatement: `${u.toTex()}\\cdot ${v.toTex()}`,
-        answer: u.scalarProduct(v).toTex(),
-        keys: [],
-    };
-}
-exports.getScalarProductViaCoordsQuestion = getScalarProductViaCoordsQuestion;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScalarProductViaCoordsQuestion = exports.scalarProductViaCoords = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const vector_1 = require("../../../math/geometry/vector");
+const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+exports.scalarProductViaCoords = {
+    id: 'scalarProductViaCoords',
+    connector: '=',
+    instruction: '',
+    isSingleStep: false,
+    label: "Calculer un produit scalaire à l'aide des coordonnées",
+    levels: ['1, 0'],
+    section: 'Vecteurs',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getScalarProductViaCoordsQuestion, nb),
+    keys: [],
+};
+function getScalarProductViaCoordsQuestion() {
+    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
+    const u = new vector_1.Vector('u', new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+    const v = new vector_1.Vector('v', new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+    return {
+        instruction: `Soit $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. Calculer $${u.toTex()}\\cdot ${v.toTex()}$.`,
+        startStatement: `${u.toTex()}\\cdot ${v.toTex()}`,
+        answer: u.scalarProduct(v).toTex(),
+        keys: [],
+    };
+}
+exports.getScalarProductViaCoordsQuestion = getScalarProductViaCoordsQuestion;