math-exercises 3.0.55 → 3.0.57

package/lib/exercises/math/powers/powersOfTenToDecimal.js

@@ -32,10 +32,36 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getPowersOfTenToDecimalQuestion = () => {
-    const randPower = randint(-9, 10);
+    const randPower = randint(-6, 7);
     const identifiers = { randPower };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `Si $x$ est un entier positif, alors $10^x$ est le nombre composé d'un $1$ suivi de $x$ zéros. 
+  
+Si $x$ est un entier négatif, alors $10^x$ est le nombre composé d'un $1$ précédé de $x$ zéros.
+
+Enfin, tout nombre élevé à la puissance $0$ est égal à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { randPower } = identifiers;
+    const order = randPower < 0 ? "précédé" : "suivi";
+    let corr = "";
+    if (randPower === 0) {
+        corr = `Tout nombre élevé à la puissance $0$ est égal à $1$ : `;
+    }
+    else if (randPower === 1) {
+        corr = `Un nombre élevé à la puissance $1$ est égal à lui-même :`;
+    }
+    else {
+        corr = `$10^{${randPower}}$ est le nombre composé d'un $1$ ${order} de $${Math.abs(randPower)}$ zéros :`;
+    }
+    const final = `
+$$
+${getStartStatement(identifiers)}=${getAnswer(identifiers)}
+$$`;
+    return corr + final;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -44,6 +70,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -68,10 +96,10 @@ export const powersOfTenToDecimal = {
     connector: "=",
     label: "Écriture décimale d'une puissance de $10$",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getPowersOfTenToDecimalQuestion, nb, 19),
+    generator: (nb) => getDistinctQuestions(getPowersOfTenToDecimalQuestion, nb, 12),
     qcmTimer: 60,
     freeTimer: 60,
-    maxAllowedQuestions: 19,
+    maxAllowedQuestions: 12,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
@@ -79,4 +107,5 @@ export const powersOfTenToDecimal = {
     getAnswer,
     getStartStatement,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/powers/powersProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AA4IF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBxD,CAAC"}
+{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AA6IF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBxD,CAAC"}

package/lib/exercises/math/powers/powersProduct.js

@@ -85,6 +85,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 const getPropositions = (n, { answer, a, b, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, power(a, add(b, c)).simplify().toTex());
     while (propositions.length < n) {
         const wrongExponent = b + c + randint(-11, 11, [0, -b - c]);
         const wrongAnswerTree = new Power(a === 1 || a === -1 ? randint(-3, 4, [-1, 1]) : a, wrongExponent).simplify();

package/lib/exercises/math/powers/scientificToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAYN,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAaN,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/powers/scientificToDecimal.js

@@ -1,6 +1,7 @@
 /**
  * a*10^x vers décimal
  *  */
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
@@ -8,22 +9,59 @@ import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
-const getScientificToDecimalQuestion = () => {
-    const decScientific = DecimalConstructor.randomScientific(randint(1, 4));
-    const tenPower = randint(-5, 6, [0, 1]);
+const getInstruction = (identifiers) => {
+    return `Donner l'écriture décimale du nombre suivant : 
+
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    const decScientific = new Decimal(decimal);
     const answer = decScientific.multiplyByPowerOfTen(tenPower).toTree().toTex();
-    const statement = new MultiplyNode(new NumberNode(decScientific.value), new PowerNode(new NumberNode(10), new NumberNode(tenPower)));
-    const statementTex = statement.toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    return `Si $x$ est un entier négatif, alors multiplier par $10^x$ revient à déplacer la virgule de $x$ rangs vers la gauche. 
+  
+Si $x$ est un entier positif, alors multiplier par $10^x$ revient à déplacer la virgule de $x$ rangs vers la droite.`;
+};
+const getCorrection = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    return `On déplace la virgule de $${Math.abs(tenPower)}$ rangs vers la ${tenPower < 0 ? "gauche" : "droite"} : 
+  
+$$
+${getStartStatement(identifiers)} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
     const question = {
-        instruction: `Donner l'écriture décimale de : $${statementTex}$`,
-        startStatement: statementTex,
-        answer: answer,
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { decimal: decScientific.value, tenPower },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getStartStatement = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    const statement = new MultiplyNode(new NumberNode(decimal), new PowerNode(new NumberNode(10), new NumberNode(tenPower)));
+    const statementTex = statement.toTex();
+    return statementTex;
+};
+const getScientificToDecimalQuestion = () => {
+    const decScientific = DecimalConstructor.randomScientific(randint(1, 4));
+    const tenPower = randint(-5, 6, [0, 1]);
+    const identifiers = { decimal: decScientific.value, tenPower };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, tenPower, decimal }) => {
     const propositions = [];
     const decScientific = new Decimal(decimal);
@@ -39,7 +77,7 @@ const getPropositions = (n, { answer, tenPower, decimal }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
 export const scientificToDecimal = {
     id: "scientificToDecimal",
@@ -52,4 +90,6 @@ export const scientificToDecimal = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAcjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAmB7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAWrD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAGJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAcjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAqB7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAWrD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -53,6 +53,7 @@ export const isPolynomialPrimitiveAnswerValid = (ans, { coeffs, answer }) => {
             towardsDistribute: true,
             forbidFactorize: true,
             forceDistributeFractions: true,
+            decimalToFractions: true,
         })
             .toTex() === answer);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAyDF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}
+{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgHF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAgB/D,CAAC"}

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

@@ -1,10 +1,52 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    return `On utilise la formule : 
+  
+$$
+S = \\text{premier terme} \\times \\frac{1-\\text{raison}^{\\text{nombre de termes}}}{1-\\text{raison}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, firstValue, nbTerms, reason } = identifiers;
+    return `On utilise la formule : 
+  
+$$
+S = \\text{premier terme} \\times \\frac{1-\\text{raison}^{\\text{nombre de termes}}}{1-\\text{raison}}
+$$
+
+Ici, la raison est $${reason}$, le premier terme est $${firstValue}$ et le nombre de termes est $${nbTerms}$.
+
+On a donc : 
+
+${alignTex([
+        [
+            "S",
+            "=",
+            multiply(firstValue, frac(substract(1, power(reason, nbTerms)), substract(1, reason))).toTex(),
+        ],
+        [
+            "",
+            "=",
+            multiply(firstValue, frac(substract(1, power(reason, nbTerms)).simplify({
+                calculatePowers: true,
+            }), substract(1, reason).simplify())).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason, nbTerms } = identifiers;
-    return `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
+    return `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. 
+  
+Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstRank, firstValue, reason, nbTerms } = identifiers;
@@ -22,12 +64,17 @@ const getGeometricFirstTermsGeneralSumQuestion = () => {
         reason,
         nbTerms,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -50,9 +97,7 @@ export const geometricFirstTermsGeneralSum = {
     id: "geometricFirstTermsGeneralSum",
     connector: "=",
     label: "Somme des termes d'une suite géométrique (cas général)",
-    levels: [],
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getGeometricFirstTermsGeneralSumQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -61,4 +106,6 @@ export const geometricFirstTermsGeneralSum = {
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"geometricFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA2FF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -2,6 +2,7 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { raison, final } = identifiers;
     return `Calculer la somme suivante : 
@@ -10,6 +11,31 @@ $$
 1 + ${raison} + ${raison}^2 + \\ldots + ${raison}^{${final}}
 $$`;
 };
+const getHint = (identifiers) => {
+    return `On utilise la formule : 
+  
+$$
+1 + q + q^2 + \\ldots + q^n = \\frac{1-q^{n+1}}{1-q}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { raison, final } = identifiers;
+    return `On utilise la formule : 
+  
+$$
+1 + q + q^2 + \\ldots + q^n = \\frac{1-q^{n+1}}{1-q}
+$$
+
+Ici, $q = ${raison}$ et $n = ${final}$.
+
+On a donc : 
+
+${alignTex([
+        ["S", "=", `\\frac{1-${raison}^{${final}+1}}{1-${raison}}`],
+        ["", "=", `\\frac{${1 - raison ** (final + 1)}}{${1 - raison}}`],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getAnswer = (identifiers) => {
     const { raison, final } = identifiers;
     const answer = (raison ** (final + 1) - 1) / (raison - 1) + "";
@@ -19,12 +45,17 @@ const getGeometricFirstTermsSumQuestion = () => {
     const raison = randint(2, 8);
     const final = randint(5, 10);
     const identifiers = { raison, final };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -55,4 +86,5 @@ export const geometricFirstTermsSum = {
     subject: "Mathématiques",
     getAnswer,
     getInstruction,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AA2C3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAgB1D,CAAC"}
+{"version":3,"file":"remarkableValues.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/remarkableValues.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAmD3B,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,CAgB1D,CAAC"}

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

@@ -20,6 +20,14 @@ const values = [
     "\\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 { mainValue, isCos, angleIdentifiers } = identifiers;
     const angle = reifyAlgebraic(angleIdentifiers);

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AASnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAyJF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAmB9C,CAAC"}
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAYnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAqOF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAoB9C,CAAC"}

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

@@ -7,11 +7,74 @@ import { LengthNode } from "../../../tree/nodes/geometry/lengthNode.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../utils/alea/random.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+const getHint = (identifiers) => {
+    return `On peut utiliser la formule : 
+  
+$$
+\\text{SOHCAHTOA}
+$$
+
+qui signifie : 
+
+$$
+\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const formules = [
+        "\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+        "\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+        "\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    ];
+    const oppose = triangle.sides[randAngle];
+    const adjacent = triangle.sides[3 - randAngle];
+    const hypo = triangle.sides[0];
+    const angle = triangle.angles[randAngle];
+    const fct = ["\\cos", "\\sin", "\\tan"][randTrigo];
+    const fraction = [
+        [adjacent, hypo],
+        [oppose, hypo],
+        [oppose, adjacent],
+    ][randTrigo];
+    return `On utilise la formule : 
+  
+$$
+${formules[randTrigo]}
+$$
+
+${randTrigo !== 2
+        ? `L'hypoténuse du triangle est le côté $${hypo.toTex()}$.`
+        : ""}
+
+${randTrigo !== 0
+        ? `Le côté opposé à l'angle $${angle.toTex()}$ est le côté $${oppose.toTex()}$.`
+        : ""}
+
+${randTrigo !== 1
+        ? `Le côté adjacent à l'angle $${angle.toTex()}$ est le côté $${adjacent.toTex()}$.`
+        : ""}
+
+Cela donne donc : 
+
+$$
+${fct}\\left(${angle.toTex()}\\right) = \\frac{${fraction[0].toInsideName()}}{${fraction[1].toInsideName()}}
+$$
+`;
+};
 const getInstruction = (identifiers) => {
     const { randAngle, triangleIdentifiers, randTrigo } = identifiers;
     const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const trigo = ["le cosinus", "le sinus", "la tangente"];
-    const angleSummit = triangle.points[randAngle].name;
     return `À quel quotient est égal ${trigo[randTrigo]} de l'angle $${triangle.angles[randAngle].toTex()}$ ?`;
 };
 const getAnswer = (identifiers) => {
@@ -78,6 +141,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 const getPropositions = (n, { answer, triangleIdentifiers }) => {
@@ -143,4 +208,5 @@ export const trigonometry = {
     getInstruction,
     getGGBOptions,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA+EF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAUnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAqLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAoBzD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometryAngleCalcul.js

@@ -4,7 +4,10 @@ import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { RightTriangleConstructor } from "../../../math/geometry/triangles/rightTriangle.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
 const getInstruction = (identifiers) => {
     const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
     const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
@@ -19,6 +22,89 @@ const getAnswer = (identifiers) => {
     const answer = round(triangle.angles[randAngle].evaluate(), 0);
     return answer + "^{\\circ}";
 };
+const getHint = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    return `On peut utiliser la formule : 
+  
+$$
+\\text{SOHCAHTOA}
+$$
+
+qui signifie : 
+
+$$
+\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}
+$$
+
+$$
+\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const formules = [
+        "\\text{cosinus} = \\frac{\\text{adjacent}}{\\text{hypoténuse}}",
+        "\\text{sinus} = \\frac{\\text{opposé}}{\\text{hypoténuse}}",
+        "\\text{tangente} = \\frac{\\text{opposé}}{\\text{adjacent}}",
+    ];
+    const randTrigo = hiddenSide === 0 ? 2 : hiddenSide === randAngle ? 0 : 1;
+    const oppose = triangle.sides[randAngle];
+    const adjacent = triangle.sides[3 - randAngle];
+    const hypo = triangle.sides[0];
+    const angle = triangle.angles[randAngle];
+    const fct = ["\\cos", "\\sin", "\\tan"][randTrigo];
+    const fraction = [
+        [adjacent, hypo],
+        [oppose, hypo],
+        [oppose, adjacent],
+    ][randTrigo];
+    const fractionEvs = fraction.map((e) => e.getLengthNode());
+    const fractionEv = frac(fractionEvs[0], fractionEvs[1]);
+    const fractionEvApprox = fractionEv.evaluate();
+    return `On utilise la formule : 
+
+$$
+${formules[randTrigo]}
+$$
+
+${randTrigo !== 2
+        ? `L'hypoténuse du triangle est le côté $${hypo.toTex()}$.`
+        : ""}
+
+${randTrigo !== 0
+        ? `Le côté opposé à l'angle $${angle.toTex()}$ est le côté $${oppose.toTex()}$.`
+        : ""}
+
+${randTrigo !== 1
+        ? `Le côté adjacent à l'angle $${angle.toTex()}$ est le côté $${adjacent.toTex()}$.`
+        : ""}
+
+Cela donne donc : 
+
+${alignTex([
+        [
+            `${fct}\\left(${angle.toTex()}\\right)`,
+            "=",
+            `\\frac{${fraction[0].toInsideName()}}{${fraction[1].toInsideName()}}`,
+        ],
+        ["", "=", fractionEv.toTex()],
+        ["", ...approxOrEqual(fractionEvApprox, 2)],
+    ])}
+
+On utilise alors la fonction $${fct}^{-1}$ avec la calculatrice : 
+
+$$
+${fct}^{-1}\\left(${round(fractionEvApprox, 2).frenchify()}\\right) \\approx ${getAnswer(identifiers)}
+$$
+
+On en déduit que $${angle.toTex()} \\approx ${getAnswer(identifiers)}$.
+`;
+};
 const getGGBOptions = (identifiers) => {
     const { randAngle, hiddenSide, triangleIdentifiers } = identifiers;
     const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
@@ -55,6 +141,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 const getPropositions = (n, { answer }) => {
@@ -86,4 +174,5 @@ export const trigonometryAngleCalcul = {
     getInstruction,
     getGGBOptions,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -29,6 +29,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     nb: number;
     divisor: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -1239,6 +1242,8 @@ declare const mathExercises: (Exercise<{
     startPointIndex: number;
     vectorPointsIndexes: number[];
     coeff: number;
+}, {}> | Exercise<{
+    pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
 }, {}> | Exercise<{
     trinom: number[];
 }, {}> | Exercise<{
@@ -1399,6 +1404,9 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     cartesianCoeffs1: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     cartesianCoeffs2: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+}, {}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     type: number;
@@ -1408,10 +1416,10 @@ declare const mathExercises: (Exercise<{
     angleAsked: number;
 }, {}> | Exercise<{
     coeffs: number[];
-    to: string;
+    to: "+\\infty" | "-\\infty";
 }, {}> | Exercise<{
     coeffs: number[];
-    to: string;
+    to: "+\\infty" | "-\\infty";
 }, {}> | Exercise<{
     numCoeffs: number[];
     denumCoeffs: number[];
@@ -1523,7 +1531,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
+}, {
+    useOnlyPowersOfTen: boolean;
+}> | Exercise<{
     randPower: number;
 }, {}> | Exercise<{
     a: number;
@@ -1547,6 +1557,12 @@ declare const mathExercises: (Exercise<{
     k: number;
     l: number;
     m: number;
+    n: number | undefined;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, {}> | Exercise<{
     c: number;
 }, {}> | Exercise<{
@@ -2161,7 +2177,9 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, {}> | Exercise<{
+}, {
+    useOnlyPowersOfTen: boolean;
+}> | Exercise<{
     randAngle: number;
     hiddenSide: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;