math-exercises 2.2.86 → 2.2.87

package/lib/exercises/math/calcul/decimals/multiplyDecimalByTens.js

@@ -58,7 +58,7 @@ const isAnswerValid = (ans, { answer }) => {
 exports.multiplyDecimalByTens = {
     id: "multiplyDecimalByTens",
     connector: "=",
-    label: "Multiplier/diviser un décimal par une puissance de 10",
+    label: "Multiplier/diviser un décimal par une puissance de $10$",
     levels: [],
     isSingleStep: true,
     sections: [],

package/lib/exercises/math/calcul/rounding/rounding.js

@@ -42,10 +42,10 @@ const getRoundQuestions = (opts) => {
         correction: `Le chiffre des ${ranks[precisionAsked + 1]}s est $${figureToLookAt}$. 
     
 ${figureToLookAt < 5
-            ? `Puisque ${figureToLookAt} est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. 
+            ? `Puisque $${figureToLookAt}$ est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. 
      
 Ainsi, en arrondissant ${ranksWithAu[precisionAsked]}, on a $${decTex} \\approx ${answer}$`
-            : `Puisque ${figureToLookAt} est supérieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur. 
+            : `Puisque $${figureToLookAt}$ est supérieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur. 
      
 Ainsi, en arrondissant ${ranksWithAu[precisionAsked]}, on a 
 

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.d.ts

@@ -2,6 +2,10 @@
  *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
  */
 import { Exercise } from "../../../../exercises/exercise";
+/**
+ * facto du type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ * b, d, f non nuls
+ */
 type Identifiers = {
     affinesCoeffs: number[][];
     operation: string;

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAclC;;;GAGG;AACH,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoJF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.js

@@ -7,44 +7,73 @@ exports.factoType1Exercise = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const affine_1 = require("../../../../math/polynomials/affine");
+const randint_1 = require("../../../../math/utils/random/randint");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const latexParser_1 = require("../../../../tree/parsers/latexParser");
 const random_1 = require("../../../../utils/alea/random");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 //TODO fix { "affinesCoeffs": [ [ -2, 8 ], [ -5, 4 ], [ 0, -8 ] ], "operation": "substract" } donne trop de moins
-const getFactoType1Question = () => {
-    const affines = affine_1.AffineConstructor.differentRandoms(3);
+const getStatementNode = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new affine_1.Affine(coeffs[1], coeffs[0]));
     const permut = [
         (0, shuffle_1.shuffle)([affines[0], affines[1]]),
         (0, shuffle_1.shuffle)([affines[0], affines[2]]),
     ];
-    const operation = (0, random_1.random)(["add", "substract"]);
     const statementTree = operation === "add"
         ? new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()))
         : new substractNode_1.SubstractNode(new multiplyNode_1.MultiplyNode(permut[0][0].toTree(), permut[0][1].toTree()), new multiplyNode_1.MultiplyNode(permut[1][0].toTree(), permut[1][1].toTree()));
-    const affine1 = affines[0];
-    const affine2 = affines[1].add(operation === "add" ? affines[2] : affines[2].opposite());
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    return `Factoriser et réduire : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    const affine1 = new affine_1.Affine(affinesCoeffs[0][1], affinesCoeffs[0][0]);
+    const affine2 = new affine_1.Affine(affinesCoeffs[1][1], affinesCoeffs[1][0]);
     const answerTree = affine2.coefficients[0] === 0
         ? affine1.coefficients[0] === 0
             ? affine1.multiply(affine2).toTree()
             : new multiplyNode_1.MultiplyNode(affine2.toTree(), affine1.toTree())
         : new multiplyNode_1.MultiplyNode(affine1.toTree(), affine2.toTree());
-    const answer = answerTree.toTex();
+    const answer = answerTree.simplify().toTex();
+    return answer;
+};
+const getFactoType1Question = () => {
+    const a = (0, randint_1.randint)(-9, 10, [0]);
+    const b = (0, randint_1.randint)(-9, 10, [0]);
+    const operation = (0, random_1.random)(["add", "substract"]);
+    let c, d;
+    let e, f;
+    do {
+        c = (0, randint_1.randint)(-9, 10, [0]);
+        d = (0, randint_1.randint)(-9, 10, [0]);
+        e = (0, randint_1.randint)(-9, 10, [0]);
+        f = (0, randint_1.randint)(-9, 10, [0]);
+    } while (c / a === d / b || e / a === f / b);
+    const identifiers = {
+        affinesCoeffs: [
+            [a, b],
+            [c, d],
+            [e, f],
+        ],
+        operation,
+    };
     const question = {
-        instruction: `Factoriser et réduire : 
-
-$$
-${statementTree.toTex()}
-$$`,
-        startStatement: statementTree.toTex(),
-        answer,
+        instruction: getInstruction(identifiers),
+        startStatement: getStatementNode(identifiers).toTex(),
+        answer: getAnswer(identifiers),
         keys: ["x"],
         answerFormat: "tex",
-        identifiers: {
-            affinesCoeffs: affines.map((affine) => affine.coefficients),
-            operation,
-        },
+        identifiers,
     };
     return question;
 };
@@ -67,17 +96,20 @@ const getPropositions = (n, { answer, affinesCoeffs, operation }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { affinesCoeffs, operation }) => {
-    const affines = affinesCoeffs.map((coeffs) => new affine_1.Affine(coeffs[1], coeffs[0]));
-    const affine1 = affines[0];
-    const affine2 = affines[1].add(operation === "add" ? affines[2] : affines[2].opposite());
-    const answerTree = affine2.coefficients[0] === 0
-        ? affine1.coefficients[0] === 0
-            ? affine1.multiply(affine2).toTree()
-            : new multiplyNode_1.MultiplyNode(affine2.toTree(), affine1.toTree())
-        : new multiplyNode_1.MultiplyNode(affine1.toTree(), affine2.toTree());
-    const validLatexs = answerTree.toAllValidTexs();
-    return validLatexs.includes(ans);
+const isAnswerValid = (ans, { affinesCoeffs, operation, answer }) => {
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        if (!(0, multiplyNode_1.isMultiplyNode)(parsed))
+            return false;
+        const simp = parsed.simplify();
+        const reversed = parsed.toReversed().simplify();
+        return simp.toTex() === answer || reversed.toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.factoType1Exercise = {
     id: "facto1",

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAe3C,cAAc;AAEd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA2JF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBtE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAe3C,cAAc;AAEd,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA6JF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBtE,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType0.js

@@ -23,7 +23,9 @@ const getCorrection = (identifiers, opts) => {
     const answer = getAnswer(identifiers, opts);
     return `On isole $x$ à gauche en ${identifiers.b > 0 ? "soustrayant" : "additionnant"} les deux côtés de l'inéquation par $${Math.abs(identifiers.b)}$: 
   
+$$
 ${(0, inequationNode_1.firstDegreeInequationResolutionTex)(new affine_1.Affine(1, identifiers.b), identifiers.ineqType, identifiers.c.toTree())}
+$$
 
 ${isInterval
         ? `On traduit ensuite cette inéquation en intervalle :

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType1.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA8KF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EACL,gBAAgB,EAGjB,MAAM,mCAAmC,CAAC;AAc3C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAgLF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBtE,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType1.js

@@ -25,7 +25,9 @@ const getCorrection = (identifiers, opts) => {
     const answer = getAnswer(identifiers, opts);
     return `On isole $x$ à gauche en divisant les deux côtés de l'inéquation par $${identifiers.a}$: 
   
+$$
 ${(0, inequationNode_1.firstDegreeInequationResolutionTex)(new affine_1.Affine(a, 0), ineqType, b.toTree())}
+$$
 
 ${identifiers.a < 0
         ? `On a changé le sens de l'inéquation, car $${a}$ est négatif.`

package/lib/exercises/math/derivation/derivative/convexityQuadrinomials.js

@@ -73,7 +73,7 @@ const isAnswerValid = (ans, { answer, askConvex, quadcoeffs }) => {
 };
 exports.convexityQuadrinomials = {
     id: "convexityQuadrinomials",
-    label: "Convexité des fonctions polynomiales de degré 3",
+    label: "Convexité des fonctions polynomiales de degré $3$",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/expDerivativeThree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"expDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/expDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/derivation/derivative/expDerivativeThree.js

@@ -50,11 +50,9 @@ const getPropositions = (n, { answer, a, b }) => {
 };
 const isAnswerValid = (ans, { a, b, answer }) => {
     try {
-        console.log(ans, answer);
         const parsed = (0, latexParser_1.parseAlgebraic)(ans);
         if (!parsed)
             return false;
-        console.log(parsed.simplify().toTex());
         return parsed.simplify().toTex() === answer;
     }
     catch (err) {

package/lib/exercises/math/derivation/derivative/quotientDerivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quotientDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/quotientDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAoHF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"quotientDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/quotientDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAuGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/derivation/derivative/quotientDerivative.js

@@ -71,17 +71,6 @@ const getPropositions = (n, { answer, poly1Coeffs, poly2Coeffs }) => {
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
 const isAnswerValid = (ans, { answer, poly1Coeffs, poly2Coeffs }) => {
-    // const poly1 = new Polynomial(poly1Coeffs);
-    // const poly2 = new Polynomial(poly2Coeffs);
-    // const answerNum = poly1
-    //   .derivate()
-    //   .multiply(poly2)
-    //   .add(poly1.opposite().multiply(poly2.derivate()))
-    //   .toTree({ forbidPowerToProduct: true });
-    // const answerDenum = new PowerNode(poly2.toTree(), new NumberNode(2));
-    // const answer = new FractionNode(answerNum, answerDenum);
-    // const texs = answer.toAllValidTexs();
-    // return texs.includes(ans);
     try {
         const parsed = (0, latexParser_1.parseAlgebraic)(ans);
         const simp = parsed
@@ -91,8 +80,6 @@ const isAnswerValid = (ans, { answer, poly1Coeffs, poly2Coeffs }) => {
         const simpAnswer = parsedAnswer
             .simplify({ keepPowers: true, forbidFactorize: true })
             .toTex();
-        console.log(answer);
-        console.log(simp);
         return simp === simpAnswer;
     }
     catch (err) {

package/lib/exercises/math/derivation/derivative/secondDegreeDerivative.js

@@ -94,7 +94,7 @@ exports.isSecondDegreeDerivativeAnswerValid = isSecondDegreeDerivativeAnswerVali
 exports.secondDegreeDerivative = {
     id: "secondDegreeDerivative",
     connector: "=",
-    label: "Dérivée d'un polynôme de degré 2",
+    label: "Dérivée d'un polynôme de degré $2$",
     levels: [
         "1reESM",
         "1reSpé",

package/lib/exercises/math/derivation/derivative/secondDerivativeOfThirdDegreeFunction.js

@@ -47,7 +47,7 @@ const isAnswerValid = (ans, { a, b, c, d }) => {
 };
 exports.secondDerivativeOfThridDegreeFunction = {
     id: "secondDerivativeOfThirdDegreeFunction",
-    label: "Dérivée seconde d'un polynôme de degré 3",
+    label: "Dérivée seconde d'un polynôme de degré $3$",
     levels: ["TermSpé"],
     isSingleStep: true,
     sections: ["Dérivation"],

package/lib/exercises/math/derivation/derivative/thirdDegreeDerivative.js

@@ -111,7 +111,7 @@ exports.isThirdDegreeDerivativeAnswerValid = isThirdDegreeDerivativeAnswerValid;
 exports.thirdDegreeDerivative = {
     id: "thirdDegreeDerivative",
     connector: "=",
-    label: "Dérivée d'un polynôme de degré 3",
+    label: "Dérivée d'un polynôme de degré $3$",
     levels: [
         "1reESM",
         "1reSpé",

package/lib/exercises/math/functions/absolute/absolueValueAffineEquation.js

@@ -78,9 +78,9 @@ $$
 ${firstIntersec
         ? `ce qui donne : 
   
-  $$
-  x=${firstIntersec?.toTex()}
-  $$`
+$$
+x=${firstIntersec?.toTex()}
+$$`
         : "qui n'a pas de solution, "}
 
 et d'autre part :

package/lib/exercises/math/functions/affines/signFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/signFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA8HF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}
+{"version":3,"file":"signFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/signFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAgIF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}

package/lib/exercises/math/functions/affines/signFunction.js

@@ -31,7 +31,9 @@ const getCorrection = (identifiers) => {
     const order = askingPositive ? "\\ge" : "\\le";
     return `On résout l'inéquation : 
 
+$$
 ${(0, inequationNode_1.firstDegreeInequationResolutionTex)(affine, order, (0).toTree())}
+$$
 
 On en conclut que $f$ est ${identifiers.askingPositive ? "positive" : "négative"} sur l'intervalle : 
 

package/lib/exercises/math/functions/basics/imageFunction.d.ts

@@ -4,6 +4,7 @@ type Identifiers = {
     poly1: number[];
     poly2: number[];
     xValue: number;
+    flip: boolean;
 };
 export declare const imageFunction: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/functions/basics/imageFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsDF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}
+{"version":3,"file":"imageFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAqGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/functions/basics/imageFunction.js

@@ -5,8 +5,51 @@ const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const polynomial_1 = require("../../../../math/polynomials/polynomial");
 const randint_1 = require("../../../../math/utils/random/randint");
+const latexParser_1 = require("../../../../tree/parsers/latexParser");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const getInstruction = (identifiers) => {
+    const { rand, poly1, poly2, xValue, flip } = identifiers;
+    const polynome1 = new polynomial_1.Polynomial(poly1);
+    const polynome2 = new polynomial_1.Polynomial(poly2);
+    const statement = `Soit $f(x) = ${(rand ? polynome1 : polynome2)
+        .toTree()
+        .toTex()}$. 
+    
+Calculer ${flip ? `l'image de $${xValue}$ par $f$.` : `$f(${xValue})$.`}`;
+    return statement;
+};
+const getAnswer = (identifiers) => {
+    const { rand, poly1, poly2, xValue } = identifiers;
+    const polynome1 = new polynomial_1.Polynomial(poly1);
+    const polynome2 = new polynomial_1.Polynomial(poly2);
+    const answer = rand
+        ? polynome1.calculate(xValue) + ""
+        : polynome2.calculate(xValue) + "";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Remplace $x$ par $${identifiers.xValue}$ dans l'expression de $f$.`;
+};
+const getCorrection = (identifiers) => {
+    const answer = getAnswer(identifiers);
+    const { rand, poly1, poly2, xValue, flip } = identifiers;
+    const polynome1 = new polynomial_1.Polynomial(poly1).toTree();
+    const polynome2 = new polynomial_1.Polynomial(poly2).toTree();
+    return `On remplace $x$ par $${identifiers.xValue}$ dans l'expression de $f$ : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `f\\left(${identifiers.xValue}\\right)`,
+            "=",
+            rand
+                ? polynome1.toDetailedEvaluation({ x: xValue.toTree() }).toTex()
+                : polynome2.toDetailedEvaluation({ x: xValue.toTree() }).toTex(),
+        ],
+        ["", "=", answer],
+    ])}`;
+};
 const getImageFunction = () => {
     const rand = (0, coinFlip_1.coinFlip)();
     const polynome1 = new polynomial_1.Polynomial([(0, randint_1.randint)(-9, 10), (0, randint_1.randint)(-5, 6, [0])]);
@@ -17,24 +60,22 @@ const getImageFunction = () => {
     ]);
     const xValue = (0, randint_1.randint)(-9, 10);
     const flip = (0, coinFlip_1.coinFlip)();
-    const statement = `Soit $f(x) = ${(rand ? polynome1 : polynome2)
-        .toTree()
-        .toTex()}$. Calculer ${flip ? `l'image de $${xValue}$ par $f$.` : `$f(${xValue})$.`}`;
-    const answer = rand
-        ? polynome1.calculate(xValue) + ""
-        : polynome2.calculate(xValue) + "";
+    const identifiers = {
+        poly1: polynome1.coefficients,
+        poly2: polynome2.coefficients,
+        rand,
+        xValue,
+        flip,
+    };
     const question = {
-        instruction: statement,
+        instruction: getInstruction(identifiers),
         startStatement: `f(${xValue})`,
-        answer: answer,
+        answer: getAnswer(identifiers),
         keys: [],
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         answerFormat: "tex",
-        identifiers: {
-            poly1: polynome1.coefficients,
-            poly2: polynome2.coefficients,
-            rand,
-            xValue,
-        },
+        identifiers,
     };
     return question;
 };
@@ -48,7 +89,15 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return answer === ans;
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.imageFunction = {
     id: "imageFunction",
@@ -63,4 +112,9 @@ exports.imageFunction = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getCorrection,
+    getHint,
+    hasHintAndCorrection: true,
+    getInstruction,
 };

package/lib/exercises/math/geometry/parametric/extractPointFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractPointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractPointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAiBhE,CAAC"}
+{"version":3,"file":"extractPointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractPointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwHF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAkBhE,CAAC"}

package/lib/exercises/math/geometry/parametric/extractPointFromParametricLine.js

@@ -106,4 +106,5 @@ exports.extractPointFromParametricLine = {
     getCorrection,
     getAnswer,
     hasHintAndCorrection: true,
+    getInstruction,
 };

package/lib/exercises/math/geometry/parametric/extractVectorFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractVectorFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractVectorFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA6GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAgBjE,CAAC"}
+{"version":3,"file":"extractVectorFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/extractVectorFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA6GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAiBjE,CAAC"}

package/lib/exercises/math/geometry/parametric/extractVectorFromParametricLine.js

@@ -105,4 +105,5 @@ exports.extractVectorFromParametricLine = {
     // getHint,
     // getCorrection,
     getAnswer,
+    getInstruction,
 };

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/pointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqFF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}
+{"version":3,"file":"pointFromParametricLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/parametric/pointFromParametricLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqFF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}

package/lib/exercises/math/geometry/parametric/pointFromParametricLine.js

@@ -92,4 +92,5 @@ exports.pointFromParametricLine = {
     getAnswer,
     getKeys,
     answerType: "QCU",
+    getInstruction,
 };

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

@@ -16,7 +16,7 @@ const getAnswer = (identifiers) => {
     return correctAnswer.simplify().toTex();
 };
 const getHint = (identifiers) => {
-    return `La norme d'un vecteur est la racine carrée de la somme des carrés de ses coordonnées. En d'autres termes, la norme du vecteur $$\\overrightarrow{u}\\begin{pmatrix}x\\\\y\\end{pmatrix}$$ est :
+    return `La norme d'un vecteur est la racine carrée de la somme des carrés de ses coordonnées. En d'autres termes, la norme du vecteur $$\\overrightarrow{u}\\begin{pmatrix}x \\\\ y \\end{pmatrix}$$ est :
   
 $$
 \\lVert \\overrightarrow u \\rVert = \\sqrt{x^2+y^2}

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

@@ -1 +1 @@
-{"version":3,"file":"evolutionToCM.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/evolutionToCM.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAuEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"evolutionToCM.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/evolutionToCM.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

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

@@ -6,28 +6,50 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const numberParser_1 = require("../../../tree/parsers/numberParser");
-const getEvolutionToCmQuestion = () => {
-    const evolution = (0, randint_1.randint)(-99, 101, [0]);
+const getInstruction = (identifiers) => {
+    const evolution = identifiers.evolution;
+    const isHausse = evolution > 0;
+    return `Quel est le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"} de $${isHausse ? evolution : evolution.toString().slice(1)}\\%$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const evolution = identifiers.evolution;
     const isHausse = evolution > 0;
     const CM = ((0, round_1.round)(1 + evolution / 100, 2) + "").replaceAll(".", ",");
     const answer = CM;
-    const question = {
-        answer: answer,
-        instruction: `Quel est le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"} de $${isHausse ? evolution : evolution.toString().slice(1)}\\%$ ?`,
-        keys: ["percent"],
-        answerFormat: "tex",
-        identifiers: { evolution },
-        hint: `Le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"}  de $t\\%$ est donné par $${isHausse ? "1+\\frac{t}{100}" : "1-\\frac{t}{100}"}$.
-    `,
-        correction: `Le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"}  de $t\\%$ est donné par $${isHausse ? "1+\\frac{t}{100}" : "1-\\frac{t}{100}"}$.
+    return answer;
+};
+const getHint = (identifiers) => {
+    const evolution = identifiers.evolution;
+    const isHausse = evolution > 0;
+    return `Le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"}  de $t\\%$ est donné par $${isHausse ? "1+\\frac{t}{100}" : "1-\\frac{t}{100}"}$.
+    `;
+};
+const getCorrection = (identifiers) => {
+    const evolution = identifiers.evolution;
+    const isHausse = evolution > 0;
+    const CM = ((0, round_1.round)(1 + evolution / 100, 2) + "").replaceAll(".", ",");
+    return `Le coefficient multiplicateur associé à une ${isHausse ? "hausse" : "baisse"}  de $t\\%$ est donné par $${isHausse ? "1+\\frac{t}{100}" : "1-\\frac{t}{100}"}$.
 
-Ici, on a $t = ${Math.abs(evolution)}$\\%, donc le coefficient multiplicateur vaut : 
+Ici, on a $t = ${Math.abs(evolution)}\\%$, donc le coefficient multiplicateur vaut : 
 
 $$
 1${isHausse ? "+" : "-"}\\frac{${Math.abs(evolution)}}{100} = ${CM}
 $$
 
-    `,
+    `;
+};
+const getEvolutionToCmQuestion = () => {
+    const evolution = (0, randint_1.randint)(-99, 101, [0]);
+    const isHausse = evolution > 0;
+    const identifiers = { evolution };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -60,4 +82,8 @@ exports.evolutionToCM = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getHint,
 };

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

@@ -116,7 +116,7 @@ exports.powersDivision = {
 exports.powersOfTenDivision = {
     id: "powersOfTenDivision",
     connector: "=",
-    label: "Division de puissances de 10",
+    label: "Division de puissances de $10$",
     levels: ["4ème", "3ème", "2nde"],
     sections: ["Puissances"],
     isSingleStep: true,

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

@@ -46,7 +46,7 @@ const isAnswerValid = (ans, { answer }) => {
 exports.powersOfTenToDecimal = {
     id: "powersOfTenToDecimal",
     connector: "=",
-    label: "Ecriture décimale d'une puissance de 10",
+    label: "Ecriture décimale d'une puissance de $10$",
     levels: [
         "5ème",
         "4ème",

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

@@ -64,7 +64,7 @@ const isAnswerValid = (ans, { a, b, c }) => {
 exports.powersOfTenPower = {
     id: "powersOfTenPower",
     connector: "=",
-    label: "Puissance d'une puissance de 10 ",
+    label: "Puissance d'une puissance de $10$ ",
     levels: [
         "4ème",
         "3ème",

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

@@ -108,7 +108,7 @@ const isAnswerValid = (ans, { a, b, c }) => {
 exports.powersOfTenProduct = {
     id: "powersOfTenProduct",
     connector: "=",
-    label: "Multiplication de puissances de 10",
+    label: "Multiplication de puissances de $10$",
     levels: [
         "4ème",
         "3ème",

package/lib/exercises/math/python/conditionIf.js

@@ -55,7 +55,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.conditionIf = {
     id: "conditionIf",
-    label: "Condition if 1",
+    label: "Condition if $1$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/forLoop.js

@@ -77,7 +77,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.forLoop = {
     id: "forLoop",
-    label: "Boucle for 2",
+    label: "Boucle for $2$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/inOutCalcul.js

@@ -58,7 +58,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.inOutCalcul = {
     id: "inOutCalcul",
-    label: "Attribution de variables 1",
+    label: "Attribution de variables $1$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/pyForLoop1Exercise.js

@@ -131,7 +131,7 @@ const isAnswerValid = (ans, { exercise }) => {
 };
 exports.pythonForLoop1Exercise = {
     id: "pyForLoop1Exercise",
-    label: "Boucles for 1",
+    label: "Boucles for $1$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/pyNestedForLoopExercise.js

@@ -52,7 +52,7 @@ const generateExercise = () => {
         n,
         p,
     };
-    const instruction = `Qu’affichera le programme suivant ?
+    const instruction = `Qu'affichera le programme suivant ?
   \`\`\`
   s=0
   n=${n}

package/lib/exercises/math/python/pyWhileLoop1Exercise.js

@@ -101,7 +101,7 @@ const generateType17Instruction = (a, b, op) => {
 };
 exports.pyWhileLoop1Exercise = {
     id: "pyWhileLoop1Exercise",
-    label: "Boucles while 1",
+    label: "Boucles while $1$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/math/python/whileLoop.js

@@ -65,7 +65,7 @@ const isAnswerValid = (ans, { answer }) => {
 };
 exports.whileLoop = {
     id: "whileLoop",
-    label: "Boucle while 2",
+    label: "Boucle while $2$",
     levels: ["2nde"],
     isSingleStep: true,
     sections: ["Python"],

package/lib/exercises/pc/pH.js

@@ -15,9 +15,9 @@ const getpH = () => {
     const answer = (0, frenchify_1.frenchify)((0, round_1.round)(-Math.log10(concentrationHydrogene), 1));
     const hint = "Utilisez la formule du pH : $\\text{pH} = -\\log[H^+]$.";
     const correction = `Pour calculer le pH, on utilise la formule $\\text{pH} = -\\log[H^+]$ :
-  \n1. La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.
-  \n2. En appliquant la formule, on obtient $\\text{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
-  \n3. Le résultat est $${answer}$.`;
+  \n$1$. La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.
+  \n$2$. En appliquant la formule, on obtient $\\text{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
+  \n$3$. Le résultat est $${answer}$.`;
     const question = {
         instruction,
         startStatement: `pH`,

package/lib/index.d.ts

@@ -678,6 +678,7 @@ declare const mathExercises: (Exercise<{
     poly1: number[];
     poly2: number[];
     xValue: number;
+    flip: boolean;
 }, {}> | Exercise<{
     isSpline: boolean;
     splinePoints: number[][];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/latexTester.d.ts

@@ -0,0 +1,2 @@
+export declare const latexTester: (latex: string, isDefaultInMathMode?: boolean) => boolean;
+//# sourceMappingURL=latexTester.d.ts.map

package/lib/latexTester.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,UAAW,MAAM,2CA+FxC,CAAC"}

package/lib/latexTester.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.latexTester = void 0;
+const latexTester = (latex, isDefaultInMathMode = false) => {
+    let inDollarMode = isDefaultInMathMode ?? false;
+    let inDoubleDollarMode = isDefaultInMathMode ?? false;
+    let commandModeCount = 0;
+    let leftRightCount = 0;
+    let inArray = false;
+    for (let i = 0; i < latex.length; i++) {
+        const prevChar = latex[i - 1];
+        const char = latex[i];
+        const nextChar = latex[i + 1];
+        if (char === "$") {
+            if (isDefaultInMathMode)
+                throw new Error("Dollar in default math mode");
+            if (nextChar === "$") {
+                if (inDollarMode)
+                    throw new Error("Double dollar instead of single");
+                inDoubleDollarMode = !inDoubleDollarMode;
+                i++;
+            }
+            else {
+                if (inDoubleDollarMode)
+                    throw new Error("Single dollar instead of double");
+                inDollarMode = !inDollarMode;
+            }
+        }
+        else {
+            //check si nombre dans latex
+            if (!isNaN(Number(char)) &&
+                char !== " " &&
+                char !== "\n" &&
+                char !== "\t") {
+                if (!inDollarMode && !inDoubleDollarMode) {
+                    throw new Error(`Number not in math mode, ${char}, ${latex}`);
+                }
+            }
+            //check si charactere spécial
+            if (mustEscapeCharacters.includes(char) && prevChar !== "\\") {
+                throw new Error("Must escape character");
+            }
+            //check si in math
+            if (mustBeInMath.includes(char) && !inDollarMode && !inDoubleDollarMode) {
+                throw new Error(`Must be in math mode, ${char}, ${latex}`);
+            }
+            //check si commande bien fermé
+            if (char === "{" && prevChar !== "\\") {
+                commandModeCount++;
+            }
+            if (char === "}" && prevChar !== "\\") {
+                commandModeCount--;
+            }
+            const substring = latex.substring(i);
+            if ((inDollarMode || inDoubleDollarMode) && char === "\n") {
+                let isEmptyLine = true;
+                for (let j = i + 1; j < latex.length; j++) {
+                    if (latex[j] === "\n")
+                        break;
+                    if (latex[j] !== " " && latex[j] !== "\t") {
+                        isEmptyLine = false;
+                        break;
+                    }
+                }
+                if (isEmptyLine)
+                    throw new Error(`New emtpy line in math mode, ${latex}`);
+            }
+            //check si command existe
+            const cmdMatch = substring.match(/^\\[a-zA-Z]+/);
+            if (cmdMatch?.length) {
+                const cmd = cmdMatch[0];
+                if (!validCmds.includes(cmd))
+                    throw new Error(`Command not valid, ${cmd}`);
+                if (cmd === "\\left") {
+                    leftRightCount++;
+                }
+                if (cmd === "\\right") {
+                    leftRightCount--;
+                }
+            }
+            //!Todo check si whitespace after double dollar
+            //!TODO Check si a^b^c ou a_b_c
+            //!Todo check si &, tabularnewline et hline sont bien dans tableaux
+        }
+    }
+    if (!isDefaultInMathMode && (inDollarMode || inDoubleDollarMode))
+        throw new Error(`Math mode not finished`);
+    if (leftRightCount !== 0)
+        throw new Error("Left right not balanced");
+    if (commandModeCount !== 0)
+        throw new Error(`Command not closed : ${latex}`);
+    return true;
+};
+exports.latexTester = latexTester;
+const mustEscapeCharacters = ["%", "`"];
+const mustBeInMath = ["%", "#", "_", "~", "^"];
+const mustBeInArrays = ["&", "\\tabularnewline", "\\hline"];
+const validCmds = [
+    "\\frac",
+    "\\exp",
+    "\\cos",
+    "\\arccos",
+    "\\sin",
+    "\\arcsin",
+    "\\tan",
+    "\\arctan",
+    "\\sqrt",
+    "\\log",
+    "\\ln",
+    "\\lim",
+    "\\in",
+    "\\belongs",
+    "\\text",
+    "\\int",
+    "\\circ",
+    "\\overrightarrow",
+    "\\le",
+    "\\ge",
+    "\\leq",
+    "\\geq",
+    "\\pi",
+    "\\infty",
+    "\\binom",
+    "\\left",
+    "\\right",
+    "\\alpha",
+    "\\beta",
+    "\\Delta",
+    "\\delta",
+    "\\theta",
+    "\\sigma",
+    "\\Theta",
+    "\\pm",
+    "\\times",
+    "\\div",
+    "\\cdot",
+    "\\ldots",
+    "\\begin",
+    "\\end",
+    "\\\\",
+    "\\arraystretch",
+    "\\def",
+    "\\tabularnewline",
+    "\\approx",
+    "\\lbrace",
+    "\\rbrace",
+    "\\varnothing",
+    "\\iff",
+    "\\neq",
+    "\\widehat",
+    "\\cup",
+    "\\cap",
+    "\\mathbb",
+    "\\to",
+    "\\newline",
+    "\\lVert",
+    "\\rVert",
+    "\\hline",
+    "\\mathrm",
+    "\\overline",
+    "\\quad",
+    "\\qquad",
+    "\\rightarrow",
+];

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,UAAU,YAStB,CAAC"}

package/lib/playground.js

@@ -2,7 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => { };
+const latexTester_1 = require("./latexTester");
+const playground = () => {
+    const a = `
+ijfezo
+$$
+\\frac{3^{2x+2}}{3}
+$$
+ad  
+`;
+    console.log((0, latexTester_1.latexTester)(a));
+};
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/tree/nodes/inequations/inequationNode.js

@@ -148,6 +148,6 @@ const firstDegreeInequationResolutionTex = (affine, order, right) => {
             (0, fractionNode_1.frac)((0, substractNode_1.substract)(right, b), a).simplify().toTex(),
         ]);
     }
-    return (0, alignTex_1.alignTex)(steps);
+    return (0, alignTex_1.alignTex)(steps, true);
 };
 exports.firstDegreeInequationResolutionTex = firstDegreeInequationResolutionTex;

package/lib/tree/nodes/operators/addNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAWlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAmI/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"addNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/addNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,gBAAgB,CAAC;AAKxB,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAYlE,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,OAAO,CAE/C;AAED,eAAO,MAAM,GAAG,MACX,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,YAOnC,CAAC;AAEF,qBAAa,OAAQ,YAAW,uBAAuB;IACrD,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAoCtD,SAAS,IAAI,MAAM,EAAE;IAIrB,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAK5C,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAerC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IA4I/C,aAAa;;;;;;;;;IAOb,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAUpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAMxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/addNode.js

@@ -188,6 +188,15 @@ class AddNode {
                         i--;
                         j--;
                     }
+                    //!ca a l'air bien mais faut vérifier pour tous les exos...
+                    // else if (isNumberNode(left) && isNumberNode(right)) {
+                    //   const pgcd = gcd(left.value, right.value);
+                    //   if (pgcd !== 1) {
+                    //     factors.push(pgcd.toTree());
+                    //     aSubExternals.splice(i, 1, new NumberNode(left.value / pgcd));
+                    //     bSubExternals.splice(j, 1, new NumberNode(right.value / pgcd));
+                    //   }
+                    // }
                 }
             }
             //si aucun facteur on return

package/lib/tree/nodes/operators/multiplyNode.d.ts

@@ -13,6 +13,7 @@ export declare class MultiplyNode implements CommutativeOperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     shuffle: () => void;
+    toReversed: () => MultiplyNode;
     toMathString(): string;
     toTex(options?: ToTexOptions): string;
     toAllTexs(): string[];

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAU1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAU1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAYrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IACF,UAAU,qBAER;IACF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAgFrC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAqK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}

package/lib/tree/nodes/operators/multiplyNode.js

@@ -49,6 +49,9 @@ class MultiplyNode {
             if ((0, coinFlip_1.coinFlip)())
                 [this.leftChild, this.rightChild] = [this.rightChild, this.leftChild];
         };
+        this.toReversed = () => {
+            return new MultiplyNode(this.rightChild, this.leftChild, this.opts);
+        };
         this.id = operatorNode_1.OperatorIds.multiply;
         this.leftChild = leftChild;
         this.rightChild = rightChild;

package/lib/utils/latex/alignTex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alignTex.d.ts","sourceRoot":"","sources":["../../../src/utils/latex/alignTex.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,YAAY,UAAQ,UAetE"}
+{"version":3,"file":"alignTex.d.ts","sourceRoot":"","sources":["../../../src/utils/latex/alignTex.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,YAAY,UAAQ,UAatE"}

package/lib/utils/latex/alignTex.js

@@ -9,12 +9,10 @@ function alignTex(arr, noLatexSigns = false) {
         }
     }
     alignements += "l";
-    const aligned = `${!noLatexSigns ? "$$" : ""}
-\\def\\arraystretch{1.8}
+    const aligned = `${!noLatexSigns ? "$$\n" : ""}\\def\\arraystretch{1.8}
 \\begin{array}{${alignements}}
 ${typeof arr === "string" ? arr : arr.map((el) => el.join("&")).join(` \\\\ `)}
-\\end{array}
-${!noLatexSigns ? "$$" : ""}`;
+\\end{array}${!noLatexSigns ? "\n$$\n" : ""}`;
     return aligned;
 }
 exports.alignTex = alignTex;

package/package.json

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