math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/sequences/notation/identifySequenceTermInList.js

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, 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 { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, values }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(values).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { askedIndex, values } = identifiers;
+    return values[askedIndex].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { askedIndex, firstRank, values } = identifiers;
+    return `Soit $u$ une suite de premier rang $${firstRank}$ et dont voici les premiers termes, dans l'ordre : 
+  
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+Quel est le terme de rang $${askedIndex + firstRank}$ ?`;
+};
+const getHint = () => {
+    return `Il suffit de compter à partir du premier rang de la suite.`;
+};
+const getCorrection = (identifiers) => {
+    const { askedIndex, firstRank, values } = identifiers;
+    return `Voici la notation pour chacun des termes : 
+
+${values
+        .map((e, i) => `$$
+u_${i + firstRank} = ${e}
+$$`)
+        .join("\n \n")}
+
+Le terme de rang $${askedIndex + firstRank}$ est donc $${values[askedIndex + firstRank]}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIdentifySequenceTermInListQuestion = (opts) => {
+    const firstRank = opts?.firstRank === "$0$"
+        ? 0
+        : opts?.firstRank === "$1$"
+            ? 1
+            : randint(0, 2);
+    const values = randTupleInt(5, { from: -10, to: 10, allDifferent: true });
+    const askedIndex = randint(1, 5);
+    const identifiers = {
+        firstRank,
+        values,
+        askedIndex,
+    };
+    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),
+    };
+};
+const options = [
+    {
+        id: "firstRank",
+        label: "Premier rang",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$0$", "$1$", "Les deux aléatoirement"],
+        defaultValue: "Les deux aléatoirement",
+    },
+];
+export const identifySequenceTermInList = {
+    id: "identifySequenceTermInList",
+    connector: "=",
+    label: "Identifier le terme de rang $k$ dans les premiers termes d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIdentifySequenceTermInListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/sequences/notation/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./identifySequenceTermInList.js";
+export * from "./identifyRankInSequenceTermsList.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/notation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/notation/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,sCAAsC,CAAC"}

package/lib/exercises/math/sequences/notation/index.js

@@ -0,0 +1,2 @@
+export * from "./identifySequenceTermInList.js";
+export * from "./identifyRankInSequenceTermsList.js";

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/spaceGeometry/basis/findSpacePointOnRectangularPrism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findSpacePointOnRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkB3C,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;IAE/C,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqgBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}
+{"version":3,"file":"findSpacePointOnRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkB3C,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;IAE/C,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;IAC9C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAogBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAiBlE,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/findSpacePointOnRectangularPrism.js

@@ -260,7 +260,6 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
-    console.log("answer", answer);
     const propositions = [];
     addValidProp(propositions, answer);
     const { arrPoolSpacePointIds } = identifiers;

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphereLatLonReading.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuFtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CAAC;IAEF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA+KF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}
+{"version":3,"file":"sphereLatLonReading.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuFtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CAAC;IAEF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA6KF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.js

@@ -152,8 +152,6 @@ const getKeys = () => {
     return ["degree", "N", "O", "S", "E"];
 };
 const isAnswerValid = (ans, { answer }) => {
-    console.log("ans", ans);
-    console.log("answer", answer);
     const ansRefined = ans.replace("^{\\circ}", "°");
     return ansRefined === answer;
 };

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,
+};