math-exercises 3.0.144 → 3.0.146

package/lib/exercises/math/trigonometry/index.d.ts

@@ -14,4 +14,7 @@ export * from "./degreeToRadians.js";
 export * from "./arcLength.js";
 export * from "./equationCosOnRandomInterval.js";
 export * from "./trigoFundamentalEquation.js";
+export * from "./trigonometrySohcahtoaCalcul.js";
+export * from "./trigonometrySideName.js";
+export * from "./trigonometrySohcahtoaUse.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/trigonometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}

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

@@ -14,3 +14,6 @@ export * from "./degreeToRadians.js";
 export * from "./arcLength.js";
 export * from "./equationCosOnRandomInterval.js";
 export * from "./trigoFundamentalEquation.js";
+export * from "./trigonometrySohcahtoaCalcul.js";
+export * from "./trigonometrySideName.js";
+export * from "./trigonometrySohcahtoaUse.js";

package/lib/exercises/math/trigonometry/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/trigonometrySideName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySideName.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/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/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/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/trigonometrySohcahtoaCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySohcahtoaCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/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"}

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

@@ -0,0 +1,290 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, 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 { round } from "../../../math/utils/round.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { random } from "../../../utils/alea/random.js";
+const getAcceptedInputTypesSentence = (acceptedInputType) => {
+    return `Donner le résultat
+${(() => {
+        switch (acceptedInputType) {
+            case "exact":
+                return "sous forme exacte";
+            default:
+            case "arrondi au centième":
+                return "arrondi au centième";
+        }
+    })()}`;
+};
+const getFormattedNode = (node, acceptedInputType) => {
+    switch (acceptedInputType) {
+        case "exact":
+            return node;
+        default:
+        case "arrondi au centième":
+            return round(node.evaluate(), 2).toTree();
+    }
+};
+const trigoFuncsDict = {
+    sin: {
+        strFrenchThe: "le sinus",
+        funcTex: (content) => `\\sin(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 0];
+                case 2:
+                    return [2, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\sin(\\text{angle}) = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+    },
+    cos: {
+        strFrenchThe: "le cosinus",
+        funcTex: (content) => `\\cos(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [2, 0];
+                case 2:
+                    return [1, 0];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\cos(\\text{angle}) = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+    },
+    tan: {
+        strFrenchThe: "la tangente",
+        funcTex: (content) => `\\tan(${content})`,
+        funcIndexesSegment: (indexPoint) => {
+            switch (indexPoint) {
+                case 1:
+                    return [1, 2];
+                case 2:
+                    return [2, 1];
+                default:
+                    throw new Error("Unsupported indexPoint: " + indexPoint);
+            }
+        },
+        texEqFrac: "\\tan(\\text{angle}) = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    },
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { nameTrigoFunc, indexPoint, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const texAngle = `\\widehat{${triangle.points[indexPoint].toTex()}}`;
+    const trigoFunc = trigoFuncsDict[nameTrigoFunc];
+    return `Le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$ est tel que : 
+  
+${triangle.sides.map((side) => `- $${side.toLengthTex()}\\ \\textrm{cm}$`)
+        .join(`
+  
+`)} 
+    
+Calculer ${trigoFunc.strFrenchThe} de l'angle $${texAngle}$.
+${getAcceptedInputTypesSentence(opts.acceptedInputType)}.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nameTrigoFunc, indexPoint, triangleIdentifiers } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const trigoFunc = trigoFuncsDict[nameTrigoFunc];
+    const indexesSegment = trigoFunc.funcIndexesSegment(indexPoint);
+    const [nodeNum, nodeDen] = indexesSegment.map((i) => triangle.sides[i].getLengthNode());
+    const fractionNode = frac(nodeNum, nodeDen);
+    return fractionNode;
+};
+const getFormattedAnswerNode = (identifiers, opts) => {
+    return getFormattedNode(getAnswerNode(identifiers), opts.acceptedInputType);
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getFormattedAnswerNode(identifiers, opts).toTex();
+};
+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, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { nameTrigoFunc, indexPoint, triangleIdentifiers } = identifiers;
+    //sohcahtoa
+    //
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const trigoFunc = trigoFuncsDict[nameTrigoFunc];
+    const indexesSegment = trigoFunc.funcIndexesSegment(indexPoint);
+    const [segmentNum, segmentDen] = indexesSegment.map((i) => triangle.sides[i]);
+    const [nameNum, nameDen] = [segmentNum, segmentDen].map((segment) => `${segment.pointA.name}${segment.pointB.name}`);
+    const [nodeNum, nodeDen] = [segmentNum, segmentDen].map((segment) => segment.getLengthNode());
+    const fractionNode = frac(nodeNum, nodeDen);
+    const texAngle = `\\widehat{${triangle.points[indexPoint].toTex()}}`;
+    return `Le triangle $${triangle.name}$ est un triangle rectangle.
+On peut donc utiliser la formule qui donne ${trigoFunc.strFrenchThe} d'un des angles non-droits comme un rapport des longueurs de côtés du triangle :
+
+$$
+${trigoFunc.texEqFrac}
+$$
+
+On a donc : 
+
+$$
+${trigoFunc.funcTex(texAngle)} = \\frac{${nameNum}}{${nameDen}}
+$$
+
+$$
+${trigoFunc.funcTex(texAngle)} = ${fractionNode.toTex()}
+$$
+
+${(() => {
+        if (opts.acceptedInputType === "arrondi au centième") {
+            return `Arrondi au centième, cela donne : 
+    
+$$
+${trigoFunc.funcTex(texAngle)} \\approx ${getFormattedAnswerNode(identifiers, opts).toTex()}
+$$
+    
+    `;
+        }
+        else {
+            return ``;
+        }
+    })()}
+
+`;
+};
+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: GetGGBOptions<Identifiers, Options> = (
+//   identifiers,
+// ) => {
+//   const { nameTrigoFunc, indexPoint, triangleIdentifiers } = identifiers;
+//   const triangle =
+//     RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+//   const trigoFunc = trigoFuncsDict[nameTrigoFunc];
+//   const indexesSegment = trigoFunc.funcIndexesSegment(indexPoint);
+//   triangle.highlightAngle(indexPoint, { color: greenDark, showValue: false });
+//   indexesSegment.forEach((i) => {
+//     triangle.highlightSide(i, { color: greenDark });
+//   });
+//   const ggb = new GeogebraConstructor({
+//     commands: triangle.commands,
+//     hideAxes: true,
+//     hideGrid: true,
+//   });
+//   return ggb.getOptions({
+//     coords: triangle.generateCoords(),
+//   });
+// };
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const format = (node) => getFormattedNode(node, opts.acceptedInputType);
+    const { triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const propositions = [];
+    const answerNode = getAnswerNode(identifiers);
+    addValidProp(propositions, format(answerNode).toTex());
+    ["sin", "cos", "tan"].forEach((nameTrigoFunc) => {
+        const trigoFunc = trigoFuncsDict[nameTrigoFunc];
+        [1, 2].forEach((indexPoint) => {
+            const indexesSegment = trigoFunc.funcIndexesSegment(indexPoint);
+            const [nodeNum, nodeDen] = indexesSegment.map((i) => triangle.sides[i].getLengthNode());
+            tryToAddWrongProp(propositions, format(frac(nodeNum, nodeDen)).toTex());
+        });
+    });
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, `${(round(randint(11, 100) / 100, 2) + "").replace(".", ",")}`);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getFormattedAnswerNode(identifiers, opts);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (_) {
+        return false;
+    }
+};
+const getTrigonometrySohcahtoaCalculQuestion = () => {
+    const indexPoint = randint(1, 3);
+    const nameTrigoFunc = random(Object.keys(trigoFuncsDict));
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const identifiers = {
+        indexPoint,
+        nameTrigoFunc,
+        triangleIdentifiers: triangle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        // correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+};
+const optsDefault = {
+    acceptedInputType: "arrondi au centième",
+};
+const options = [
+    {
+        id: "acceptedInputType",
+        label: "Format du résultat",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["exact", "arrondi au centième"],
+        defaultValue: optsDefault.acceptedInputType,
+    },
+];
+export const trigonometrySohcahtoaCalcul = {
+    id: "trigonometrySohcahtoaCalcul",
+    connector: "=",
+    label: "Calculer le cosinus/sinus/tangente d'un angle dans un triangle rectangle",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigonometrySohcahtoaCalculQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/trigonometrySohcahtoaUse.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../math/geometry/triangles/triangle.js";
+type Options = {
+    questionType: "frac" | "func";
+    targetTypes: string[];
+};
+type Identifiers = {
+    questionType: "frac" | "func";
+    targetType: string;
+    indexTarget: number;
+    indexesGivenSegments: number[];
+    indexGivenAngle: number | undefined;
+    triangleIdentifiers: TriangleIdentifiers;
+};
+export declare const trigonometrySohcahtoaUseFrac: Exercise<Identifiers, Options>;
+export declare const trigonometrySohcahtoaUseFunc: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trigonometrySohcahtoaUse.d.ts.map

package/lib/exercises/math/trigonometry/trigonometrySohcahtoaUse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigonometrySohcahtoaUse.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySohcahtoaUse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAiInD,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAiZF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}