math-exercises 3.0.157 → 3.0.158

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"}

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

@@ -0,0 +1,100 @@
+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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, degree }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    let fakeValues;
+    if (degree % 90 === 0) {
+        fakeValues = mainTrigoValues.filter((e) => [0, 90, 180, 270].includes(e.degree));
+    }
+    else if (degree % 60 === 0) {
+        fakeValues = mainTrigoValues.filter((e) => [60, 120, 240, 300].includes(e.degree));
+    }
+    else if (degree % 45 === 0) {
+        fakeValues = mainTrigoValues.filter((e) => [45, 135, 225, 315].includes(e.degree));
+    }
+    else {
+        fakeValues = mainTrigoValues.filter((e) => [30, 150, 210, 330].includes(e.degree));
+    }
+    fakeValues.forEach((v) => tryToAddWrongProp(propositions, v.angle.toTex()));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const value = mainTrigoValues.find((e) => e.degree === identifiers.degree);
+    return value.angle.toTex();
+};
+const getInstruction = (identifiers) => {
+    const angle = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
+    return `Déterminer la mesure principale de l'angle : 
+  
+$$
+${angle.toTex()}
+$$
+  `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   const angle = NodeConstructor.fromIdentifiers(identifiers.nodeIds);
+//   return `La mesure principale d'un angle en radian est sa valeur appartenant à l'intervalle $]-\\pi; \\pi]$. Il faut donc ajouter (ou retirer) $2\\pi$ à $${angle.toTex()}$ jusqu'à ce que le résultat soit dans cet intervalle.`;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return `a`;
+// };
+const getKeys = () => {
+    return ["pi"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const simplified = parsed.simplify().toTex();
+        return simplified === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMainAngleMeasureQuestion = () => {
+    const value = random(mainTrigoValues);
+    const multipleOf2PiToAdd = randint(-100, 100, [0]);
+    const node = new AddNode(value.angle, new MultiplyNode((2 * multipleOf2PiToAdd).toTree(), PiNode)).simplify();
+    const identifiers = {
+        degree: value.degree,
+        multipleOf2PiToAdd,
+        nodeIds: node.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const mainAngleMeasure = {
+    id: "mainAngleMeasure",
+    connector: "=",
+    label: "Déterminer la mesure principale d'un angle",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMainAngleMeasureQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercise.js";
+type Identifiers = {
+    valueIndex: number;
+    isCos: boolean;
+};
+export declare const mainRemarkableValuesExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=mainRemarkableValues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mainRemarkableValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/mainRemarkableValues.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAuFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

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

@@ -0,0 +1,97 @@
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+const getStatementNode = (identifiers) => {
+    const { isCos, valueIndex } = identifiers;
+    const remarkableValue = mainTrigoValues[valueIndex];
+    const statement = isCos
+        ? cos(remarkableValue.angle)
+        : sin(remarkableValue.angle);
+    return statement;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Donner la valeur exacte de : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { isCos, valueIndex } = identifiers;
+    const remarkableValue = mainTrigoValues[valueIndex];
+    return isCos ? remarkableValue.cos.toTex() : remarkableValue.sin.toTex();
+};
+const getMainRemarkableValues = () => {
+    const isCos = coinFlip();
+    const valueIndex = randint(0, mainTrigoValues.length);
+    const identifiers = { valueIndex, isCos };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["pi", "cos", "sin"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const values = [
+        "-1",
+        "-\\frac{\\sqrt{3}}{2}",
+        "-\\frac{\\sqrt{2}}{2}",
+        "-\\frac{1}{2}",
+        "0",
+        "\\frac{\\sqrt{3}}{2}",
+        "\\frac{\\sqrt{2}}{2}",
+        "\\frac{1}{2}",
+        "1",
+    ];
+    shuffle(values);
+    values.forEach((value) => {
+        tryToAddWrongProp(propositions, value);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ forbidTrigo: true, decimalToFractions: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const mainRemarkableValuesExercise = {
+    id: "mainRemarkableValues",
+    connector: "=",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$ sur $]-\\pi; \\pi]$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMainRemarkableValues, nb, 18),
+    qcmTimer: 60,
+    freeTimer: 60,
+    maxAllowedQuestions: 18,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,10 @@
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { Exercise } from "../../../exercise.js";
+type Identifiers = {
+    mainValue: number;
+    isCos: boolean;
+    angleIdentifiers: NodeIdentifiers;
+};
+export declare const remarkableValuesExercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=remarkableValues.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/remarkableValues.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAmD9B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IAEf,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

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

@@ -0,0 +1,112 @@
+import { RemarkableValueConstructor } from "../../../../math/trigonometry/remarkableValue.js";
+import { cos, CosNode } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin, SinNode } from "../../../../tree/nodes/functions/sinNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+const values = [
+    "-1",
+    "-\\frac{\\sqrt{3}}{2}",
+    "-\\frac{\\sqrt{2}}{2}",
+    "-\\frac{1}{2}",
+    "0",
+    "\\frac{\\sqrt{3}}{2}",
+    "\\frac{\\sqrt{2}}{2}",
+    "\\frac{1}{2}",
+    "1",
+];
+// const rebuildIdentifiers: RebuildIdentifiers<Identifiers> = (oldIds)=>{
+//   if(oldIds.angleIdentifiers) return oldIds
+//   return {
+//     angleIdentifiers: ,
+//     isCos: oldIds.isCos,
+//     mainValue: oldIds.mainValue
+//   }
+// }
+const getStatementNode = (identifiers) => {
+    const { isCos, angleIdentifiers } = identifiers;
+    const angle = reifyAlgebraic(angleIdentifiers);
+    const statement = isCos ? new CosNode(angle) : new SinNode(angle);
+    return statement;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Donner la valeur exacte de : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { isCos, angleIdentifiers } = identifiers;
+    const angle = reifyAlgebraic(angleIdentifiers);
+    return (isCos ? cos : sin)(angle).simplify().toTex();
+    // remarkableValue.cos.toTex() : remarkableValue.sin.toTex();
+};
+const getRemarkableValues = () => {
+    const isCos = coinFlip();
+    const remarkableValue = RemarkableValueConstructor.simplifiable();
+    const mainValue = remarkableValue.angle.evaluate({});
+    // const valueIndex = remarkableValue.index;
+    const identifiers = {
+        isCos,
+        mainValue,
+        angleIdentifiers: remarkableValue.angle.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["pi", "cos", "sin"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const statement = random(values);
+        tryToAddWrongProp(propositions, statement);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ forbidTrigo: true, decimalToFractions: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const remarkableValuesExercise = {
+    id: "remarkableValues",
+    connector: "=",
+    label: "Valeurs remarquables de $\\cos$ et $\\sin$ (hors de $]-\\pi; \\pi]$)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRemarkableValues, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/functions/basicEquationCos.d.ts

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

package/lib/exercises/math/trigonometry/functions/basicEquationCos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicEquationCos.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/basicEquationCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/trigonometry/functions/basicEquationCos.js

@@ -0,0 +1,92 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainPositiveTrigovalues, mainTrigoValues, } from "../../../../math/trigonometry/remarkableValues.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { CosNode } from "../../../../tree/nodes/functions/cosNode.js";
+import { OppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer, degree }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //distracteur avec une solution manquante
+    if (degree !== 0 && degree !== 180) {
+        const answerNode = getAnswerNode({ degree });
+        const newSet = answerNode.solutionsSet.toDeleteRandomElement();
+        tryToAddWrongProp(propositions, new EquationSolutionNode(newSet).toTex());
+    }
+    propWhile(propositions, n, () => {
+        const value = random(mainPositiveTrigovalues);
+        const randDegree = value.degree;
+        tryToAddWrongProp(propositions, getAnswer({ degree: randDegree }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const value = mainTrigoValues.find((v) => v.degree === identifiers.degree);
+    if (value.degree === 0 || value.degree === 180)
+        return new EquationSolutionNode(new DiscreteSetNode([value.angle]));
+    const ans2 = value.angle;
+    const ans1 = new OppositeNode(value.angle);
+    return new EquationSolutionNode(new DiscreteSetNode([ans1, ans2]));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const cos = mainTrigoValues.find((v) => v.degree === identifiers.degree).cos;
+    return `Résoudre : 
+  
+$$
+${new CosNode("x".toTree()).toTex()}=${cos.toTex()}
+$$
+
+Donner les solutions dans l'intervalle $\\left]-\\pi,\\pi\\right]$.
+`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
+const getKeys = () => {
+    return ["x", "S", "equal", "lbrace", "semicolon", "rbrace", "pi"];
+};
+const isAnswerValid = (ans, { degree }) => {
+    const answerNode = getAnswerNode({ degree });
+    return answerNode.toAllValidTexs().includes(ans);
+};
+const getBasicEquationCosQuestion = () => {
+    const value = random(mainPositiveTrigovalues);
+    const degree = value.degree;
+    const identifiers = { degree };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const basicEquationCos = {
+    id: "basicEquationCos",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $\\cos\\left(x\\right)=k$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBasicEquationCosQuestion, nb, 9),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    maxAllowedQuestions: 9,
+};

package/lib/exercises/math/trigonometry/functions/basicEquationSin.d.ts

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

package/lib/exercises/math/trigonometry/functions/basicEquationSin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicEquationSin.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/basicEquationSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+FF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}