math-exercises 3.0.173 → 3.0.174

package/lib/exercises/math/probaStat/trees/treeInAnswer.js

@@ -0,0 +1,107 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getTreeDiagramAnswer = (identifiers) => {
+    return identifiers.answerTree;
+};
+const getInstruction = () => {
+    return `Compléter l'arbre suivant blabla`;
+};
+const getHint = () => {
+    return `indice`;
+};
+const getCorrection = () => {
+    return `correction`;
+};
+const getKeys = () => {
+    return ["A", "B", "C"];
+};
+const isAnswerTreeTableValid = (ans, { answerTreeTable }) => {
+    try {
+        return ans.every((step, i) => step.every((block, j) => block.every((branch, k) => branch.every((value, l) => value === answerTreeTable[i][j][k][l]))));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTreeInAnswerQuestion = () => {
+    // const steps = randint(2, 3);
+    const randomBlock = () => {
+        const branches = randint(2, 4);
+        const isDecimal = coinFlip();
+        const value = () => {
+            return isDecimal
+                ? randfloat(0.1, 1, 2)
+                : RationalConstructor.randomIrreductibleProba().toTree().toTex();
+        };
+        const res = [
+            [`${value()}`, "A"],
+            [`${value()}`, "B"],
+        ];
+        if (branches === 3)
+            res.push([`${value()}`, "C"]);
+        return res;
+    };
+    const firstBlock = randomBlock();
+    const firstBlockLength = firstBlock.length;
+    const tree = [[firstBlock], []];
+    for (let i = 0; i < firstBlockLength; i++) {
+        tree[1].push(randomBlock());
+    }
+    // if (steps === 3) {
+    //   tree.push([]);
+    //   tree[1].forEach((block) => {
+    //     const length = block.length;
+    //     for (let i = 0; i < length; i++) {
+    //       tree[2].push(randomBlock());
+    //     }
+    //   });
+    // }
+    const initTree = structuredClone(tree);
+    const voidifyCell = () => {
+        const x = randint(0, tree.length);
+        const y = randint(0, tree[x].length);
+        const z = randint(0, tree[x][y].length);
+        const w = randint(0, tree[x][y][z].length);
+        initTree[x][y][z][w] = "";
+    };
+    const nbVoid = randint(1, 3);
+    for (let i = 0; i < nbVoid; i++) {
+        voidifyCell();
+    }
+    const identifiers = {
+        initTree,
+        answerTree: tree,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        initTreeTable: identifiers.initTree,
+        answerTreeTable: getTreeDiagramAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const treeInAnswer = {
+    id: "treeInAnswer",
+    label: "Tree in answer",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTreeInAnswerQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "treeDiagram",
+    isAnswerTreeTableValid,
+};

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

@@ -99,7 +99,7 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
 export const geometricFindExplicitFormula = {
     id: "geometricFindExplicitFormula",
     connector: "=",
-    label: "Déterminer la formule générale d'une suite géométrique (premier rang $u_0$)",
+    label: "Déterminer la formule générale d'une suite géométrique à partir de la raison et de $u_0$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormula, nb),
     qcmTimer: 60,

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

@@ -99,7 +99,7 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
 export const geometricFindExplicitFormulaFirstRankOne = {
     id: "geometricFindExplicitFormulaFirstRankOne",
     connector: "=",
-    label: "Déterminer la formule générale d'une suite géométrique (premier rang $u_1$)",
+    label: "Déterminer la formule générale d'une suite géométrique à partir de la raison et de $u_1$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormula, nb),
     qcmTimer: 60,

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     firstValue: number;
     firstRank: number;
 };
-export declare const geometricFindExplicitFormulaFirstTermRandom: Exercise<Identifiers>;
+type Options = {
+    firstTermRankOne: boolean;
+};
+export declare const geometricFindExplicitFormulaFirstTermRandom: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=geometricFindExplicitFormulaFirstTermRandom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgGF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAe3E,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6HF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AASF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAoBR,CAAC"}

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

@@ -1,13 +1,13 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power, PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.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}$.
@@ -16,26 +16,58 @@ Donner l'expression de $u_n$ en fonction de $n$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
-    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), new SubstractNode(new VariableNode("n"), firstRank.toTree())));
-    const answer = "u_n=" + formula.toTex();
+    const formula = multiply(firstValue, power(reason, substract("n", firstRank)));
+    const answer = "u_n=" + formula.simplify().toTex();
     return answer;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        instruction: getInstruction(identifiers),
-        answer: getAnswer(identifiers),
+const getHint = () => {
+    return `La formule générale d'une suite géométrique $u$ de raison $q$ est, pour tous entiers $n$ et $k$ positifs : 
+  
+$$
+u_n = u_k\\times q^{n-k}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, firstValue, reason } = identifiers;
+    const formula = multiply(firstValue, power(reason, substract("n", firstRank)));
+    const formulaSimp = formula.simplify();
+    return `La formule générale d'une suite géométrique $u$ de raison $q$ est, pour tous entiers $n$ et $k$ positifs : 
+  
+$$
+u_n = u_k\\times q^{n-k}
+$$
+
+Ici, on a donc : 
+
+$$
+u_n = ${formula.toTex()}
+$$
+
+${formula.toTex() !== formulaSimp.toTex()
+        ? `On peut simplifier : 
+  
+$$
+u_n = ${formulaSimp.toTex()}
+$$`
+        : ""}`;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
         keys: ["un", "equal", "n"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
-    return question;
 };
-const getGeometricFindExplicitFormulaFirstTermRandom = () => {
-    const firstRank = randint(0, 9);
+const getGeometricFindExplicitFormulaFirstTermRandom = (opts) => {
+    const firstRank = randint(opts?.firstTermRankOne ? 1 : 0, 9);
     const firstValue = randint(1, 10);
     const reason = randint(2, 10);
     const identifiers = { reason, firstValue, firstRank };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getPropositions = (n, { answer, reason, firstValue }) => {
     const propositions = [];
@@ -48,24 +80,34 @@ const getPropositions = (n, { answer, reason, firstValue }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { reason, firstValue, firstRank }) => {
-    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), new SubstractNode(new VariableNode("n"), firstRank.toTree())));
-    const equal = new EqualNode(new VariableNode("u_n"), formula, {
-        allowRawRightChildAsSolution: true,
-    });
-    const texs = equal.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = ans.includes("=")
+        ? parseAlgebraic(ans.split("=")[1])
+        : parseAlgebraic(ans);
+    if (!parsed)
+        return false;
+    return parsed.simplify().toTex() === answer.split("=")[1];
 };
+const options = [
+    {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+    },
+];
 export const geometricFindExplicitFormulaFirstTermRandom = {
     id: "geometricFindExplicitFormulaFirstTermRandom",
     connector: "=",
-    label: "Déterminer la formule générale d'une suite géométrique (premier rang aléatoire)",
+    label: "Déterminer la formule générale d'une suite géométrique à partir de la raison et d'un terme donné",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormulaFirstTermRandom, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindExplicitFormulaFirstTermRandom(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
 };

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

@@ -6,4 +6,5 @@ export * from "./areReelsOnTheSameTrigoCirclePoint.js";
 export * from "./associateReelToTrigoCirclePoint.js";
 export * from "./placeAssociateAngleOnCircle.js";
 export * from "./findAssociateAnglePointOnTrigoCircle.js";
+export * from "./trigoFunctionsFundamentalEquation.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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;AAErD,cAAc,kCAAkC,CAAC;AACjD,cAAc,2CAA2C,CAAC"}
+{"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;AAErD,cAAc,kCAAkC,CAAC;AACjD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,wCAAwC,CAAC"}

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

@@ -7,3 +7,4 @@ export * from "./associateReelToTrigoCirclePoint.js";
 // export * from "./findAngleFromCosAndSin.js";
 export * from "./placeAssociateAngleOnCircle.js";
 export * from "./findAssociateAnglePointOnTrigoCircle.js";
+export * from "./trigoFunctionsFundamentalEquation.js";

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=selectQuadrantOnTrigoCircle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectQuadrantOnTrigoCircle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/selectQuadrantOnTrigoCircle.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,94 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetQuestionFromIdentifiers,
+//   propWhile,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+export {};
+// //angle donné genre Pi/6, donner la couleur
+// //donner couleur pour signe cos et sin
+// //une couleur est donnée, donner signe sin&cos
+// type Identifiers = {
+//   angle?: NodeIdentifiers;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   propWhile(propositions, n, () => {
+//     throw Error("QCM not implemented");
+//   });
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {};
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   return `On considère le cercle trigonométrique ci-dessous.
+//   https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCercle_couleur.jpg`;
+// };
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   try {
+//     throw Error("VEA not implemented");
+//   } catch (err) {
+//     return handleVEAError(err);
+//   }
+// };
+// const getSelectQuadrantOnTrigoCircleQuestion: QuestionGenerator<Identifiers> = (
+//   ops,
+// ) => {
+//   const identifiers: Identifiers = {};
+//   return getQuestionFromIdentifiers(identifiers);
+// };
+// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (
+//   identifiers,
+// ) => {
+//   return {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "tex",
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers),
+//   };
+// };
+// export const selectQuadrantOnTrigoCircle: Exercise<Identifiers> = {
+//   id: "selectQuadrantOnTrigoCircle",
+//   label:
+//     "Donner le quadrant du cercle trigonométrique auquel un angle appartient",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(
+//       () => getSelectQuadrantOnTrigoCircleQuestion(opts),
+//       nb,
+//     ),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswer,
+//   getQuestionFromIdentifiers,
+//   hasHintAndCorrection: true,
+//   answerType: "QCU",
+// };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigoFunctionsFundamentalEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/trigoFunctionsFundamentalEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsNF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAsBnE,CAAC"}

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

@@ -0,0 +1,223 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, opposite(getAnswerNode(identifiers)).toTex());
+    tryToAddWrongProp(propositions, getAnswerNode({
+        isCos: !identifiers.isCos,
+        quadrant: identifiers.quadrant,
+        valueIds: identifiers.valueIds,
+    }).toTex());
+    propWhile(propositions, n, () => {
+        let value = coinFlip()
+            ? randfloat(0.1, 1, 1).toTree()
+            : RationalConstructor.randomIrreductibleProba().toTree();
+        value = coinFlip() ? opposite(value).simplify() : value;
+        tryToAddWrongProp(propositions, getAnswer({
+            isCos: identifiers.isCos,
+            quadrant: identifiers.quadrant,
+            valueIds: value.toIdentifiers(),
+        }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { isCos, valueIds, quadrant } = identifiers;
+    const value = reifyAlgebraic(valueIds);
+    const isPos = value.evaluate() >= 0;
+    const absValue = sqrt(substract(1, square(value))).simplify();
+    if (isCos) {
+        if (isPos) {
+            if (quadrant === 0)
+                return absValue;
+            return opposite(absValue);
+        }
+        else {
+            if (quadrant === 1)
+                return absValue;
+            return opposite(absValue);
+        }
+    }
+    else {
+        if (isPos) {
+            if (quadrant === 0)
+                return absValue;
+            return opposite(absValue);
+        }
+        else {
+            if (quadrant === 3)
+                return absValue;
+            return opposite(absValue);
+        }
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInterval = (identifiers) => {
+    const { quadrant } = identifiers;
+    switch (quadrant) {
+        case 0:
+            return new IntervalNode((0).toTree(), frac(PiNode, 2), ClosureType.FF);
+        case 1:
+            return new IntervalNode(frac(PiNode, 2), PiNode, ClosureType.FF);
+        case 2:
+            return new IntervalNode(opposite(PiNode), opposite(frac(PiNode, 2)), ClosureType.FF);
+        case 3:
+        default:
+            return new IntervalNode(opposite(frac(PiNode, 2)), (0).toTree(), ClosureType.FF);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isCos, valueIds } = identifiers;
+    const value = reifyAlgebraic(valueIds);
+    const interval = getInterval(identifiers);
+    return `On donne :
+  
+$$
+${isCos ? "\\cos" : "\\sin"}(x) = ${value.toTex()}
+$$
+
+avec 
+
+$$
+${interval.toInequality().toTex()}
+$$
+
+Déterminer $${isCos ? "\\sin" : "\\cos"}(x)$.`;
+};
+const getHint = (identifiers) => {
+    const { isCos } = identifiers;
+    const fct = isCos ? "\\sin(x)" : "\\cos(x)";
+    return `Utilise la propriété suivante : pour tout réel $x$, 
+  
+$$
+\\cos(x)^2 + \\sin(x)^2 = 1
+$$
+
+Grâce à cela, tu peux obtenir la valeur de $(${fct})^2$. Cela te donne donc deux valeurs possibles pour $${fct}$.
+
+Pour déterminer laquelle est la bonne, utilise le quart de cercle auquel appartient $x$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { isCos, valueIds, quadrant } = identifiers;
+    const fct = isCos ? "\\sin(x)" : "\\cos(x)";
+    const value = reifyAlgebraic(valueIds);
+    const squared = substract(1, square(value)).simplify();
+    const interval = getInterval(identifiers);
+    const answerNode = getAnswerNode(identifiers);
+    const answerIsPos = answerNode.evaluate() >= 0;
+    const direction = quadrant === 0
+        ? "nord-est"
+        : quadrant === 1
+            ? "nord-ouest"
+            : quadrant === 2
+                ? "sud-ouest"
+                : "sud-est";
+    return `On sait que : 
+  
+$$
+\\cos(x)^2 + \\sin(x)^2 = 1
+$$
+
+On a donc : 
+
+$$
+${fct}^2 = 1 - \\${isCos ? "cos" : "sin"}(x)^2 = ${squared.toTex()}
+$$
+
+On en déduit que $${fct}$ peut valoir $${sqrt(squared)
+        .simplify()
+        .toTex()}$ ou $${opposite(sqrt(squared)).simplify().toTex()}$.
+
+Or, puique $${interval.toInequality().toTex()}$, $${fct}$ est ${answerIsPos ? "positif" : "négatif"} (car on est sur le quart "${direction}" du cercle trigonométrique).
+
+Ainsi :
+
+$$
+${fct}=${answerNode.toTex()}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        const value = getAnswerNode(identifiers).evaluate();
+        return Math.abs(parsed.evaluate() - value) < 0.01;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrigoFunctionsFundamentalEquationQuestion = () => {
+    const isCos = coinFlip();
+    let value = coinFlip()
+        ? randfloat(0.1, 1, 1).toTree()
+        : RationalConstructor.randomIrreductibleProba().toTree();
+    value = coinFlip() ? opposite(value).simplify() : value;
+    const isPos = value.evaluate() >= 0;
+    const quadrant = isCos
+        ? isPos
+            ? random([0, 3])
+            : random([1, 2])
+        : isPos
+            ? random([0, 1])
+            : random([2, 3]);
+    const identifiers = {
+        isCos,
+        valueIds: value.toIdentifiers(),
+        quadrant,
+    };
+    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 trigoFunctionsFundamentalEquation = {
+    id: "trigoFunctionsFundamentalEquation",
+    connector: "=",
+    label: "Connaissant $\\cos(x)$ et le quart de cercle auquel appartient $x$, déterminer $\\sin(x)$.",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigoFunctionsFundamentalEquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1 +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"}
+{"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,CAiBlD,CAAC"}

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

@@ -78,7 +78,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const basicEquationCos = {
     id: "basicEquationCos",
     connector: "\\iff",
-    label: "Résoudre une équation du type $\\cos\\left(x\\right)=k$",
+    label: "Résoudre une équation du type $\\cos\\left(x\\right)=k$ sur l'intervalle $]-\\pi; \\pi]$",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getBasicEquationCosQuestion, nb, 9),
     qcmTimer: 60,
@@ -89,4 +89,5 @@ export const basicEquationCos = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     maxAllowedQuestions: 9,
+    // hasHintAndCorrection: true,
 };