math-exercises 3.0.157 → 3.0.159

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

@@ -0,0 +1,104 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { SinNode } from "../../../../tree/nodes/functions/sinNode.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 !== 90 && degree !== 270) {
+        const answerNode = getAnswerNode({ degree });
+        const newSet = answerNode.solutionsSet.toDeleteRandomElement();
+        tryToAddWrongProp(propositions, new EquationSolutionNode(newSet).toTex());
+    }
+    const mainSinusValues = mainTrigoValues.slice(3, 12);
+    propWhile(propositions, n, () => {
+        const value = random(mainSinusValues);
+        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 === 90 || value.degree === 270)
+        return new EquationSolutionNode(new DiscreteSetNode([value.angle]));
+    const isNegative = value.degree > 270;
+    let ans1;
+    let ans2;
+    if (isNegative) {
+        ans2 = value.angle;
+        const oppositeDegree = 270 - (value.degree - 270);
+        ans1 = mainTrigoValues.find((v) => v.degree === oppositeDegree).angle;
+    }
+    else {
+        ans1 = value.angle;
+        const oppositeDegree = 90 + (90 - value.degree);
+        ans2 = mainTrigoValues.find((v) => v.degree === oppositeDegree).angle;
+    }
+    return new EquationSolutionNode(new DiscreteSetNode([ans1, ans2]));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const sin = mainTrigoValues.find((v) => v.degree === identifiers.degree).sin;
+    return `Résoudre : 
+    
+$$
+${new SinNode("x".toTree()).toTex()}=${sin.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 getBasicEquationSinQuestion = () => {
+    const mainSinusValues = mainTrigoValues.slice(3, 12);
+    const value = random(mainSinusValues);
+    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 basicEquationSin = {
+    id: "basicEquationSin",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $\\sin\\left(x\\right)=k$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBasicEquationSinQuestion, nb, 9),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    maxAllowedQuestions: 9,
+};

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

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

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

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

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

@@ -0,0 +1,83 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { CosNode } from "../../../../tree/nodes/functions/cosNode.js";
+import { SinNode } from "../../../../tree/nodes/functions/sinNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const value = random(mainTrigoValues);
+        tryToAddWrongProp(propositions, new EquationSolutionNode(new DiscreteSetNode([value.angle])).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const value = mainTrigoValues.find((v) => v.degree === identifiers.degree);
+    return new EquationSolutionNode(new DiscreteSetNode([value.angle]));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const value = mainTrigoValues.find((v) => v.degree === identifiers.degree);
+    return `Résoudre : 
+  
+$$
+\\left\\{${alignTex([
+        [`${new CosNode("x".toTree()).toTex()}=${value.cos.toTex()}`],
+        [`${new SinNode("x".toTree()).toTex()}=${value.sin.toTex()}`],
+    ], true)}\\right.
+$$
+
+Donner les solutions dans l'intervalle $\\left]-\\pi,\\pi\\right]$.
+`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = () => {
+    return ["x", "S", "equal", "lbrace", "semicolon", "rbrace", "pi"];
+};
+const isAnswerValid = (ans, { degree }) => {
+    const node = getAnswerNode({ degree });
+    return node.toAllValidTexs().includes(ans);
+};
+const getBasicTrigoSystemEquationQuestion = () => {
+    const value = random(mainTrigoValues);
+    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 basicTrigoSystemEquation = {
+    id: "basicTrigoSystemEquation",
+    connector: "\\iff",
+    label: "Résoudre un système du type $\\left\\{\\begin{matrix}\\cos(x)=a\\\\ \\sin(x)=b\\end{matrix}\\right.$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBasicTrigoSystemEquationQuestion, nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    ggbTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    maxAllowedQuestions: 15,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"equationCosOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationCosOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAkIF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}

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

@@ -0,0 +1,111 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainPositiveTrigovalues, mainTrigoValues, trigoValuesOnZeroTwoPIOF, } from "../../../../math/trigonometry/remarkableValues.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { CosNode } from "../../../../tree/nodes/functions/cosNode.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 { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer, degree, leftBoundPiMultiple }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //distracteur avec une solution manquante
+    if (degree !== 0 && degree !== 180) {
+        const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+        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, leftBoundPiMultiple }));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const coeff = identifiers.leftBoundPiMultiple;
+    /**
+     * Si l'intervalle est centré autour d'un multiple de 2pi (coeff impair) (genre ]3pi, 5pi]) on ajoute (coeff+1)/2 tours
+     * Sinon (coeff pair) (genre ]2pi, 4pipi]) , on chope la value de ]0, 2pi] et on ajoute coeff/2 tours
+     */
+    const turnsToAdd = Math.abs(coeff % 2) === 1 ? (coeff + 1) / 2 : coeff / 2;
+    const cos = mainTrigoValues
+        .find((v) => v.degree === identifiers.degree)
+        .cos.evaluate({});
+    const values = (Math.abs(coeff % 2) === 1 ? mainTrigoValues : trigoValuesOnZeroTwoPIOF).filter((v) => v.cos.evaluate({}) === cos);
+    if (values.length === 1) {
+        const value = values[0];
+        const newValue = new AddNode(value.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+        return new EquationSolutionNode(new DiscreteSetNode([newValue]));
+    }
+    else {
+        const newValues = values.map((v) => {
+            return new AddNode(v.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+        });
+        return new EquationSolutionNode(new DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({}))));
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = ({ degree, leftBoundPiMultiple, }) => {
+    const value = mainPositiveTrigovalues.find((v) => v.degree === degree);
+    const leftBound = new MultiplyNode(leftBoundPiMultiple.toTree(), PiNode).simplify();
+    const rightBound = new MultiplyNode((leftBoundPiMultiple + 2).toTree(), PiNode).simplify();
+    const interval = new IntervalNode(leftBound, rightBound, ClosureType.OF);
+    return `Résoudre sur $${interval.toTex()}$ l'équation : 
+  
+$$
+${new CosNode("x".toTree()).toTex()}=${value.cos.toTex()}
+$$`;
+};
+// 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, leftBoundPiMultiple }) => {
+    const answerNode = getAnswerNode({ degree, leftBoundPiMultiple });
+    return answerNode.toAllValidTexs().includes(ans);
+};
+const getEquationCosOnRandomIntervalQuestion = () => {
+    const value = random(mainPositiveTrigovalues);
+    const degree = value.degree;
+    const leftBoundPiMultiple = randint(-3, 4);
+    const identifiers = { degree, leftBoundPiMultiple };
+    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 equationCosOnRandomInterval = {
+    id: "equationCosOnRandomInterval",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $\\cos\\left(x\\right)=k$ sur un intervalle donné",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getEquationCosOnRandomIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"equationSinOnRandomInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/equationSinOnRandomInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,EAAE,MAAM,CAAC;CAC7B,CAAC;AAiHF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}

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

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { mainPositiveTrigovalues, mainTrigoValues, trigoValuesOnZeroTwoPIOF, } from "../../../../math/trigonometry/remarkableValues.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { SinNode } from "../../../../tree/nodes/functions/sinNode.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 { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        throw Error("QCM not implemented");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const coeff = identifiers.leftBoundPiMultiple;
+    /**
+     * Si l'intervalle est centré autour d'un multiple de 2pi (coeff impair) (genre ]3pi, 5pi]) on ajoute (coeff+1)/2 tours
+     * Sinon (coeff pair) (genre ]2pi, 4pipi]) , on chope la value de ]0, 2pi] et on ajoute coeff/2 tours
+     */
+    const turnsToAdd = Math.abs(coeff % 2) === 1 ? (coeff + 1) / 2 : coeff / 2;
+    const sin = mainTrigoValues
+        .find((v) => v.degree === identifiers.degree)
+        .sin.evaluate({});
+    const values = (Math.abs(coeff % 2) === 1 ? mainTrigoValues : trigoValuesOnZeroTwoPIOF).filter((v) => v.sin.evaluate({}) === sin);
+    if (values.length === 1) {
+        const value = values[0];
+        const newValue = new AddNode(value.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+        return (new EquationSolutionNode(new DiscreteSetNode([newValue])).toTex() +
+            ` turns ${turnsToAdd}, value : ${value.angle.toTex()}`);
+    }
+    else {
+        const newValues = values.map((v) => {
+            return new AddNode(v.angle, new MultiplyNode((turnsToAdd * 2).toTree(), PiNode)).simplify();
+        });
+        return (new EquationSolutionNode(new DiscreteSetNode(newValues.sort((a, b) => a.evaluate({}) - b.evaluate({})))).toTex() +
+            ` turns ${turnsToAdd}, values: ${values.map((v) => v.angle.toTex())}`);
+    }
+};
+const getInstruction = ({ degree, leftBoundPiMultiple, }) => {
+    const value = mainPositiveTrigovalues.find((v) => v.degree === degree);
+    const leftBound = new MultiplyNode(leftBoundPiMultiple.toTree(), PiNode).simplify();
+    const rightBound = new MultiplyNode((leftBoundPiMultiple + 2).toTree(), PiNode).simplify();
+    const interval = new IntervalNode(leftBound, rightBound, ClosureType.OF);
+    return `Résoudre sur $${interval.toTex()}$ l'équation : 
+    
+$$
+${new SinNode("x".toTree()).toTex()}=${value.sin.toTex()}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return "";
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   return "";
+// };
+const getKeys = () => {
+    return ["pi"];
+};
+const isAnswerValid = () => {
+    throw Error("VEA not implemented");
+};
+const getEquationSinOnRandomIntervalQuestion = () => {
+    const value = random(mainPositiveTrigovalues);
+    const degree = value.degree;
+    const leftBoundPiMultiple = randint(-3, 4);
+    const identifiers = { degree, leftBoundPiMultiple };
+    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 equationSinOnRandomInterval = {
+    id: "equationSinOnRandomInterval",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $\\sin\\left(x\\right)=k$ sur un intervalle donné",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getEquationSinOnRandomIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,6 @@
+export * from "./basicEquationCos.js";
+export * from "./basicEquationSin.js";
+export * from "./basicTrigoSystemEquation.js";
+export * from "./equationCosOnRandomInterval.js";
+export * from "./trigoAssociateAngle.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AAEjD,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./basicEquationCos.js";
+export * from "./basicEquationSin.js";
+export * from "./basicTrigoSystemEquation.js";
+export * from "./equationCosOnRandomInterval.js";
+// export * from "./equationSinOnRandomInterval.js";
+export * from "./trigoAssociateAngle.js";

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isCos: boolean;
+    value: number;
+    associateType: number;
+};
+export declare const trigoAssociateAngle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=trigoAssociateAngle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trigoAssociateAngle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/trigoAssociateAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAsIF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

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

@@ -0,0 +1,151 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { mainTrigoValues } from "../../../../math/trigonometry/remarkableValues.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 { substract } from "../../../../tree/nodes/operators/substractNode.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, value }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, value.frenchify());
+    tryToAddWrongProp(propositions, (-value).frenchify());
+    tryToAddWrongProp(propositions, random(mainTrigoValues).cos.toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(-1, 1, 1).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { isCos, value, associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return isCos ? value.frenchify() : (-value).frenchify();
+        case 1:
+            return isCos ? (-value).frenchify() : value.frenchify();
+        case 2:
+        default:
+            return (-value).frenchify();
+    }
+};
+const getAssociateAngle = (identifiers) => {
+    switch (identifiers.associateType) {
+        case 0:
+            return opposite("a");
+        case 1:
+            return substract(PiNode, "a");
+        case 2:
+        default:
+            return add(PiNode, "a");
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isCos, value } = identifiers;
+    const fc = isCos ? cos : sin;
+    return `On considère un nombre réel $a$ tel que : 
+  
+$$
+${fc("a").toTex()} \\approx ${value.frenchify()}
+$$
+
+Donner une valeur approchée de $${fc(getAssociateAngle(identifiers)).toTex()}$.
+`;
+};
+const getHint = (identifiers) => {
+    const { associateType } = identifiers;
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses.`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées.`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { associateType, isCos } = identifiers;
+    const fc = isCos ? cos : sin;
+    const answer = getAnswer(identifiers);
+    const associate = getAssociateAngle(identifiers).toTex();
+    switch (associateType) {
+        case 0:
+            return `Sur le cercle trigonométrique, le point image de $-a$ est le symétrique du point image de $a$ par rapport à l'axe des abscisses. On a donc : 
+      
+$$
+${fc(associate).toTex()} = ${isCos ? "" : "-"}${fc("a").toTex()} \\approx ${answer}
+$$`;
+        case 1:
+            return `Sur le cercle trigonométrique, le point image de $\\pi-a$ est le symétrique du point image de $a$ par rapport à l'axe des ordonnées. On a donc : 
+      
+$$
+${fc(associate).toTex()} = ${isCos ? "-" : ""}${fc("a").toTex()} \\approx ${answer}
+$$`;
+        case 2:
+        default:
+            return `Sur le cercle trigonométrique, le point image de $\\pi+a$ est le symétrique du point image de $a$ par rapport à l'origine du repère. On a donc : 
+      
+$$
+${fc(associate).toTex()} = -${fc("a").toTex()} \\approx ${answer}
+$$`;
+    }
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTrigoAssociateAngleQuestion = () => {
+    const isCos = coinFlip();
+    const associateType = randint(0, 3);
+    const value = randfloat(-1, 1, 1);
+    const identifiers = {
+        associateType,
+        isCos,
+        value,
+    };
+    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 trigoAssociateAngle = {
+    id: "trigoAssociateAngle",
+    connector: "=",
+    label: "Déterminer le cosinus ou le sinus d'un angle associé (opposé, supplémentaire, ou anti-supplémentaire)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrigoAssociateAngleQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1,20 +1,9 @@
-export * from "./mainRemarkableValues.js";
-export * from "./remarkableValues.js";
-export * from "./trigonometry.js";
-export * from "./trigonometryAngleCalcul.js";
-export * from "./trigonometrySideCalcul.js";
-export * from "./associatePoint.js";
+export * from "./circle/index.js";
 export * from "./arcValue.js";
 export * from "./calculateCosSinAndTan.js";
-export * from "./basicEquationCos.js";
-export * from "./basicEquationSin.js";
-export * from "./basicTrigoSystemEquation.js";
-export * from "./mainAngleMeasure.js";
+export * from "./functions/index.js";
 export * from "./degreeToRadians.js";
 export * from "./arcLength.js";
-export * from "./equationCosOnRandomInterval.js";
 export * from "./trigoFundamentalEquation.js";
-export * from "./trigonometrySohcahtoaCalcul.js";
-export * from "./trigonometrySideName.js";
-export * from "./trigonometrySohcahtoaUse.js";
+export * from "./triangle/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kCAAkC,CAAC;AACjD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC"}