math-exercises 2.0.7 → 2.0.9

package/lib/exercises/complex/argumentFromAlgebraicComplex.d.ts

@@ -1 +1,7 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    arg: number;
+};
+export declare const argumentFromAlgebraicComplex: MathExercise<Identifiers>;
+export {};
 //# sourceMappingURL=argumentFromAlgebraicComplex.d.ts.map

package/lib/exercises/complex/argumentFromAlgebraicComplex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"argumentFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../src/exercises/complex/argumentFromAlgebraicComplex.ts"],"names":[],"mappings":""}
+{"version":3,"file":"argumentFromAlgebraicComplex.d.ts","sourceRoot":"","sources":["../../../src/exercises/complex/argumentFromAlgebraicComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA4CF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/complex/argumentFromAlgebraicComplex.js

@@ -1,52 +1,63 @@
 "use strict";
-// import {
-//   MathExercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   addValidProp,
-//   shuffleProps,
-//   tryToAddWrongProp,
-// } from "../../exercises/exercise";
-// import { getDistinctQuestions } from "../../exercises/utils/getDistinctQuestions";
-// import { ComplexConstructor } from "../../math/complex/complex";
-// type Identifiers = {
-//   re: number;
-//   im: number;
-// };
-// const getArgumentFromAlgebraicComplexQuestion: QuestionGenerator<
-//   Identifiers
-// > = () => {
-//   const z = ComplexConstructor.random();
-//   const zTex = z.toTree().toTex();
-//   const answer = z.toModuleTree().toTex();
-//   const question: Question<Identifiers> = {
-//     answer: answer,
-//     instruction: `Soit $z=${zTex}$. Déterminer le module $|z|$ de $z$.`,
-//     keys: [],
-//     answerFormat: "tex",
-//     identifiers: {  re: z.re, im: z.im },
-//   };
-//   return question;
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   while (propositions.length < n) {}
-//   return shuffleProps(propositions, n);
-// };
-// export const argumentFromAlgebraicComplex: MathExercise<Identifiers> = {
-//   id: "argumentFromAlgebraicComplex",
-//   connector: "=",
-//   label: "Déterminer l'argument d'un nombre complexe via sa forme algébrique",
-//   levels: ["MathExp"],
-//   isSingleStep: true,
-//   sections: ["Nombres complexes"],
-//   generator: (nb: number) =>
-//     getDistinctQuestions(getArgumentFromAlgebraicComplexQuestion, nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-// };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argumentFromAlgebraicComplex = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const integer_1 = require("../../math/numbers/integer/integer");
+const rational_1 = require("../../math/numbers/rationals/rational");
+const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
+const remarkableValues_1 = require("../../math/trigonometry/remarkableValues");
+const randint_1 = require("../../math/utils/random/randint");
+const complexNode_1 = require("../../tree/nodes/complex/complexNode");
+const sqrtNode_1 = require("../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const random_1 = require("../../utils/random");
+const getArgumentFromAlgebraicComplexQuestion = () => {
+    const arg = remarkableValue_1.RemarkableValueConstructor.mainInterval();
+    const factor = (0, random_1.random)([
+        new integer_1.Integer((0, randint_1.randint)(-5, 6, [0, 1])).toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+        (0, random_1.random)([new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(2)), new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(3))]),
+    ]);
+    const re = new multiplyNode_1.MultiplyNode(factor, arg.cos).simplify();
+    const im = new multiplyNode_1.MultiplyNode(factor, arg.sin).simplify();
+    const z = new complexNode_1.ComplexNode(re, im);
+    const zTex = z.toTex();
+    const answer = arg.angle.toTex();
+    const question = {
+        answer: answer,
+        instruction: `Soit $z=${zTex}$. Déterminer l'argument principal de $z$.`,
+        keys: ["pi"],
+        answerFormat: "tex",
+        identifiers: { arg: arg.angle.evaluate({}) },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const randomPoint = remarkableValue_1.RemarkableValueConstructor.mainInterval();
+        (0, exercise_1.tryToAddWrongProp)(propositions, randomPoint.angle.toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { arg }) => {
+    const point = remarkableValues_1.remarkableTrigoValues.find((point) => point.angle.evaluate({}) === arg);
+    const texs = point.angle.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.argumentFromAlgebraicComplex = {
+    id: "argumentFromAlgebraicComplex",
+    connector: "=",
+    label: "Déterminer l'argument d'un nombre complexe via sa forme algébrique",
+    levels: ["MathExp"],
+    isSingleStep: true,
+    sections: ["Nombres complexes"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArgumentFromAlgebraicComplexQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/complex/index.d.ts

@@ -8,4 +8,5 @@ export * from "./linearCombinaisonComplex";
 export * from "./moduloFromAlgebraicComplex";
 export * from "./mutiplyComplex";
 export * from "./reAndIm";
+export * from "./argumentFromAlgebraicComplex";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/complex/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/complex/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAE7B,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,gCAAgC,CAAC"}

package/lib/exercises/complex/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./linearCombinaisonComplex"), exports);
 __exportStar(require("./moduloFromAlgebraicComplex"), exports);
 __exportStar(require("./mutiplyComplex"), exports);
 __exportStar(require("./reAndIm"), exports);
+__exportStar(require("./argumentFromAlgebraicComplex"), exports);

package/lib/exercises/functions/exponential/expEquation.d.ts

@@ -1,4 +1,5 @@
 import { MathExercise } from "../../../exercises/exercise";
+/**ae^x = k */
 type Identifiers = {
     a: number;
     k: number;

package/lib/exercises/functions/exponential/expEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/exponential/expEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"expEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/exponential/expEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAelC,cAAc;AACd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwEF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/functions/logarithm/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./logEquation";
 export * from "./logSimplifiying";
 export * from "./log10PowerSimplifying";
+export * from "./logPowerEquation";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/functions/logarithm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC"}

package/lib/exercises/functions/logarithm/index.js

@@ -17,4 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./logEquation"), exports);
 __exportStar(require("./logSimplifiying"), exports);
 __exportStar(require("./log10PowerSimplifying"), exports);
-// export * from "./logPowerEquation";
+__exportStar(require("./logPowerEquation"), exports);

package/lib/exercises/functions/logarithm/log10PowerSimplifying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqCF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqCF,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/functions/logarithm/log10PowerSimplifying.js

@@ -10,7 +10,7 @@ const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
 const probaFlip_1 = require("../../../utils/probaFlip");
 const getLog10PowerSimplifyingQuestion = () => {
-    const tenthPower = (0, randint_1.randint)(-5, 6, [0]);
+    const tenthPower = (0, randint_1.randint)(-5, 6, [0, 1]);
     const shouldEvaluate = (0, probaFlip_1.probaFlip)(0.7);
     const nb = shouldEvaluate
         ? new decimal_1.Decimal(1).multiplyByPowerOfTen(tenthPower).toTree()
@@ -45,9 +45,10 @@ exports.log10PowerSimplifying = {
     levels: ["TermTech", "MathComp"],
     isSingleStep: true,
     sections: ["Logarithme décimal", "Puissances"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb),
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb, 15),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    maxAllowedQuestions: 15,
 };

package/lib/exercises/functions/logarithm/logPowerEquation.d.ts

@@ -1,5 +1,11 @@
 import { MathExercise } from "../../../exercises/exercise";
-type Identifiers = {};
+type Identifiers = {
+    a: number;
+    powered: number;
+    c: number;
+    k: number;
+    isLog10: boolean;
+};
 export declare const logPowerEquation: MathExercise<Identifiers>;
 export declare const log10PowerEquation: MathExercise<Identifiers>;
 export {};

package/lib/exercises/functions/logarithm/logPowerEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkDtB,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC;AACF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAgBxD,CAAC"}
+{"version":3,"file":"logPowerEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/logarithm/logPowerEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAwGF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC;AACF,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/functions/logarithm/logPowerEquation.js

@@ -7,6 +7,7 @@ const randint_1 = require("../../../math/utils/random/randint");
 const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
 const equationSolutionNode_1 = require("../../../tree/nodes/equations/equationSolutionNode");
 const log10Node_1 = require("../../../tree/nodes/functions/log10Node");
+const logNode_1 = require("../../../tree/nodes/functions/logNode");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
@@ -17,41 +18,70 @@ const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 /**a*b^x+c=d */
 const getLogPowerEquationQuestion = (opts) => {
     const powered = (0, randint_1.randint)(2, 8);
-    const a = (0, randint_1.randint)(1, 10);
-    const c = (0, randint_1.randint)(-5, 5);
-    const k = (0, randint_1.randint)(5, 15, [powered, 10]);
+    const a = (0, randint_1.randint)(1, 10, [powered]);
+    const c = (0, randint_1.randint)(-5, 5, [a]);
+    const k = (0, randint_1.randint)(5, 15, [powered]);
     const d = k * a + c;
     const xNode = new variableNode_1.VariableNode("x");
     const poweredNode = new numberNode_1.NumberNode(powered);
+    const LNode = opts?.isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
     const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
-        new fractionNode_1.FractionNode(new log10Node_1.Log10Node(new numberNode_1.NumberNode(k)), new log10Node_1.Log10Node(poweredNode)),
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)).simplify(),
     ])).toTex();
-    const equation = new equalNode_1.EqualNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new powerNode_1.PowerNode(poweredNode, xNode)), new numberNode_1.NumberNode(c)), new numberNode_1.NumberNode(d));
+    const equation = new equalNode_1.EqualNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new powerNode_1.PowerNode(poweredNode, xNode)), new numberNode_1.NumberNode(c)).simplify(), new numberNode_1.NumberNode(d));
+    const keys = [
+        "log",
+        "x",
+        "equal",
+        "S",
+        "lbrace",
+        "semicolon",
+        "rbrace",
+    ];
+    keys.push(opts?.isLog10 ? "log" : "ln");
     const question = {
         answer,
         instruction: `Résoudre : $${equation.toTex()}$`,
-        keys: ["log", "x", "equal", "lbrace", "semicolon", "rbrace"],
+        keys,
         answerFormat: "tex",
-        identifiers: {},
+        identifiers: { a, c, k, powered, isLog10: opts?.isLog10 ?? false },
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, isLog10, a, c, k, powered }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    while (propositions.length < n) { }
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const withoutLogs = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new numberNode_1.NumberNode(k), new numberNode_1.NumberNode(powered)).simplify(),
+    ]));
+    (0, exercise_1.tryToAddWrongProp)(propositions, withoutLogs.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+            new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode((0, randint_1.randint)(2, 10))), new LNode(new numberNode_1.NumberNode((0, randint_1.randint)(2, 10)))).simplify(),
+        ])).toTex());
+    }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return true;
+const isAnswerValid = (ans, { a, c, k, powered, isLog10 }) => {
+    const LNode = isLog10 ? log10Node_1.Log10Node : logNode_1.LogNode;
+    const poweredNode = new numberNode_1.NumberNode(powered);
+    const answerSimp = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)).simplify(),
+    ]));
+    const answer = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([
+        new fractionNode_1.FractionNode(new LNode(new numberNode_1.NumberNode(k)), new LNode(poweredNode)),
+    ]));
+    const texs = [...answerSimp.toAllValidTexs(), ...answer.toAllValidTexs()];
+    return texs.includes(ans);
 };
 exports.logPowerEquation = {
     id: "logPowerEquation",
     connector: "\\iff",
-    label: "",
-    levels: [],
+    label: "Résoudre une équation du type $a\\times b^x + c = d$",
+    levels: ["TermSpé", "MathComp"],
     isSingleStep: true,
-    sections: [],
+    sections: ["Logarithme népérien", "Puissances"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLogPowerEquationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -61,10 +91,10 @@ exports.logPowerEquation = {
 exports.log10PowerEquation = {
     id: "log10PowerEquation",
     connector: "\\iff",
-    label: "",
-    levels: [],
+    label: "Résoudre une équation du type $a\\times b^x + c = d$",
+    levels: ["TermSpé", "MathComp"],
     isSingleStep: true,
-    sections: [],
+    sections: ["Logarithme décimal", "Puissances"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getLogPowerEquationQuestion({ isLog10: true }), nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/trigonometry/associatePoint.d.ts

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

package/lib/exercises/trigonometry/associatePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"associatePoint.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/associatePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqDF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/trigonometry/associatePoint.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.associatePoint = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
+const random_1 = require("../../utils/random");
+const points = [
+    "I",
+    "A",
+    "B",
+    "C",
+    "J",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+];
+const getAssociatePointQuestion = () => {
+    const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
+    const answer = remarkableValue.point;
+    const question = {
+        answer,
+        instruction: `À quel point du cercle trigonométrique ci-dessous le réel $${remarkableValue.angle.toTex()}$ est-il associé ?
+    ![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/piCircle.png)
+    `,
+        keys: points,
+        answerFormat: "tex",
+        identifiers: { angleValue: remarkableValue.mainAngle.evaluate({}) },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, angleValue }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const rand = (0, random_1.random)(points);
+        (0, exercise_1.tryToAddWrongProp)(propositions, rand);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return answer === ans;
+};
+exports.associatePoint = {
+    id: "associatePoint",
+    connector: "=",
+    label: "Associer un réel à un point du cercle trigonométrique",
+    levels: ["1reSpé", "TermSpé"],
+    isSingleStep: true,
+    sections: ["Trigonométrie"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAssociatePointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -3,4 +3,5 @@ export * from "./remarkableValues";
 export * from "./trigonometry";
 export * from "./trigonometryAngleCalcul";
 export * from "./trigonometrySideCalcul";
+export * from "./associatePoint";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC"}

package/lib/exercises/trigonometry/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./remarkableValues"), exports);
 __exportStar(require("./trigonometry"), exports);
 __exportStar(require("./trigonometryAngleCalcul"), exports);
 __exportStar(require("./trigonometrySideCalcul"), exports);
+__exportStar(require("./associatePoint"), exports);

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

@@ -1,6 +1,6 @@
 import { MathExercise } from "../exercise";
 type Identifiers = {
-    valueIndex: number;
+    mainValue: number;
     isCos: boolean;
 };
 export declare const remarkableValuesExercise: MathExercise<Identifiers>;

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

@@ -1 +1 @@
-{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAerB,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwCF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../src/exercises/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,YAAY,EAQb,MAAM,aAAa,CAAC;AAerB,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAyCF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/trigonometry/remarkableValues.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.remarkableValuesExercise = void 0;
 const remarkableValue_1 = require("../../math/trigonometry/remarkableValue");
 const remarkableValues_1 = require("../../math/trigonometry/remarkableValues");
+const cosNode_1 = require("../../tree/nodes/functions/cosNode");
+const sinNode_1 = require("../../tree/nodes/functions/sinNode");
 const coinFlip_1 = require("../../utils/coinFlip");
 const random_1 = require("../../utils/random");
 const shuffle_1 = require("../../utils/shuffle");
@@ -22,21 +24,21 @@ const values = [
 const getRemarkableValues = () => {
     const isCos = (0, coinFlip_1.coinFlip)();
     const remarkableValue = remarkableValue_1.RemarkableValueConstructor.simplifiable();
-    const valueIndex = remarkableValue.index;
+    const mainValue = remarkableValue.mainAngle.evaluate({});
+    // const valueIndex = remarkableValue.index;
     const answer = isCos
         ? remarkableValue.cos.toTex()
         : remarkableValue.sin.toTex();
-    (0, shuffle_1.shuffle)(values);
     const statement = isCos
-        ? `\\cos\\left(${remarkableValue.angle.toTex()}\\right)`
-        : `\\sin\\left(${remarkableValue.angle.toTex()}\\right)`;
+        ? new cosNode_1.CosNode(remarkableValue.angle).toTex()
+        : new sinNode_1.SinNode(remarkableValue.angle).toTex();
     const question = {
         instruction: `Donner la valeur exacte de : $${statement}$`,
         startStatement: statement,
         answer: answer,
         keys: ["pi", "cos", "sin"],
         answerFormat: "tex",
-        identifiers: { isCos, valueIndex },
+        identifiers: { isCos, mainValue },
     };
     return question;
 };
@@ -49,8 +51,8 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { valueIndex, isCos }) => {
-    const remarkableValue = remarkableValues_1.remarkableTrigoValues[valueIndex];
+const isAnswerValid = (ans, { mainValue, isCos }) => {
+    const remarkableValue = remarkableValues_1.remarkableTrigoValues.find((point) => point.angle.evaluate({}) === mainValue);
     const answer = isCos ? remarkableValue.cos : remarkableValue.sin;
     const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
     return texs.includes(ans);

package/lib/index.d.ts

@@ -1,9 +1,9 @@
 declare const mathExercises: (import("./exercises/exercise").MathExercise<{
-    numbers: number[];
+    chosenNumbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
-    chosenNumbers: number[];
+    numbers: number[];
 }> | import("./exercises/exercise").MathExercise<{
     dividend: number;
     divisor: number;
@@ -208,6 +208,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     re: number;
     im: number;
     isRe: boolean;
+}> | import("./exercises/exercise").MathExercise<{
+    arg: number;
 }> | import("./exercises/exercise").MathExercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
@@ -417,6 +419,12 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
 }> | import("./exercises/exercise").MathExercise<{
     tenthPower: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    powered: number;
+    c: number;
+    k: number;
+    isLog10: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     coin: boolean;
     radius: number;
@@ -691,7 +699,7 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     valueIndex: number;
     isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
-    valueIndex: number;
+    mainValue: number;
     isCos: boolean;
 }> | import("./exercises/exercise").MathExercise<{
     sideA: string;
@@ -708,6 +716,8 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     randAngle: number;
     randSide: number;
     randSideQuestion: number;
+}> | import("./exercises/exercise").MathExercise<{
+    angleValue: number;
 }>)[];
 export { mathExercises };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqCA,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA2B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/lib/math/numbers/nombre.js

@@ -17,7 +17,7 @@ var NumberType;
 class NombreConstructor {
     static random() {
         const type = (0, random_1.random)([
-            NumberType.Decimal,
+            NumberType.Integer,
             NumberType.Decimal,
             NumberType.Rational,
             NumberType.Real,

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -1,4 +1,5 @@
 import { NumberNode } from '../../../tree/nodes/numbers/numberNode';
+import { MultiplyNode } from '../../../tree/nodes/operators/multiplyNode';
 import { SubstractNode } from '../../../tree/nodes/operators/substractNode';
 import { Nombre } from '../nombre';
 /**
@@ -10,6 +11,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | MultiplyNode | SubstractNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

package/lib/math/numbers/reals/extendedRingElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}
+{"version":3,"file":"extendedRingElement.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/reals/extendedRingElement.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,qBAAa,mBAAmB;IAM9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,MAAM,CAAC;gBACb,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM;IAM1D,MAAM;CAeP"}

package/lib/math/polynomials/trinom.d.ts

@@ -27,8 +27,8 @@ export declare class Trinom extends Polynomial {
     getAlphaNode(): NumberNode | FractionNode | OppositeNode;
     getBeta(): number;
     getBetaNode(): NumberNode | FractionNode | OppositeNode;
-    getFactorizedForm(): AlgebraicNode;
-    getCanonicalForm(): AddNode | MultiplyNode;
+    getFactorizedForm(): AlgebraicNode | MultiplyNode;
+    getCanonicalForm(): MultiplyNode | AddNode;
     getSommet(): Point;
 }
 //# sourceMappingURL=trinom.d.ts.map

package/lib/math/trigonometry/remarkableValue.d.ts

@@ -1,16 +1,9 @@
-import { Node } from "../../tree/nodes/node";
-import { Integer } from "../numbers/integer/integer";
-import { Rational } from "../numbers/rationals/rational";
-export interface RemarkableValue {
-    angleValue: Integer | Rational;
-    angle: Node;
-    cos: Node;
-    sin: Node;
-}
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { RemarkableValue } from "./remarkableValues";
 export declare abstract class RemarkableValueConstructor {
     static mainInterval: () => RemarkableValue;
     static simplifiable: () => RemarkableValue & {
-        index: number;
+        mainAngle: AlgebraicNode;
     };
 }
 //# sourceMappingURL=remarkableValue.d.ts.map