math-exercises 3.0.157 → 3.0.159

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"}

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

@@ -0,0 +1,189 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.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 { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getSidePropstWithSideType = (triangle, indexPoint, sideType) => {
+    const indexSideAdjacent = 3 - indexPoint;
+    const indexSideOpposite = indexPoint;
+    const indexSideHypo = 0;
+    const sidePropsDict = {
+        adjacent: {
+            strFrench: "adjacent",
+            name: triangle.sides[indexSideAdjacent].toTex(),
+            indexSide: 3 - indexPoint,
+        },
+        opposé: {
+            strFrench: "opposé",
+            name: triangle.sides[indexSideOpposite].toTex(),
+            indexSide: indexPoint,
+        },
+        hypoténuse: {
+            strFrench: "hypoténuse",
+            name: triangle.sides[indexSideHypo].toTex(),
+            indexSide: 0,
+        },
+    };
+    const sideProps = sidePropsDict[sideType];
+    return sideProps;
+};
+const getInstruction = (identifiers) => {
+    const { indexPoint, sideType, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+
+${(() => {
+        switch (sideType) {
+            case "hypoténuse": {
+                return `Nommer l'${sideType} du triangle.`;
+            }
+            default: {
+                const angleTex = `\\widehat{${triangle.points[indexPoint].name}}`;
+                return `Nommer le côté ${sideType} à l'angle $${angleTex}$.`;
+            }
+        }
+    })()}`;
+};
+const getAnswer = (identifiers) => {
+    const { indexPoint, sideType, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sideProps = getSidePropstWithSideType(triangle, indexPoint, sideType);
+    return sideProps.name;
+};
+const getGGBOptions = (identifiers) => {
+    const { indexPoint, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.highlightAngle(indexPoint, { color: greenDark, showValue: false });
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { indexPoint, sideType, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.highlightAngle(indexPoint, { color: greenDark, showValue: false });
+    ["adjacent", "opposé", "hypoténuse"].forEach((key) => {
+        const sideProps = getSidePropstWithSideType(triangle, indexPoint, key);
+        if (sideType === key) {
+            triangle.highlightSide(sideProps.indexSide, {
+                color: greenDark,
+                caption: sideProps.strFrench,
+                size: "small",
+            });
+        }
+        else {
+            triangle.highlightSide(sideProps.indexSide, {
+                caption: sideProps.strFrench,
+                size: "tiny",
+            });
+        }
+    });
+    const ggb = new GeogebraConstructor({
+        commands: triangle.commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { indexPoint, sideType, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const propositions = [];
+    ["adjacent", "opposé", "hypoténuse"].forEach((key) => {
+        const sideProps = getSidePropstWithSideType(triangle, indexPoint, key);
+        if (sideType === key) {
+            addValidProp(propositions, sideProps.name);
+        }
+        else {
+            tryToAddWrongProp(propositions, sideProps.name);
+        }
+    });
+    return shuffle(propositions);
+};
+const getHint = () => {
+    return `- Le côté opposé à un angle est celui qui est en face de cet angle.
+- L'hypoténuse est le côté opposé à l'angle droit.
+- Le côté adjacent à un angle est le côté qui touche cette angle et qui n'est pas l'hypoténuse.
+
+Si tu pivotes le triangle pour qu'il ait l'angle droit vers le haut, l'hypoténuse se retrouve en dessous ("hypo" veut dire en dessous en grec).`;
+};
+const getCorrection = (identifiers) => {
+    const { indexPoint, sideType, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sideProps = getSidePropstWithSideType(triangle, indexPoint, sideType);
+    if (sideType === "hypoténuse") {
+        return `L'hypoténuse du triangle $${triangle.name}$ est $${sideProps.name}$.`;
+    }
+    else {
+        const angleTex = `\\widehat{${triangle.points[indexPoint].name}}`;
+        return `Le côté ${sideType} à l'angle $${angleTex}$ est $${sideProps.name}$.`;
+    }
+};
+const getTrigonometrySideNameQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const indexPoint = randint(1, 3);
+    const sideType = random(opts.sideTypes);
+    const triangle = RightTriangleConstructor.randomNiceAngles({
+        randomName: true,
+    });
+    const identifiers = {
+        indexPoint,
+        sideType,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+};
+const optsDefault = {
+    sideTypes: ["adjacent", "opposé", "hypoténuse"],
+};
+const options = [
+    {
+        id: "sideTypes",
+        label: "Type de côté",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["adjacent", "opposé", "hypoténuse"],
+        defaultValue: optsDefault.sideTypes,
+    },
+];
+export const trigonometrySideName = {
+    id: "trigonometrySideName",
+    connector: "=",
+    label: "Nommer le côté opposé/adjacent/hypoténuse dans un triangle",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySideNameQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySohcahtoaCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/triangle/trigonometrySohcahtoaCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AA0FnD,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAqQF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAiBF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBtE,CAAC"}