math-exercises 2.1.18 → 2.1.20

package/lib/exercises/math/calculLitteral/equation/equationType3Exercise.js

@@ -27,7 +27,7 @@ const getEquationType3ExerciseQuestion = () => {
         hint: "Isolez le terme $x$ dans la partie gauche de l'equation.",
         correction: `Commencer par soustraire $${b}$ des deux côtés de l'équation pour 
     l'éliminer du côté gauche, ensuite, diviser les deux côtés de l'équation par 
-    $${a}$ pour isoler $x$, ce qui donne : $ ${a}x = ${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)} \\Leftrightarrow x=\\frac{${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)}}{${a}} \\Leftrightarrow ${answer}$.`,
+    $${a}$ pour isoler $x$, ce qui donne : \n $ ${a}x = ${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)} \\Leftrightarrow x=\\frac{${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)}}{${a}} \\Leftrightarrow ${answer}$.`,
         startStatement: statementTree.toTex(),
         answer,
         keys: equationKeys_1.equationKeys,

package/lib/exercises/math/conversion/capacityConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAyDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAwDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/conversion/capacityConversion.js

@@ -33,9 +33,8 @@ const getPropositions = (n, { answer, randomCapacity, randomUnitIndex, randomUni
     (0, exercise_1.addValidProp)(propositions, answer);
     const capacityDecimal = new decimal_1.Decimal(randomCapacity);
     while (propositions.length < n) {
-        console.log("capactiy conv qcm");
         const wrongAnswer = capacityDecimal
-            .multiplyByPowerOfTen((0, randint_1.randint)(-3, 4, [randomUnitIndex - randomUnitInstructionIndex]))
+            .multiplyByPowerOfTen((0, randint_1.randint)(-4, 5, [randomUnitIndex - randomUnitInstructionIndex]))
             .value.toString()
             .replace(".", ",");
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.js

@@ -16,8 +16,8 @@ const getExponentialEquation = () => {
     const equation = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("y"));
     const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("C"), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("x"))))).toTex();
     const correctionequation = new equalNode_1.EqualNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode("y'"), new multiplyNode_1.MultiplyNode(a.toTree(), new variableNode_1.VariableNode("y"))).simplify(), new numberNode_1.NumberNode(0)).toTex();
-    const hint = "Rappelez-vous que la solution générale d'une équation différentielle de la forme $y' = ay$ est de la forme $y = Ce^{ax}$, où $C$ est une constante d'intégration.";
-    const correction = `La solution est $y = Ce^{ax}$, où $C$ est une constante d'intégration.
+    const hint = "La solution générale d'une équation différentielle de la forme $y' = ay$ est de la forme $y = Ce^{ax}$, où $C$ est une constante d'intégration.";
+    const correction = `La solution générale d'une équation différentielle de la forme $y' = ay$ est de la forme $y = Ce^{ax}$, où $C$ est une constante d'intégration.
   \n Donc, la solution générale de l'équation différentielle $y' = ${a}y$ est $y = Ce^{${a}x}$.`;
     const question = {
         instruction: `Résoudre l'équation différentielle suivante : $y' = ${equation.toTex()}$.`,

package/lib/exercises/math/functions/integral/integralFractions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integralFractions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/integral/integralFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6LF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"integralFractions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/integral/integralFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgMF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/math/functions/integral/integralFractions.js

@@ -35,7 +35,8 @@ const getIntegralFractionsQuestion = () => {
             lowerBound = (0, randint_1.randint)(-5, 5, [0]);
             upperBound = (0, randint_1.randint)(-5, 5, [0]);
         }
-    } while (doesTrinomialVanishInInterval(trinomial, lowerBound, upperBound));
+    } while (doesTrinomialVanishInInterval(trinomial, lowerBound, upperBound) ||
+        affine.calculate(lowerBound) === 0);
     const fraction = questionType === "Trinomial"
         ? new fractionNode_1.FractionNode(affine.toTree(), trinomial.toTree())
         : new fractionNode_1.FractionNode(affine.coefficients[1].toTree(), affine.toTree());

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

@@ -1 +1 @@
-{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}
+{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+CF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

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

@@ -6,16 +6,11 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const decimal_1 = require("../../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../../math/utils/random/randint");
 const log10Node_1 = require("../../../../tree/nodes/functions/log10Node");
-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, 1]);
-    const shouldEvaluate = (0, probaFlip_1.probaFlip)(0.7);
+    const tenthPower = (0, randint_1.randint)(-6, 8, [1]);
     console.log("log10 power simp q");
-    const nb = shouldEvaluate
-        ? new decimal_1.Decimal(1).multiplyByPowerOfTen(tenthPower).toTree()
-        : new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode(tenthPower));
+    const nb = new decimal_1.Decimal(1).multiplyByPowerOfTen(tenthPower).toTree();
     const answer = tenthPower + "";
     const question = {
         answer,
@@ -39,13 +34,12 @@ const getPropositions = (n, { answer, tenthPower }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const getHint = (nb) => {
-    return `Pour calculer $log(⁡${nb.toTex()})$, il est utile de transformer le nombre $${nb.toTex()}$ en une puissance de $10$.`;
+    return `Pour calculer $\\log(⁡${nb.toTex()})$, il est utile de transformer le nombre $${nb.toTex()}$ en une puissance de $10$.`;
 };
 const getCorrection = (tenthPower, nb) => {
     const powerTen = new powerNode_1.PowerNode((10).toTree(), tenthPower.toTree());
-    return `1 . Exprimez $${nb.toTex()}$ en puissance de $10$ : $${powerTen.toTex()}$ \n 
-  2 . Utilisez la propriété des logarithmes qui stipule que $\\log(a^{b}) = b\\times \\log(a) \\Leftrightarrow \\log(${powerTen.toTex()}) = ${tenthPower}\\times \\log(10) 
-  \\Leftrightarrow \\log(${nb.toTex()}) = ${tenthPower}$.
+    return `1 . On exprime $${nb.toTex()}$ en puissance de $10$ : $${nb.toTex()} = ${powerTen.toTex()}$ \n 
+  2 . On utilise la propriété $\\log(a^{b}) = b\\times \\log(a)$. On a alors $\\log(${nb.toTex()}) = \\log(${powerTen.toTex()}) = ${tenthPower}\\times \\log(10)  = ${tenthPower}$.
   `;
 };
 const isAnswerValid = (ans, { answer, tenthPower }) => {
@@ -58,11 +52,11 @@ exports.log10PowerSimplifying = {
     levels: ["TermTech", "MathComp"],
     isSingleStep: true,
     sections: ["Logarithme décimal", "Puissances"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb, 15),
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLog10PowerSimplifyingQuestion, nb, 10),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
-    maxAllowedQuestions: 15,
+    maxAllowedQuestions: 10,
     subject: "Mathématiques",
 };

package/lib/exercises/math/geometry/vectors/scalarProductViaCoords.js

@@ -23,7 +23,7 @@ const getScalarProductViaCoordsQuestion = () => {
             uCoords: [u.x.toTex(), u.y.toTex()],
             vCoords: [v.x.toTex(), v.y.toTex()],
         },
-        hint: "Rappelez-vous que le produit scalaire de deux vecteurs se calcule en multipliant les coordonnées correspondantes et en additionnant les résultats.",
+        hint: "Le produit scalaire de deux vecteurs se calcule en multipliant les coordonnées correspondantes et en additionnant les résultats.",
         correction: `Le produit scalaire de $${u.toTex()}$ et $${v.toTex()}$ est calculé comme suit : $(${u.x.toTex()} \\times ${v.x.toTex()}) + (${u.y.toTex()} \\times ${v.y.toTex()}) = ${answer}$.`,
     };
     return question;

package/lib/exercises/math/percent/isTableProportional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isTableProportional.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/isTableProportional.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkEtB,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}
+{"version":3,"file":"isTableProportional.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/isTableProportional.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkEtB,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/percent/isTableProportional.js

@@ -9,7 +9,7 @@ const getIsTableProportionalQuestion = () => {
     const table = generateTable();
     const question = {
         answer: table.coeff ? "Oui" : "Non",
-        instruction: `On considere le tableau ci-dessous, est-il proportionnel ?${table.table}`,
+        instruction: `On considère le tableau ci-dessous. Est-ce un tableau de proportionnalité ?${table.table}`,
         keys: [],
         answerFormat: "raw",
         style: { tableHasNoHeader: true },
@@ -22,7 +22,7 @@ const getPropositions = (n, { answer }) => {
     (0, exercise_1.addValidProp)(propositions, answer, "raw");
     (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
     (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
-    (0, exercise_1.tryToAddWrongProp)(propositions, "On peut pas savoir", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
@@ -47,7 +47,7 @@ const generateTable = () => {
 };
 const generateYValues = (xValues) => {
     const flip = (0, coinFlip_1.coinFlip)();
-    const coeff = (0, randint_1.randint)(1, 5);
+    const coeff = (0, randint_1.randint)(2, 6);
     return flip
         ? {
             values: xValues.map((value) => value * (0, randint_1.randint)(2, 5)),
@@ -59,7 +59,7 @@ const generateYValues = (xValues) => {
 };
 exports.isTableProportional = {
     id: "isVTableProportional",
-    label: "Reconnaître si 2 grandeurs sont proportionnelles à partir d'un tableau.",
+    label: "Reconnaître un tableau de proportionnalité",
     levels: ["5ème"],
     isSingleStep: true,
     sections: ["Proportionnalité"],

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

@@ -41,7 +41,7 @@ const getArcValueQuestion = () => {
         : selectedFunction === "cos"
             ? new cosNode_1.CosNode(new variableNode_1.VariableNode("\\theta"))
             : new tanNode_1.TanNode(new variableNode_1.VariableNode("\\theta"));
-    const instruction = `Quelle est la valeur en degrés de l'angle $\\theta$ si $${trigNode.toTex()} = ${trigValue.frenchify()}$ ? Arrondir à l'unité.`;
+    const instruction = `Quelle est la valeur en degrés de l'angle $\\theta$ sachant que $${trigNode.toTex()} = ${trigValue.frenchify()}$ ? Arrondir à l'unité.`;
     const answer = (0, round_1.round)(angleInDegrees, 0).toTree().toTex();
     const question = {
         answer: answer,
@@ -65,7 +65,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.arcValue = {
     id: "arcValue",
-    label: "Calculer l'angle en degrés donné une valeur trigonométrique",
+    label: "Calculer un angle via son cosinus/sinus/tangente",
     levels: ["1reSpé"],
     isSingleStep: true,
     sections: ["Trigonométrie"],

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

@@ -1,6 +1,7 @@
 import { Exercise } from "../../../exercises/exercise";
 type Identifiers = {
     degree: number;
+    trigoFunct: string;
 };
 export declare const calculateCosSinAndTan: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"calculateCosSinAndTan.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/calculateCosSinAndTan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

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

@@ -13,13 +13,13 @@ const random_1 = require("../../../utils/random");
 const trigo = ["sin", "tan", "cos"];
 const getCalculateCosSinAndTanQuestion = () => {
     const trigoFunct = (0, random_1.random)(trigo);
-    const degree = (0, randint_1.randint)(1, 360);
+    const degree = (0, randint_1.randint)(1, 180);
     const question = {
         answer: getCorrectAnswer(degree, trigoFunct),
-        instruction: `Calculer $${trigoFunct}(${new degree_1.DegreeNode(degree).toTex()})$, arrondir le resultat au dixième.`,
+        instruction: `Calculer $\\${trigoFunct}(${new degree_1.DegreeNode(degree).toTex()})$, arrondir le résultat au dixième.`,
         keys: [],
         answerFormat: "tex",
-        identifiers: { degree },
+        identifiers: { degree, trigoFunct },
     };
     return question;
 };
@@ -58,7 +58,7 @@ const getCorrectAnswer = (degree, trigoFunct) => {
 };
 exports.calculateCosSinAndTan = {
     id: "calculateCosSinAndTan",
-    label: "Calcul de tan/sin/cos avec des degrés",
+    label: "Calculer le cosinus/sinus/tangente d'un angle en degrés",
     levels: ["3ème"],
     isSingleStep: true,
     sections: ["Trigonométrie"],

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

@@ -90,7 +90,7 @@ const getCorrection = (sides, sideLengths, randSideQuestion, randSide, angle, an
     const opposite = sidesWithLentgh.filter((value) => value.name !== hypothenus.name && value.name !== adjacent.name)[0];
     const correctEquations = getCorrectEquations({ name: sides[randSideQuestion], length: sideLengths[randSideQuestion] }, { name: sides[randSide], length: sideLengths[randSide] }, hypothenus, { name: angle, value: angleValue }, adjacent, opposite, answer);
     return `On utilise la relation $${correctEquations[0]}$, on a donc :
-    $${correctEquations[1]} \\Leftrightarrow ${correctEquations[2]} \\Leftrightarrow ${correctEquations[3]}$ `;
+    $${correctEquations[1]}$, donc $${correctEquations[2]}$. Ainsi $${correctEquations[3]}$ `;
 };
 const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adjacent, opposite, answer) => {
     let result;
@@ -101,12 +101,12 @@ const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adja
                     ? [
                         `\\tan(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${adjacent.name}}`,
                         `\\tan(\\widehat{${angle.value}})=\\frac{${opposite.length}}{${adjacent.name}}`,
-                        `\\frac{${opposite.length}}{\\tan(\\widehat{${angle.value}})}=${adjacent.name}`,
+                        `${adjacent.name}=\\frac{${opposite.length}}{\\tan(\\widehat{${angle.value}})}`,
                     ]
                     : [
                         `\\cos(\\widehat{${angle.name}})=\\frac{${adjacent.name}}{${hypothenus.name}}`,
                         `\\cos(\\widehat{${angle.value}})=\\frac{${adjacent.name}}{${hypothenus.length}}`,
-                        `\\cos(\\widehat{${angle.value}})*${hypothenus.length}=${adjacent.name}`,
+                        `${adjacent.name}=\\cos(\\widehat{${angle.value}})\\times${hypothenus.length}`,
                     ];
             return result.concat(`${answer}=${adjacent.name}`);
         case opposite.name:
@@ -115,12 +115,12 @@ const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adja
                     ? [
                         `\\tan(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${adjacent.name}}`,
                         `\\tan(\\widehat{${angle.value}})=\\frac{${opposite.name}}{${adjacent.length}}`,
-                        `\\tan(\\widehat{${angle.value}})*${adjacent.length}=${opposite.name}`,
+                        `${opposite.name}=\\tan(\\widehat{${angle.value}})*${adjacent.length}`,
                     ]
                     : [
                         `\\sin(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${hypothenus.name}}`,
                         `\\sin(\\widehat{${angle.value}})=\\frac{${opposite.name}}{${hypothenus.length}}`,
-                        `\\sin(\\widehat{${angle.value}})*${hypothenus.length}=${opposite.name}`,
+                        `${opposite.name}=\\sin(\\widehat{${angle.value}})\\times${hypothenus.length}`,
                     ];
             return result.concat(`${answer}=${opposite.name}`);
         case hypothenus.name:
@@ -129,14 +129,14 @@ const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adja
                     ? [
                         `\\cos(\\widehat{${angle.name}})=\\frac{${adjacent.name}}{${hypothenus.name}}`,
                         `\\cos(\\widehat{${angle.value}})=\\frac{${adjacent.length}}{${hypothenus.name}}`,
-                        `\\frac{${adjacent.length}}{\\cos(${angle.value})}=${hypothenus.name}`,
+                        `${hypothenus.name}=\\frac{${adjacent.length}}{\\cos(${angle.value})}`,
                     ]
                     : [
                         `\\sin(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${hypothenus.name}}`,
                         `\\sin(\\widehat{${angle.value}})=\\frac{${opposite.length}}{${hypothenus.name}}`,
-                        `\\frac{${opposite.length}}{\\sin(${angle.value})}=${hypothenus.name}`,
+                        `${hypothenus.name}=\\frac{${opposite.length}}{\\sin(${angle.value})}`,
                     ];
-            return result.concat(`${answer}=${hypothenus.name}`);
+            return result.concat(`${hypothenus.name}=${answer}`);
         default:
             return [];
     }

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -51,11 +51,11 @@ const getPropositions = (n, { answer, originIsMoon, weight }) => {
 const getCorrection = (origin, weight, answer, gt, gl) => {
     switch (origin) {
         case "Terre":
-            return `1 . Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : \n $m = \\frac{p_T}{g_T} \\Leftrightarrow m=${(0, round_1.round)(weight / gt.evaluate(), 1)}$. \n \\
+            return `1 . Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : \n $m = \\frac{p_T}{g_T} \\Leftrightarrow m=${(0, round_1.round)(weight / gt.evaluate(), 1)}\\text{kg}$. \n \\
       2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : $p_L = m \\ \\cdot g_L \\Leftrightarrow$ $p_L = ${(0, frenchify_1.frenchify)(answer)}$.`;
         case "Lune":
             return `1 . Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
-      $m = \\frac{p_L}{g_L} \\Leftrightarrow m=${(0, round_1.round)(weight / gl.evaluate(), 1)}$. \n \\
+      $m = \\frac{p_L}{g_L} \\Leftrightarrow m=${(0, round_1.round)(weight / gl.evaluate(), 1)}\\text{kg}$. \n \\
       2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
       $p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${(0, frenchify_1.frenchify)(answer)}$.`;
         default:

package/lib/index.d.ts

@@ -1284,6 +1284,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     angleInDegrees: number;
 }> | import("./exercises/exercise").Exercise<{
     degree: number;
+    trigoFunct: string;
 }> | import("./exercises/exercise").Exercise<{
     exercise: {
         a: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/tree/nodes/functions/log10Node.js

@@ -27,9 +27,9 @@ class Log10Node {
     }
     toTex() {
         const tex = this.child.toTex();
-        if (!this.opts?.allowLnOfOne && tex === "1") {
-            return "0";
-        }
+        // if (!this.opts?.allowLnOfOne && tex === "1") {
+        //   return "0";
+        // }
         const shouldntUseBrackets = (0, absNode_1.isAbsNode)(this.child);
         if (shouldntUseBrackets)
             return `\\log${tex}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [