math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.js

@@ -0,0 +1,107 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const diff = frac(substract(a, b), PiNode).simplify();
+    return Math.abs(diff.evaluate()) % 2 === 0 ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    return `Les nombres $${a.toTex()}$ et $${b.toTex()}$ ont-ils  le même point-image sur le cercle trigonométrique ?`;
+};
+const getHint = () => {
+    return `Deux nombres réels ont le même point-image sur le cercle trigonométrique si et seulement si leur différence est un multiple de $2\\pi$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const sub = substract(a, b);
+    const subSimp = sub.simplify();
+    const k = frac(sub, multiply(2, PiNode)).simplify();
+    const isSamePoint = getAnswer(identifiers) === "Oui";
+    return `On calcule la différence de $${a.toTex()}$ et $${b.toTex()}$ :
+  
+$$
+${substract(a, b).toTex()} = ${subSimp.toTex()}
+$$
+
+${isSamePoint
+        ? k.evaluate() === 1
+            ? `Puisqu'on obtient $2\\pi$, les nombres ont bien le même point-image sur le cercle trigonométrique.`
+            : `On obtient bien un multiple de $2\\pi$, car 
+  
+$$
+${subSimp.toTex()} = ${k.toTex()}\\times (2\\pi)
+$$
+
+Les nombres ont donc bien le même point-image sur le cercle trigonométrique.`
+        : `On n'obtient pas un multiple de $2\\pi$ : les nombres n'ont donc pas le même point-image sur le cercle trigonométrique.`}
+`;
+};
+const getAreReelsOnTheSameTrigoCirclePointQuestion = () => {
+    const isSamePoint = coinFlip();
+    const value = random(mainTrigoValues);
+    const a = value.angle;
+    const b = isSamePoint
+        ? add(a, multiply(2 * randint(-4, 4, [0]), PiNode)).simplify()
+        : random([
+            add(a, multiply(2 * randint(-4, 4, [0]) + 1, PiNode)).simplify(),
+            random(mainTrigoValues.filter((m) => m.point !== value.point)).angle,
+        ]);
+    const identifiers = {
+        aIds: a.toIdentifiers(),
+        bIds: b.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const areReelsOnTheSameTrigoCirclePoint = {
+    id: "areReelsOnTheSameTrigoCirclePoint",
+    label: "Déterminer si deux réels ont le même point image sur le cercle trigonométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreReelsOnTheSameTrigoCirclePointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/trigonometry/circle/associatePoint.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    angleValue: number;
+    angleIdentifiers: NodeIdentifiers;
+    point: string;
+};
+export declare const associatePoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=associatePoint.d.ts.map

package/lib/exercises/math/trigonometry/circle/associatePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;IAClC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/trigonometry/circle/associatePoint.js

@@ -0,0 +1,86 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RemarkableValueConstructor } from "../../../../math/trigonometry/remarkableValue.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const points = [
+    "I",
+    "A",
+    "B",
+    "C",
+    "J",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+];
+const getInstruction = (identifiers) => {
+    const { angleIdentifiers } = identifiers;
+    return `À quel point du cercle trigonométrique ci-dessous le réel $${reifyAlgebraic(angleIdentifiers).toTex()}$ est-il associé ?
+  ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCircle.png)
+  `;
+};
+const getAnswer = (identifiers) => {
+    const { point } = identifiers;
+    return point;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: points,
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getAssociatePointQuestion = () => {
+    const remarkableValue = coinFlip()
+        ? RemarkableValueConstructor.simplifiable()
+        : RemarkableValueConstructor.mainInterval();
+    const identifiers = {
+        angleValue: remarkableValue.angle.evaluate({}),
+        point: remarkableValue.point,
+        angleIdentifiers: remarkableValue.angle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const rand = random(points);
+        tryToAddWrongProp(propositions, rand);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return answer === ans;
+};
+export const associatePoint = {
+    id: "associatePoint",
+    connector: "=",
+    label: "Associer un point du cercle trigonométrique à un réel",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAssociatePointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/circle/associateReelToTrigoCirclePoint.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    pointIndex: number;
+};
+type Options = {
+    solutionInterval: string;
+};
+export declare const associateReelToTrigoCirclePoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=associateReelToTrigoCirclePoint.d.ts.map

package/lib/exercises/math/trigonometry/circle/associateReelToTrigoCirclePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"associateReelToTrigoCirclePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/associateReelToTrigoCirclePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA+NF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAWF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA0B1E,CAAC"}

package/lib/exercises/math/trigonometry/circle/associateReelToTrigoCirclePoint.js

@@ -0,0 +1,205 @@
+import { addValidProp, shuffleProps, propWhile, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
+const getPropositions = (n, { answer }, opts) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        if (opts?.solutionInterval === "$[0; 2\\pi[$") {
+            tryToAddWrongProp(propositions, multiply(randint(0, 24), frac(PiNode, 12)).simplify().toTex());
+        }
+        else {
+            tryToAddWrongProp(propositions, add(opposite(PiNode), multiply(randint(0, 24), frac(PiNode, 12)))
+                .simplify()
+                .toTex());
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers, opts) => {
+    const { pointIndex } = identifiers;
+    if (opts?.solutionInterval === "$[0; 2\\pi[$") {
+        return multiply(pointIndex, frac(PiNode, 12)).simplify();
+    }
+    else {
+        //]-pi; pi]
+        if (pointIndex === 12)
+            return PiNode;
+        if (pointIndex > 12) {
+            return add(opposite(PiNode), multiply(pointIndex - 12, frac(PiNode, 12))).simplify();
+        }
+        return multiply(pointIndex, frac(PiNode, 12)).simplify();
+    }
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (_identifiers, opts) => {
+    const int = opts?.solutionInterval === "$]-\\pi; \\pi]$"
+        ? "$]-\\pi; \\pi]$"
+        : opts?.solutionInterval === "$[0; 2\\pi[$"
+            ? "$[0; 2\\pi[$"
+            : undefined;
+    return `Le cercle trigonométrique ci-dessous est divisé en $24$ parts égales.
+    
+Donner un nombre réel associé au point $A$.
+
+${int ? `Le nombre donné doit se trouver dans l'intervalle ${int}.` : ""}`;
+};
+const getHint = () => {
+    return `Puisque le cercle est divisé en $24$ parts égales, chaque secteur représente un angle de $\\frac{2\\pi}{24} = \\frac{\\pi}{12}$ radians.`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { pointIndex } = identifiers;
+    if (pointIndex === 0)
+        return `Le point de coordonnées $(1;0)$ est associé au nombre $0$.`;
+    const corr = `Puisque le cercle est divisé en $24$ parts égales, chaque secteur représente un angle de $\\frac{2\\pi}{24} = \\frac{\\pi}{12}$ radians.
+
+`;
+    if (opts?.solutionInterval === "$[0; 2\\pi[$")
+        return (corr +
+            `
+À partir du point de coordonnées $(1;0)$, qui est associé au nombre $0$, on compte $${pointIndex}$ ${pluralize("part", pointIndex)} pour arriver jusqu'au point $A$, dans le sens trigonométrique (sens inverse des aiguilles d'une montre). 
+
+Un nombre réel de l'intervalle $[0; 2\\pi[$ associé au point $A$ est donc : 
+
+$$
+${multiply(pointIndex, frac(PiNode, 12)).toSimplificationTex()}
+$$
+`);
+    else {
+        if (pointIndex > 12)
+            return (corr +
+                `
+À partir du point de coordonnées $(1;0)$, qui est associé au nombre $0$, on compte $${24 - pointIndex}$ ${pluralize("part", 24 - pointIndex)} pour arriver jusqu'au point $A$, et ce dans le sens anti-trigonométrique (sens des aiguilles d'une montre). 
+
+Un nombre réel de l'intervalle $]-\\pi; \\pi[$ associé au point $A$ est donc :
+
+$$
+${multiply(opposite(24 - pointIndex), frac(PiNode, 12)).toSimplificationTex()}
+$$
+`);
+        return (corr +
+            `
+À partir du point de coordonnées $(1;0)$, qui est associé au nombre $0$, on compte $${pointIndex}$ ${pluralize("part", pointIndex)} pour arriver jusqu'au point $A$, et ce dans le sens trigonométrique (sens inverse des aiguilles d'une montre). 
+
+Un nombre réel de l'intervalle $]-\\pi; \\pi[$ associé au point $A$ est donc :
+
+$$
+${multiply(pointIndex, frac(PiNode, 12)).toSimplificationTex()}
+$$`);
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { pointIndex } = identifiers;
+    const A = new Point("A", cos(multiply(pointIndex, frac(PiNode, 12))), sin(multiply(pointIndex, frac(PiNode, 12))));
+    const commands = [
+        ...A.toGGBCommand({
+            showLabel: true,
+        }),
+        `C = Circle((0,0), 1)`,
+        `SetFixed(C, true, false)`,
+    ];
+    for (let i = 0; i < 24; i++) {
+        commands.push(`S_{${i}} = Segment( (0,0), (cos(${i}*pi/12), sin(${i}*pi/12)))`);
+        commands.push(`SetFilling(S_{${i}}, 0)`);
+        commands.push(`SetFixed(S_{${i}}, true, false)`);
+        commands.push(`SetLineStyle(S_{${i}}, 3)`);
+    }
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        xAxis: {
+            hideNumbers: true,
+        },
+        yAxis: {
+            hideNumbers: true,
+        },
+    });
+    return ggb.getOptions({ coords: [-1.1, 1.1, -1.1, 1.1] });
+};
+const getKeys = () => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { answer: _answer, pointIndex }, opts) => {
+    const parsed = parseAlgebraic(ans);
+    const ansNode = getAnswerNode({ pointIndex }, opts);
+    if (opts?.solutionInterval === "$[0; 2\\pi[$") {
+        const parsedEv = parsed.evaluate();
+        return (parsedEv >= 0 &&
+            parsedEv < 2 * Math.PI &&
+            Math.abs(parsed.evaluate() - ansNode.evaluate()) < 0.001);
+    }
+    else if (opts?.solutionInterval === "$]-\\pi; \\pi]$") {
+        const parsedEv = parsed.evaluate();
+        return (parsedEv > -Math.PI - 0.005 &&
+            parsedEv <= Math.PI + 0.005 &&
+            Math.abs(parsed.evaluate() - ansNode.evaluate()) < 0.001);
+    }
+    else {
+        const diff = frac(substract(ansNode, parsed), PiNode).simplify();
+        return Math.abs(diff.evaluate()) % 2 === 0;
+    }
+};
+const getAssociateReelToTrigoCirclePointQuestion = (opts) => {
+    const identifiers = {
+        pointIndex: randint(0, 24),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "solutionInterval",
+        label: "Intervalle pour la réponse",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        defaultValue: "Peu importe",
+        values: ["Peu importe", "$]-\\pi; \\pi]$", "$[0; 2\\pi[$"],
+    },
+];
+export const associateReelToTrigoCirclePoint = {
+    id: "associateReelToTrigoCirclePoint",
+    connector: "=",
+    label: "Donner un réel correspondant à un point du cercle trigonométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAssociateReelToTrigoCirclePointQuestion(opts), nb, 20),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    options,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    maxAllowedQuestions: 20,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/trigonometry/circle/findAngleFromCosAndSin.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    point: string;
+};
+export declare const findAngleFromCosAndSin: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findAngleFromCosAndSin.d.ts.map

package/lib/exercises/math/trigonometry/circle/findAngleFromCosAndSin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findAngleFromCosAndSin.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/findAngleFromCosAndSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}

package/lib/exercises/math/trigonometry/circle/findAngleFromCosAndSin.js

@@ -0,0 +1,121 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(mainTrigoValues).angle.toTex());
+    });
+    throw Error("correction not over");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const value = mainTrigoValues.find((e) => e.point === identifiers.point);
+    return value.angle.toTex();
+};
+const getInstruction = (identifiers) => {
+    const value = mainTrigoValues.find((e) => e.point === identifiers.point);
+    return `On considère un nombre $a$ dans l'intervalle $]-\\pi; \\pi]$, tel que $\\cos(a) = ${value.cos.toTex()} $ et $\\sin(a) = ${value.sin.toTex()}$. 
+  
+Quelle est la valeur de $a$ ?`;
+};
+const getHint = (identifiers) => {
+    const { point } = identifiers;
+    const value = mainTrigoValues.find((e) => e.point === point);
+    const isCosPos = value.cos.evaluate() > 0;
+    const isSinPos = value.sin.evaluate() > 0;
+    return `Puisque $\\cos(a)$ est ${isCosPos ? "positif" : "négatif"}, le point image de $a$ sur le cercle trigonométrique se trouve ${isCosPos ? "à droite" : "à gauche"} de l'axe des ordonnées.
+  
+De plus, puisque $\\sin(a)$ est ${isSinPos ? "positif" : "négatif"}, le point image de $a$ sur le cercle trigonométrique se trouve ${isSinPos ? "au-dessus" : "en-dessous"} de l'axe des abscisses.`;
+};
+const getCorrection = (identifiers) => {
+    const { point } = identifiers;
+    const value = mainTrigoValues.find((e) => e.point === point);
+    const isCosPos = value.cos.evaluate() > 0;
+    const isSinPos = value.sin.evaluate() > 0;
+    const answer = getAnswer(identifiers);
+    return `On rappelle les valeurs remarquables des fonctions cosinus et sinus : 
+  
+${mdTable([
+        [
+            "Angle",
+            "$0$",
+            "$\\frac{\\pi}{6}$",
+            "$\\frac{\\pi}{4}$",
+            "$\\frac{\\pi}{3}$",
+            "$\\frac{\\pi}{2}$",
+        ],
+        [
+            "Cosinus",
+            "$1$",
+            "$\\frac{\\sqrt{3}}{2}$",
+            "$\\frac{\\sqrt{2}}{2}$",
+            "$\\frac{1}{2}$",
+            "$0$",
+        ],
+        [
+            "Sinus",
+            "$0$",
+            "$\\frac{1}{2}$",
+            "$\\frac{\\sqrt{2}}{2}$",
+            "$\\frac{\\sqrt{3}}{2}$",
+            "$1$",
+        ],
+    ])}
+
+${isCosPos && isSinPos ? `L'angle recherché est donc $${answer}$.` : ``}`;
+};
+const getKeys = () => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { answer: _answer, point }) => {
+    try {
+        const value = mainTrigoValues.find((e) => e.point === point);
+        const ansNode = parseAlgebraic(ans);
+        return Math.abs(ansNode.evaluate() - value.angle.evaluate()) < 0.01;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindAngleFromCosAndSinQuestion = () => {
+    const point = random(mainTrigoValues).point;
+    const identifiers = {
+        point,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findAngleFromCosAndSin = {
+    id: "findAngleFromCosAndSin",
+    connector: "=",
+    label: "Déterminer $a$ en connaissant $\\cos(a)$ et $\\sin(a)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindAngleFromCosAndSinQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,7 @@
+export * from "./associatePoint.js";
+export * from "./mainAngleMeasure.js";
+export * from "./mainRemarkableValues.js";
+export * from "./remarkableValues.js";
+export * from "./areReelsOnTheSameTrigoCirclePoint.js";
+export * from "./associateReelToTrigoCirclePoint.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC"}

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

@@ -0,0 +1,7 @@
+export * from "./associatePoint.js";
+export * from "./mainAngleMeasure.js";
+export * from "./mainRemarkableValues.js";
+export * from "./remarkableValues.js";
+export * from "./areReelsOnTheSameTrigoCirclePoint.js";
+export * from "./associateReelToTrigoCirclePoint.js";
+// export * from "./findAngleFromCosAndSin.js";

package/lib/exercises/math/trigonometry/circle/mainAngleMeasure.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    degree: number;
+    multipleOf2PiToAdd: number;
+    nodeIds: NodeIdentifiers;
+};
+export declare const mainAngleMeasure: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=mainAngleMeasure.d.ts.map

package/lib/exercises/math/trigonometry/circle/mainAngleMeasure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mainAngleMeasure.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/mainAngleMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAgGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}