math-exercises 3.0.157 → 3.0.158

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

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