math-exercises 3.0.157 → 3.0.158

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.js

@@ -10,7 +10,9 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
-    return `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. $\\\\$ Donner l'expression de $u_n$ en fonction de $n$.`;
+    return `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$.
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;

package/lib/exercises/math/sequences/geometric/geometricFindReason.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"geometricFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindReason.js

@@ -1,12 +1,43 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = () => {
+    return `La raison d'une suite géométrique est le nombre par lequel on multiple un terme pour obtenir le suivant.`;
+};
+const getCorrection = (identifiers) => {
+    const { rank1, reason, value1 } = identifiers;
+    const rank2 = rank1 + 1;
+    const value2 = reason * value1;
+    return `Puisque la suite $u$ est géométrique, on sait que : 
+
+$$
+u_{${rank2}} = u_{${rank1}} \\times q
+$$
+
+où $q$ est la raison.
+
+On a donc : 
+
+${alignTex([
+        ["q", "=", `\\frac{u_{${rank2}}}{u_{${rank1}}}`],
+        ["", "=", `\\frac{${value2}}{${value1}}`],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
 const getInstruction = (identifiers) => {
     const { rank1, value1, reason } = identifiers;
     const rank2 = rank1 + 1;
     const value2 = reason * value1;
-    return `$(u_n)$ est une suite géométrique. On sait que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. Quelle est la raison de la suite $(u_n)$ ?`;
+    return `$(u_n)$ est une suite géométrique. 
+  
+On sait que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. 
+  
+Quelle est la raison de la suite $(u_n)$ ?`;
 };
 const getAnswer = (identifiers) => {
     const { reason } = identifiers;
@@ -20,6 +51,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         identifiers,
     };
     return question;
@@ -43,7 +76,12 @@ const getPropositions = (n, { answer, value1, reason }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const geometricFindReason = {
     id: "geometricFindReason",
@@ -57,4 +95,5 @@ export const geometricFindReason = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyGF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.js

@@ -1,11 +1,34 @@
 import { tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    const { firstRank } = identifiers;
+    return `Il suffit de remplacer $n$ par $${firstRank}$ dans la formule de récurrence de la suite $u$.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, firstValue, reason } = identifiers;
+    const askedRank = firstRank + 1;
+    return `On remplace $n$ par $${firstRank}$ dans la formule de récurrence :
+  
+${alignTex([
+        [
+            `u_{${firstRank}+1}`,
+            "=",
+            multiply(reason, `u_{${firstRank}}`).toTex({ forceTimesSign: true }),
+        ],
+        [`u_{${askedRank}}`, "=", multiply(reason, firstValue).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+
+`;
+};
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
     const askedRank = firstRank + 1;
-    return `$(u_n)$ est une suite définie par :
+    return `$(u_n)$ est une suite définie, pour $n\\geq 0$, par :
   
 $$
 u_{n+1} = ${reason}\\times u_n
@@ -30,9 +53,11 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),
         answer: getAnswer(identifiers),
-        keys: ["u", "underscore", "equal"],
+        keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -73,4 +98,5 @@ export const geometricRecurrenceFormulaUsage = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkOF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqPF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/math/sequences/sequenceEvaluation.js

@@ -8,6 +8,23 @@ import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    const { termeAdd, termeMult } = identifiers;
+    const f = new Affine(termeMult, termeAdd, "n").toTree().simplify().toTex();
+    return `Il suffit de remplacer $n$ par $${f}$ dans la formule donnant $u_n$. Puis, simplifie et réduis l'expression obtenue.`;
+};
+const getCorrection = (identifiers) => {
+    const { termeAdd, termeMult, affine } = identifiers;
+    const aff = new Affine(affine[0], affine[1], "n").toTree();
+    const f = new Affine(termeMult, termeAdd, "n").toTree().simplify();
+    return `On remplace $n$ par $${f.toTex()}$ dans la formule donnant $u_n$ : 
+  
+${alignTex([
+        [`u_{${f.toTex()}}`, "=", aff.toDetailedEvaluation({ n: f }).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { termeid, affine, termeAdd, termeMult } = identifiers;
     const aff = new Affine(affine[0], affine[1], "n");
@@ -27,7 +44,7 @@ $$
 u_n = ${aff.toTree().toTex()}
 $$
     
-Exprimer $u_{${terme.toTex()}}$.`;
+Exprimer $u_{${terme.toTex()}}$ en fonction de $n$.`;
 };
 const getAnswer = (identifiers) => {
     const { termeid, affine, termeAdd, termeMult } = identifiers;
@@ -60,6 +77,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["n"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -70,7 +89,7 @@ const getSequenceEvaluationQuestion = () => {
     let termeAdd = 0;
     let termeMult = 1;
     if (termeid === 1) {
-        termeAdd = randint(1, 4);
+        termeAdd = randint(-4, 4, [0]);
     }
     else if (termeid === 2) {
         termeMult = randint(2, 4);
@@ -179,4 +198,5 @@ export const sequenceEvaluation = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+};
+export declare const areReelsOnTheSameTrigoCirclePoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=areReelsOnTheSameTrigoCirclePoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"areReelsOnTheSameTrigoCirclePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAqBnE,CAAC"}

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