math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/trigonometry/triangle/trigonometry.js

@@ -0,0 +1,207 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { LengthNode } from "../../../../tree/nodes/geometry/lengthNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getHint = () => {
+    return `On peut utiliser : 
+  
+$$
+\\text{SOHCAHTOA}
+$$
+
+qui signifie : 
+
+$$
+\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const formules = [
+        "\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+        "\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+        "\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    ];
+    const oppose = triangle.sides[randAngle];
+    const adjacent = triangle.sides[3 - randAngle];
+    const hypo = triangle.sides[0];
+    const angle = triangle.angles[randAngle];
+    const fct = ["\\cos", "\\sin", "\\tan"][randTrigo];
+    const fraction = [
+        [adjacent, hypo],
+        [oppose, hypo],
+        [oppose, adjacent],
+    ][randTrigo];
+    return `On utilise : 
+  
+$$
+${formules[randTrigo]}
+$$
+
+${randTrigo !== 2
+        ? `L'hypoténuse du triangle est le côté $${hypo.toTex()}$.`
+        : ""}
+
+${randTrigo !== 0
+        ? `Le côté opposé à l'angle $${angle.toTex()}$ est le côté $${oppose.toTex()}$.`
+        : ""}
+
+${randTrigo !== 1
+        ? `Le côté adjacent à l'angle $${angle.toTex()}$ est le côté $${adjacent.toTex()}$.`
+        : ""}
+
+Cela donne donc : 
+
+$$
+${fct}\\left(${angle.toTex()}\\right) = \\frac{${fraction[0].toInsideName()}}{${fraction[1].toInsideName()}}
+$$
+`;
+};
+const getInstruction = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const trigo = ["le cosinus", "le sinus", "la tangente"];
+    return `À quel quotient est égal ${trigo[randTrigo]} de l'angle $${triangle.angles[randAngle].toTex()}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    let quotient;
+    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
+    switch (randAngle) {
+        case 1: //angle B
+            quotient = [
+                `\\frac{${sideC}}{${sideA}}`, //cos
+                `\\frac{${sideB}}{${sideA}}`, //sin
+                `\\frac{${sideB}}{${sideC}}`, //tan
+            ];
+            break;
+        case 2: //angle C
+        default:
+            quotient = [
+                `\\frac{${sideB}}{${sideA}}`, //cos
+                `\\frac{${sideC}}{${sideA}}`, //sin
+                `\\frac{${sideC}}{${sideB}}`, //tan
+            ];
+            break;
+    }
+    const answer = quotient[randTrigo];
+    return answer;
+};
+const getKeys = (identifiers) => {
+    const { triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return [...triangle.points.map((p) => p.name), "equal"];
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.highlightAngle(randAngle, { color: "red" });
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometry = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randTrigo = randint(0, 3);
+    const randAngle = random([1, 2]);
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+        randAngle,
+        randTrigo,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const getPropositions = (n, { answer, triangleIdentifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
+    const wrongQuotients = [
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideA}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideC}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideB}}`,
+        `\\frac{${sideA}}{${sideC}}`,
+        `\\frac{${sideB}}{${sideC}}`,
+    ];
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, wrongQuotients[randint(0, 12)]);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { randAngle, randTrigo, triangleIdentifiers }) => {
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const [sideA, sideB, sideC] = triangle.sides.map((s) => s.toInsideName());
+    let quotients = [];
+    if (randAngle === 1)
+        quotients = [
+            [sideC, sideA],
+            [sideB, sideA],
+            [sideB, sideC],
+        ];
+    else
+        quotients = [
+            [sideB, sideA],
+            [sideC, sideA],
+            [sideC, sideB],
+        ];
+    const quotient = quotients[randTrigo];
+    const answer = new FractionNode(new LengthNode(quotient[0]), new LengthNode(quotient[1]));
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const trigonometry = {
+    id: "trigonometry",
+    connector: "=",
+    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getTrigonometry, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/trigonometry/triangle/trigonometryAngleCalcul.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangles/triangle.js";
+type Identifiers = {
+    randAngle: number;
+    hiddenSide: number;
+    triangleIdentifiers: TriangleIdentifiers;
+};
+export declare const trigonometryAngleCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometryAngleCalcul.d.ts.map

package/lib/exercises/math/trigonometry/triangle/trigonometryAngleCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/triangle/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAQhF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAmLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/math/trigonometry/triangle/trigonometryAngleCalcul.js

@@ -0,0 +1,174 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getInstruction = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const givenSides = triangle.sides.filter((_s, i) => i !== hiddenSide);
+    const angle = triangle.angles[randAngle];
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${givenSides[0].toLengthTex()}\\ \\textrm{cm}$ et $${givenSides[1].toLengthTex()}\\ \\textrm{cm}$. 
+    
+Calculer l'angle $${angle.toTex()}$ en arrondissant à $1^\\circ$.`;
+};
+const getAnswer = (identifiers) => {
+    const { randAngle, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = round(triangle.angles[randAngle].evaluate(), 0);
+    return answer + "^{\\circ}";
+};
+const getHint = () => {
+    return `On peut utiliser : 
+  
+$$
+\\text{SOHCAHTOA}
+$$
+
+qui signifie : 
+
+$$
+\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const formules = [
+        "\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+        "\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+        "\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    ];
+    const randTrigo = hiddenSide === 0 ? 2 : hiddenSide === randAngle ? 0 : 1;
+    const oppose = triangle.sides[randAngle];
+    const adjacent = triangle.sides[3 - randAngle];
+    const hypo = triangle.sides[0];
+    const angle = triangle.angles[randAngle];
+    const fct = ["\\cos", "\\sin", "\\tan"][randTrigo];
+    const fraction = [
+        [adjacent, hypo],
+        [oppose, hypo],
+        [oppose, adjacent],
+    ][randTrigo];
+    const fractionEvs = fraction.map((e) => e.getLengthNode());
+    const fractionEv = frac(fractionEvs[0], fractionEvs[1]);
+    const fractionEvApprox = fractionEv.evaluate();
+    return `On utilise la formule : 
+
+$$
+${formules[randTrigo]}
+$$
+
+${randTrigo !== 2
+        ? `L'hypoténuse du triangle est le côté $${hypo.toTex()}$.`
+        : ""}
+
+${randTrigo !== 0
+        ? `Le côté opposé à l'angle $${angle.toTex()}$ est le côté $${oppose.toTex()}$.`
+        : ""}
+
+${randTrigo !== 1
+        ? `Le côté adjacent à l'angle $${angle.toTex()}$ est le côté $${adjacent.toTex()}$.`
+        : ""}
+
+Cela donne donc : 
+
+${alignTex([
+        [
+            `${fct}\\left(${angle.toTex()}\\right)`,
+            "=",
+            `\\frac{${fraction[0].toInsideName()}}{${fraction[1].toInsideName()}}`,
+        ],
+        ["", "=", fractionEv.toTex()],
+        ["", ...approxOrEqual(fractionEvApprox, 2)],
+    ])}
+
+On utilise alors la fonction $${fct}^{-1}$ avec la calculatrice : 
+
+$$
+${fct}^{-1}\\left(${round(fractionEvApprox, 2).frenchify()}\\right) \\approx ${getAnswer(identifiers)}
+$$
+
+On en déduit que $${angle.toTex()} \\approx ${getAnswer(identifiers)}$.
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.showSidesLength([hiddenSide]);
+    triangle.highlightAngle(randAngle, { color: "red" });
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometryAngleCalcul = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const randAngle = randint(1, 3);
+    const hiddenSide = randint(0, 3);
+    const identifiers = {
+        randAngle,
+        hiddenSide,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    const question = getQuestionFromIdentifiers(identifiers);
+    return question;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["degree"],
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(20, 80) + "^{\\circ}");
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return [answer, answer.split("^")[0]].includes(ans);
+};
+export const trigonometryAngleCalcul = {
+    id: "trigonometryAngleCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un angle",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

package/lib/exercises/math/trigonometry/triangle/trigonometrySideCalcul.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangles/triangle.js";
+type Identifiers = {
+    sideAsked: number;
+    givenSide: number;
+    givenAngle: number;
+    triangleIdentifiers: TriangleIdentifiers;
+};
+export declare const trigonometrySideCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigonometrySideCalcul.d.ts.map

package/lib/exercises/math/trigonometry/triangle/trigonometrySideCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/triangle/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAInD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAmPF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/trigonometry/triangle/trigonometrySideCalcul.js

@@ -0,0 +1,224 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { greenDark } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
+import { TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { givenAngle, givenSide, sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const angleValue = triangle.angles[givenAngle].evaluate().frenchify();
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que $${triangle.sides[givenSide].toLengthTex()}\\ \\textrm{cm}$ et $${triangle.angles[givenAngle].toTex()} = ${angleValue}^\\circ$. 
+    
+Calculer $${triangle.sides[sideAsked].toInsideName()}$ à $0,1 \\ \\textrm{cm}$ près.`;
+};
+const getAnswer = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = round(triangle.sides[sideAsked].getLength(), 1).frenchify();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { givenAngle, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    // triangle.showSidesLength([0, 1, 2].filter((i) => i !== givenSide));
+    triangle.highlightAngle(givenAngle, { color: greenDark, showValue: false });
+    // triangle.highlightSide(sideAsked, { color: "red", caption: "?" });
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getTrigonometrySideCalcul = () => {
+    const givenAngle = randint(1, 3);
+    const givenSide = randint(0, 3);
+    const sideAsked = randint(0, 3, [givenSide]);
+    const triangle = RightTriangleConstructor.randomNiceAngles({
+        randomName: true,
+        niceSideIndex: givenSide,
+    });
+    const identifiers = {
+        givenAngle,
+        givenSide,
+        sideAsked,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, `${(round(randint(11, 100) / 10, 1) + "").replace(".", ",")}`);
+    });
+    return shuffle(propositions);
+};
+const getHint = () => {
+    return `Identifie le côté opposé, le côté adjacent et l'hypoténuse du triangle. Puis utilise la bonne formule de trigonométrie, en te rappelant de : 
+  
+$$
+\\text{SOHCAHTOA}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { givenAngle, givenSide, sideAsked, triangleIdentifiers } = identifiers;
+    //sohcahtoa
+    //
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const angle = triangle.angles[givenAngle];
+    const hypoSegment = triangle.sides[0];
+    const adjacentSegment = triangle.sides[3 - givenAngle];
+    const oppositeSegment = triangle.sides[givenAngle];
+    const angleValue = angle.evaluate().frenchify();
+    const sideAskedType = sideAsked === 0
+        ? "hypoténuse"
+        : sideAsked === givenAngle
+            ? "opposé"
+            : "adjacent";
+    const sideGivenType = givenSide === 0
+        ? "hypoténuse"
+        : givenSide === givenAngle
+            ? "opposé"
+            : "adjacent";
+    const fcts = [
+        {
+            id: "cos",
+            name: "le cosinus",
+            frac: "\\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+        },
+        {
+            id: "sin",
+            name: "le sinus",
+            frac: "\\frac{\\text{opposé}}{\\text{hypoténuse}}",
+        },
+        {
+            id: "tan",
+            name: "la tangente",
+            frac: "\\frac{\\text{opposé}}{\\text{adjacent}}",
+        },
+    ];
+    const sidesProps = [
+        {
+            id: "adjacent",
+            name: "le côté adjacent",
+            tex: adjacentSegment.toTex(),
+            insideTex: adjacentSegment.toInsideName(),
+            value: sideGivenType === "adjacent"
+                ? adjacentSegment.getLength().frenchify()
+                : adjacentSegment.toInsideName(),
+        },
+        {
+            id: "opposé",
+            name: "le côté opposé",
+            tex: oppositeSegment.toTex(),
+            insideTex: oppositeSegment.toInsideName(),
+            value: sideGivenType === "opposé"
+                ? oppositeSegment.getLength().frenchify()
+                : oppositeSegment.toInsideName(),
+        },
+        {
+            id: "hypoténuse",
+            name: "l'hypoténuse",
+            tex: hypoSegment.toTex(),
+            insideTex: hypoSegment.toInsideName(),
+            value: sideGivenType === "hypoténuse"
+                ? hypoSegment.getLength().frenchify()
+                : hypoSegment.toInsideName(),
+        },
+    ];
+    let fct;
+    let sides;
+    switch (sideAskedType) {
+        case "hypoténuse":
+            if (sideGivenType === "adjacent") {
+                fct = fcts[0];
+                sides = [sidesProps[2], sidesProps[0]];
+            }
+            else {
+                fct = fcts[1];
+                sides = [sidesProps[2], sidesProps[1]];
+            }
+            break;
+        case "adjacent":
+            if (sideGivenType === "opposé") {
+                fct = fcts[2];
+                sides = [sidesProps[0], sidesProps[1]];
+            }
+            else {
+                fct = fcts[0];
+                sides = [sidesProps[0], sidesProps[2]];
+            }
+            break;
+        case "opposé":
+            if (sideGivenType === "adjacent") {
+                fct = fcts[2];
+                sides = [sidesProps[1], sidesProps[0]];
+            }
+            else {
+                fct = fcts[1];
+                sides = [sidesProps[1], sidesProps[2]];
+            }
+            break;
+    }
+    const isDenumeratorAsked = sideAskedType === "hypoténuse" ||
+        (sideAskedType === "adjacent" && sideGivenType === "opposé");
+    return `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, par rapport à l'angle $${angle.toTex()}$, $${sides[0].tex}$ est ${sides[0].name} et $${sides[1].tex}$ est ${sides[1].name}.
+        
+Pour trouver $${sides[0].insideTex}$, on peut donc utiliser ${fct.name} de l'angle $${angle.toTex()}$. En effet, on a : 
+
+$$
+\\${fct.id}(${angle.toTex()}) = ${fct.frac}
+$$
+
+donc
+
+$$
+\\${fct.id}(${angleValue}) = \\frac{${sides[isDenumeratorAsked ? 1 : 0].insideTex}}{${sides[isDenumeratorAsked ? 0 : 1].insideTex}} = \\frac{${sides[isDenumeratorAsked ? 1 : 0].value}}{${sides[isDenumeratorAsked ? 0 : 1].value}}
+$$
+
+Ainsi
+
+$$
+${isDenumeratorAsked
+        ? `${sides[0].insideTex} = \\frac{${sides[1].value}}{\\${fct.id}(${angleValue})}`
+        : `${sides[0].insideTex} = \\${fct.id}(${angleValue}) \\times ${sides[1].value}`} \\approx ${getAnswer(identifiers)}\\ \\textrm{cm}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer, 1);
+};
+export const trigonometrySideCalcul = {
+    id: "trigonometrySideCalcul",
+    connector: "=",
+    label: "Utiliser la trigonométrie pour calculer un côté",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/triangle/trigonometrySideName.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangles/triangle.js";
+type Identifiers = {
+    sideType: string;
+    indexPoint: number;
+    triangleIdentifiers: TriangleIdentifiers;
+};
+type Options = {
+    sideTypes: string[];
+};
+export declare const trigonometrySideName: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trigonometrySideName.d.ts.map

package/lib/exercises/math/trigonometry/triangle/trigonometrySideName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideName.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/triangle/trigonometrySideName.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAsCnD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAmKF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAeF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}