math-exercises 2.2.96 → 2.2.98

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

@@ -29,3 +29,4 @@ __exportStar(require("./digitDecimalRankNumber"), exports);
 __exportStar(require("./ordering"), exports);
 __exportStar(require("./decimals"), exports);
 // export * from "./writing";
+// export * from "./sign";

package/lib/exercises/math/calcul/sign/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/sign/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/index.ts"],"names":[],"mappings":""}

package/lib/exercises/math/calcul/sign/index.js

@@ -0,0 +1 @@
+"use strict";

package/lib/exercises/math/calcul/sign/signFromAx.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=signFromAx.d.ts.map

package/lib/exercises/math/calcul/sign/signFromAx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signFromAx.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/sign/signFromAx.ts"],"names":[],"mappings":""}

package/lib/exercises/math/calcul/sign/signFromAx.js

@@ -0,0 +1,80 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   shuffleProps,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   tryToAddWrongProp,
+// } from '../../../../exercises/exercise';
+// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions';
+// import { handleVEAError } from "../../../../utils/errors/handleVEAError";
+// type Identifiers = {
+//   coeff:number;
+//   sign: number;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   tryToAddWrongProp(propositions, `$x$ est négatif`)
+//   while (propositions.length < n) {
+//     throw Error("QCM not implemented")
+//   }
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
+// }
+// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
+//   return `On considère un nombre relatif $x$ tel que $${}$ est strictement $${sign}$. Quel est le signe de $x$ ?`
+// }
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
+//   return []
+// }
+// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
+//   try {
+//     throw Error("VEA not implemented")
+//   } catch(err){
+//     return handleVEAError(err)
+//   }
+// }
+// const getSignFromAxQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
+//   const identifiers: Identifiers = {}
+//   const question: Question<Identifiers> = {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: 'tex',
+//     identifiers,
+//     hint: getHint(identifiers),
+//     correction: getCorrection(identifiers)
+//   };
+//   return question;
+// }
+// export const signFromAx: Exercise<Identifiers> = {
+//   id: 'signFromAx',
+//   connector: "",
+//   label: undefined,
+//   isSingleStep: true,
+//   generator: (nb, opts) => getDistinctQuestions(()=>getSignFromAxQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   getHint,
+//   getCorrection,
+//   getAnswer,
+// };

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doubleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA0GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"doubleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA+JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/doubleDistributivity.js

@@ -10,12 +10,47 @@ const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const operatorComposition_1 = require("../../../../tree/utilities/operatorComposition");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
-const getDoubleDistributivityQuestion = () => {
-    const affines = affine_1.AffineConstructor.differentRandoms(2, undefined, {
-        excludes: [0],
-    });
+const handleVEAError_1 = require("../../../../utils/errors/handleVEAError");
+const polynomialParser_1 = require("../../../../tree/parsers/polynomialParser");
+const getStatementNode = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new affine_1.Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new affine_1.Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
     const statementTree = new multiplyNode_1.MultiplyNode(affines[0].toTree(), affines[1].toTree());
+    return statementTree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Développer et réduire : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new affine_1.Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new affine_1.Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
     const answer = affines[0].multiply(affines[1]).toTree().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "Multiplie chaque terme du premier facteur par chaque terme du second facteur, puis regroupe les termes similaires.";
+};
+const getCorrection = (identifiers) => {
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affines = [
+        new affine_1.Affine(affine1Coeffs[1], affine1Coeffs[0]),
+        new affine_1.Affine(affine2Coeffs[1], affine2Coeffs[0]),
+    ];
     const subTerms = [
         new multiplyNode_1.MultiplyNode(affines[0].a.toTree(), "x".toTree()),
         affines[0].b.toTree(),
@@ -28,30 +63,37 @@ const getDoubleDistributivityQuestion = () => {
         new multiplyNode_1.MultiplyNode(subTerms[1], subTerms[2], { forceTimesSign: true }),
         new multiplyNode_1.MultiplyNode(subTerms[1], subTerms[3], { forceTimesSign: true }),
     ];
-    const statementTex = statementTree.toTex();
+    return `
+${(0, alignTex_1.alignTex)([
+        [statementTex, "=", (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, subMultiplications).toTex()],
+        [
+            "",
+            "=",
+            (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, subMultiplications.map((e) => e.simplify())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+
+    `;
+};
+const getDoubleDistributivityQuestion = () => {
+    const affines = affine_1.AffineConstructor.differentRandoms(2, undefined, {
+        excludes: [0],
+    });
+    const statementTree = new multiplyNode_1.MultiplyNode(affines[0].toTree(), affines[1].toTree());
+    const identifiers = {
+        affine1Coeffs: affines[0].coefficients,
+        affine2Coeffs: affines[1].coefficients,
+    };
     const question = {
-        instruction: `Développer et réduire : $${statementTex}$`,
+        instruction: getInstruction(identifiers),
         startStatement: statementTree.toTex(),
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x"],
         answerFormat: "tex",
-        identifiers: {
-            affine1Coeffs: affines[0].coefficients,
-            affine2Coeffs: affines[1].coefficients,
-        },
-        hint: "Multiplie chaque terme du premier facteur par chaque terme du second facteur, puis regroupe les termes similaires.",
-        correction: `
-${(0, alignTex_1.alignTex)([
-            [statementTex, "=", (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, subMultiplications).toTex()],
-            [
-                "",
-                "=",
-                (0, operatorComposition_1.operatorComposition)(addNode_1.AddNode, subMultiplications.map((e) => e.simplify())).toTex(),
-            ],
-            ["", "=", answer],
-        ])}
-
-    `,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -79,14 +121,21 @@ const getPropositions = (n, { answer, affine1Coeffs, affine2Coeffs }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { affine1Coeffs, affine2Coeffs }) => {
-    const affines = [
-        new affine_1.Affine(affine1Coeffs[1], affine1Coeffs[0]),
-        new affine_1.Affine(affine2Coeffs[1], affine2Coeffs[0]),
-    ];
-    const answerTree = affines[0].multiply(affines[1]).toTree();
-    const validLatexs = answerTree.toAllValidTexs();
-    return validLatexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = (0, polynomialParser_1.polynomialParser)(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return (0, handleVEAError_1.handleVEAError)(err);
+    }
 };
 exports.doubleDistributivity = {
     id: "doubleDistri",
@@ -102,4 +151,8 @@ exports.doubleDistributivity = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };

package/lib/exercises/math/calculLitteral/distributivity/simpleDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simpleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8FF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}
+{"version":3,"file":"simpleDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/simpleDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/simpleDistributivity.js

@@ -10,6 +10,8 @@ const addNode_1 = require("../../../../tree/nodes/operators/addNode");
 const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const handleVEAError_1 = require("../../../../utils/errors/handleVEAError");
+const polynomialParser_1 = require("../../../../tree/parsers/polynomialParser");
 const buildStatement = (identifiers) => {
     const { a, b, coeff } = identifiers;
     const affine = new affine_1.Affine(a, b);
@@ -18,7 +20,11 @@ const buildStatement = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const statementTex = buildStatement(identifiers).toTex();
-    return `Développer et réduire : $${statementTex}$`;
+    return `Développer et réduire : 
+  
+$$
+${statementTex}
+$$`;
 };
 const getAnswer = (identifiers) => {
     const { a, b, coeff } = identifiers;
@@ -75,11 +81,19 @@ const getPropositions = (n, { answer, a, b, coeff }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { a, b, coeff }) => {
-    const affine = new affine_1.Affine(a, b);
-    const answerTree = affine.times(coeff).toTree();
-    const validLatexs = answerTree.toAllValidTexs();
-    return validLatexs.includes(ans);
+const isAnswerValid = (ans, { answer, a, b, coeff }) => {
+    try {
+        console.log(ans, answer);
+        const parsed = (0, polynomialParser_1.polynomialParser)(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return (0, handleVEAError_1.handleVEAError)(err);
+    }
 };
 exports.simpleDistributivity = {
     id: "simpleDistri",

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

@@ -9,6 +9,7 @@ import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
     affinesCoeffs: number[][];
     operation: string;
+    affinesOrder: number[];
 };
 export declare const factoType1Exercise: Exercise<Identifiers>;
 export {};

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,EAUT,MAAM,0BAA0B,CAAC;AAmBlC;;;GAGG;AACH,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,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;AAmBlC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAgKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

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

@@ -16,15 +16,14 @@ const random_1 = require("../../../../utils/alea/random");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const handleVEAError_1 = require("../../../../utils/errors/handleVEAError");
 const getStatementNode = (identifiers) => {
-    const { affinesCoeffs, operation } = identifiers;
+    const { affinesCoeffs, operation, affinesOrder } = 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 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 order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? addNode_1.add : substractNode_1.substract)(new multiplyNode_1.MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new multiplyNode_1.MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
     return statementTree;
 };
 const getInstruction = (identifiers) => {
@@ -35,7 +34,7 @@ $$
 ${getStatementNode(identifiers).toTex()}
 $$`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { affinesCoeffs, operation } = identifiers;
     const factor = new affine_1.Affine(affinesCoeffs[0][1], affinesCoeffs[0][0]);
     const affine2 = new affine_1.Affine(affinesCoeffs[2][1], affinesCoeffs[2][0]);
@@ -43,10 +42,11 @@ const getAnswer = (identifiers) => {
     const secondTerm = (operation === "add"
         ? (0, addNode_1.add)(affine1.toTree(), affine2.toTree())
         : (0, substractNode_1.substract)(affine1.toTree(), affine2.toTree())).simplify({ forbidFactorize: true, towardsDistribute: true });
-    const sol = (0, multiplyNode_1.multiply)(factor.toTree(), secondTerm).simplify({
-        forbidFactorize: true,
-    });
-    return sol.toTex();
+    const sol = (0, multiplyNode_1.multiply)(factor.toTree(), secondTerm).simplify({});
+    return sol;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
 };
 const getFactoType1Question = () => {
     const a = (0, randint_1.randint)(-9, 10, [0]);
@@ -71,6 +71,7 @@ const getFactoType1Question = () => {
             [e, f],
         ],
         operation,
+        affinesOrder: [(0, random_1.random)([0, 1]), (0, random_1.random)([0, 1])],
     };
     const question = {
         instruction: getInstruction(identifiers),
@@ -113,10 +114,12 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
             forbidFactorize: true,
             towardsDistribute: true,
         });
-        const answerSimp = getStatementNode(identifiers).simplify({
+        const answerSimp = getAnswerNode(identifiers).simplify({
             towardsDistribute: true,
             forbidFactorize: true,
         });
+        // const simp = parsed.simplify({});
+        console.log(simp.toTex());
         return simp.toTex() === answerSimp.toTex();
     }
     catch (err) {

package/lib/exercises/math/calculLitteral/simplifying/distributeAndSimplify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"distributeAndSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/distributeAndSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"distributeAndSimplify.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/distributeAndSimplify.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/distributeAndSimplify.js

@@ -68,7 +68,9 @@ const isAnswerValid = (ans, { answer, firstTermIsAffine, a, b, c, d, e, f, g })
         const parsed = (0, polynomialParser_1.polynomialParser)(ans);
         if (!parsed)
             return false;
-        return parsed.simplify().toTex() === answer;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() === answer);
     }
     catch (err) {
         return (0, handleVEAError_1.handleVEAError)(err);

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

@@ -1 +1 @@
-{"version":3,"file":"aeraConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/aeraConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA+DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"aeraConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/aeraConversion.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,QAAQ,EAYT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6HF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

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

@@ -1,32 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.aeraConversion = void 0;
+const numberVEA_1 = require("../../../exercises/vea/numberVEA");
 const decimal_1 = require("../../../math/numbers/decimals/decimal");
 const randint_1 = require("../../../math/utils/random/randint");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const doWhile_1 = require("../../../utils/doWhile");
+const alignTex_1 = require("../../../utils/latex/alignTex");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
+const getInstruction = (identifiers) => {
+    const { randomAera, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    return `Compléter : 
+  
+$$
+${randomAera.frenchify()}\\ \\textrm{${units[randomUnitIndex]}}^2 = \\ldots \\ \\textrm{${units[randomUnitInstructionIndex]}}^2
+$$`;
+};
+const getHint = (identifiers) => {
+    const { randomAera, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    return `On rappelle que :
+  
+$$
+1 \\ \\textrm{${unit}}^2 = ${space > 0
+        ? Math.pow(10, space * 2)
+        : (0, fractionNode_1.frac)(1, Math.pow(10, -(space * 2))).toTex()} \\ \\textrm{${target}}^2
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomAera, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0
+        ? Math.pow(10, space * 2).toTree()
+        : (0, fractionNode_1.frac)(1, Math.pow(10, -(space * 2)));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}}^2 = ${coeff.toTex()} \\ \\textrm{${target}}^2
+$$
+
+Il suffit alors de multiplier $${randomAera.frenchify()}$ par $${coeff.toTex()}$ :
+
+${(0, alignTex_1.alignTex)([
+        [
+            `${randomAera.frenchify()} \\textrm{${unit}}^2 `,
+            "=",
+            `${(0, multiplyNode_1.multiply)(coeff, randomAera).toTex()}\\ \\textrm{${target}}^2`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}^2`],
+    ])}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { randomAera, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const randomAeraDec = new decimal_1.Decimal(randomAera);
+    const answer = randomAeraDec
+        .multiplyByPowerOfTen(2 * (randomUnitIndex - randomUnitInstructionIndex))
+        .value.frenchify();
+    return answer;
+};
 const getAeraConversion = () => {
     const randomUnitIndex = (0, randint_1.randint)(0, 7);
-    const randomUnitInstructionIndex = (0, randint_1.randint)(
-    // cette manip a pour but d'éviter des conversion de type km² --> cm² ou le contraire (chiffre trop grand/petit)
-    randomUnitIndex - 2 < 0 ? 0 : randomUnitIndex - 2, randomUnitIndex + 2 > 7 ? 7 : randomUnitIndex + 3, [randomUnitIndex]);
+    const randomUnitInstructionIndex = (0, randint_1.randint)(Math.max(0, randomUnitIndex - 2), Math.min(7, randomUnitIndex + 3), [randomUnitIndex]);
     const randomAera = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
-    const answer = (randomAera.multiplyByPowerOfTen(2 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
+    const identifiers = {
+        randomAera: randomAera.value,
+        randomUnitIndex,
+        randomUnitInstructionIndex,
+    };
     const question = {
-        instruction: `Compléter : $${randomAera.value
-            .toString()
-            .replace(".", ",")} \\textrm{${units[randomUnitIndex]}}^2 = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}^2$`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            randomAera: randomAera.value,
-            randomUnitIndex,
-            randomUnitInstructionIndex,
-        },
+        identifiers: identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -43,7 +100,7 @@ const getPropositions = (n, { answer, randomAera, randomUnitIndex, randomUnitIns
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return (0, numberVEA_1.numberVEA)(ans, answer);
 };
 exports.aeraConversion = {
     id: "aeraConversion",
@@ -51,11 +108,14 @@ exports.aeraConversion = {
     getPropositions,
     isAnswerValid,
     label: "Conversion des aires",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAeraConversion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAExB,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA+DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -10,9 +10,7 @@ const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
 const getVolumeConversion = () => {
     const randomUnitIndex = (0, randint_1.randint)(0, 7);
-    const randomUnitInstructionIndex = (0, randint_1.randint)(
-    // cette manip a pour but d'éviter des conversion de type km³ --> cm³ ou le contraire (chiffre trop grand/petit)
-    randomUnitIndex - 2 < 0 ? 0 : randomUnitIndex - 2, randomUnitIndex + 2 > 6 ? 6 : randomUnitIndex + 2, [randomUnitIndex]);
+    const randomUnitInstructionIndex = (0, randint_1.randint)(Math.max(0, randomUnitIndex - 2), Math.min(7, randomUnitIndex + 3), [randomUnitIndex]);
     const randomVolume = (0, doWhile_1.doWhile)(() => decimal_1.DecimalConstructor.random(0, 1000, (0, randint_1.randint)(0, 4)), (x) => x.value === 0);
     const answer = (randomVolume.multiplyByPowerOfTen(3 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
     const question = {

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

@@ -0,0 +1,2 @@
+export * from "./tableReading";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/lib/exercises/math/dataRepresentations/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tableReading"), exports);

package/lib/exercises/math/dataRepresentations/tableReading.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    values: number[][];
+    caseAsked: number;
+};
+export declare const tableReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=tableReading.d.ts.map

package/lib/exercises/math/dataRepresentations/tableReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/tableReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IAIjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}

package/lib/exercises/math/dataRepresentations/tableReading.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableReading = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const numberVEA_1 = require("../../../exercises/vea/numberVEA");
+const randint_1 = require("../../../math/utils/random/randint");
+const random_1 = require("../../../utils/alea/random");
+const handleVEAError_1 = require("../../../utils/errors/handleVEAError");
+const dollarize_1 = require("../../../utils/latex/dollarize");
+const mdTable_1 = require("../../../utils/markdown/mdTable");
+const getPropositions = (n, { answer, values, caseAsked }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, random_1.random)(values.flat()).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { values, caseAsked } = identifiers;
+    const flatValues = values.flat();
+    return flatValues[caseAsked].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { values, caseAsked } = identifiers;
+    let population = caseAsked % 3 === 0
+        ? "de la $6^e$ A"
+        : caseAsked % 3 === 1
+            ? "de la $6^e$ B"
+            : "";
+    let caractere = caseAsked < 3
+        ? "préfèrent le jeu Minecraft"
+        : caseAsked < 6
+            ? "préfèrent le jeu The Legend of Zelda"
+            : "ont répondu au sondage";
+    return `Un sondage a été réalisé auprès des élèves de deux classes de $6^e$ pour connaître leur jeu vidéo préféré. Voici leurs réponses : 
+  
+${(0, mdTable_1.mdTable)([
+        ["", "$6^e$ A", "$6^e$ B", "Total"],
+        ["Minecraft", ...values[0].map(dollarize_1.dollarize)],
+        ["The Legend of Zelda", ...values[1].map(dollarize_1.dollarize)],
+        ["Total", ...values[2].map(dollarize_1.dollarize)],
+    ])}
+
+Combien d'élèves ${population} ${caractere} ?
+`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return (0, numberVEA_1.numberVEA)(ans, answer);
+    }
+    catch (err) {
+        return (0, handleVEAError_1.handleVEAError)(err);
+    }
+};
+const getTableReadingQuestion = (ops) => {
+    const caseAsked = (0, randint_1.randint)(0, 9);
+    const totalA = (0, randint_1.randint)(20, 30);
+    const totalB = (0, randint_1.randint)(20, 30, [totalA]);
+    const case0 = (0, randint_1.randint)(3, totalA - 5);
+    const case1 = (0, randint_1.randint)(3, totalB - 5, [case0]);
+    const case3 = totalA - case0;
+    const case4 = totalB - case1;
+    const values = [
+        [case0, case1, case0 + case1],
+        [case3, case4, case3 + case4],
+        [totalA, totalB, totalA + totalB],
+    ];
+    const identifiers = {
+        caseAsked,
+        values,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.tableReading = {
+    id: "tableReading",
+    connector: "=",
+    label: "Lire un tableau à double entrée",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTableReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"constanteDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/constanteDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAQF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAgBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAmBxE,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAE7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}
+{"version":3,"file":"constanteDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/constanteDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAMR,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAmBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAgBjE,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAmBxE,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CAE7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

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

@@ -11,17 +11,26 @@ const getHint = ({ tex }) => {
 const getCorrection = ({ tex }) => {
     return `La fonction $f$ est une fonction constante égale à $${tex}$. Or, la fonction dérivée d'une fonction constante est nulle. Ainsi, pour tout $x\\in \\mathbb{R}$, $f'(x) = 0$.`;
 };
+const getAnswer = () => "0";
+const getInstruction = (identifiers) => {
+    const tex = identifiers.tex;
+    return `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${tex}
+$$.`;
+};
 const getConstanteDerivative = () => {
     const c = nombre_1.NombreConstructor.random();
     const tex = c.toTree().toTex();
-    const answer = "0";
+    const identifiers = { tex };
     const question = {
-        instruction: `Déterminer la fonction dérivée $f'$ de la fonction $f$ définie par $f(x) = ${tex}$.`,
+        instruction: getInstruction(identifiers),
         startStatement: `f'(x)`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["x"],
         answerFormat: "tex",
-        identifiers: { tex },
+        identifiers,
         hint: getHint({ tex }),
         correction: getCorrection({ tex }),
     };
@@ -63,4 +72,6 @@ exports.constanteDerivative = {
     getHint,
     getCorrection,
     hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAoBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAwB9D,CAAC"}
+{"version":3,"file":"thirdDegreeFunctionVariation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/thirdDegreeFunctionVariation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAoBlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

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

@@ -103,16 +103,6 @@ exports.thirdDegreeFunctionVariation = {
     id: "thirdDegreeFunctionVariation",
     connector: "=",
     label: "Lecture du signe de la dérivée via les variations d'une fonction",
-    levels: [
-        "1reESM",
-        "1reSpé",
-        "1reTech",
-        "MathComp",
-        "1rePro",
-        "TermPro",
-        "TermTech",
-    ],
-    sections: ["Dérivation"],
     isSingleStep: true,
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThirdDegreeFunctionVariation, nb),
     qcmTimer: 60,

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;AAoBlC,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,CAkB9C,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;AAoBlC,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,CAqB9C,CAAC"}

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

@@ -127,4 +127,7 @@ exports.signFunction = {
     getCorrection,
     getAnswer,
     getInstruction,
+    pdfOptions: {
+        shouldSpreadPropositions: true,
+    },
 };

package/lib/exercises/math/geometry/areas/rectangleArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/rectangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuCF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"rectangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/rectangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAmB/C,CAAC"}

package/lib/exercises/math/geometry/areas/rectangleArea.js

@@ -6,18 +6,43 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const randint_1 = require("../../../../math/utils/random/randint");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getKeys = (identifiers) => ["cm", "cm2"];
+const getInstruction = (identifiers) => {
+    const { length, width } = identifiers;
+    return `Calculer l'aire d'un rectangle de $${length}$ cm de longueur et de $${width}$ cm de largeur.`;
+};
+const getAnswer = (identifiers) => {
+    const { length, width } = identifiers;
+    const answer = length * width + "";
+    const answerTex = answer + "\\text{cm}^2";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return "Pour déterminer l'aire d'un rectangle, on multiplie sa longeur par sa largeur.";
+};
+const getCorrection = (identifiers) => {
+    const { length, width } = identifiers;
+    return `L'aire d'un rectangle est le produit de sa largeur et de sa longueur.
+
+Ici, on a donc :
+
+$$
+\\mathcal{A} = ${length} \\times ${width} = ${length * width} \\text{cm}^2
+$$
+
+`;
+};
 const getRectangleArea = () => {
     const length = (0, randint_1.randint)(3, 13);
     const width = (0, randint_1.randint)(1, length);
-    const answer = length * width + "";
-    const answerTex = answer + "\\text{cm}^2";
     const identifiers = { length, width };
     const question = {
-        instruction: `Calculer l'aire d'un rectangle de $${length}$ cm de longueur et de $${width}$ cm de largeur.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: getKeys(identifiers),
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -47,4 +72,9 @@ exports.rectangleArea = {
     isAnswerValid,
     subject: "Mathématiques",
     getKeys,
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -20,5 +20,5 @@ export * from "./squareRoots";
 export * from "./trigonometry";
 export * from "./python";
 export * from "./sampling";
-export * from "./dataReading";
+export * from "./dataRepresentations";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/index.js

@@ -36,4 +36,4 @@ __exportStar(require("./squareRoots"), exports);
 __exportStar(require("./trigonometry"), exports);
 __exportStar(require("./python"), exports);
 __exportStar(require("./sampling"), exports);
-__exportStar(require("./dataReading"), exports);
+__exportStar(require("./dataRepresentations"), exports);

package/lib/index.d.ts

@@ -330,6 +330,7 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     affinesCoeffs: number[][];
     operation: string;
+    affinesOrder: number[];
 }, {}> | Exercise<{
     a: number;
     b: 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/playground.d.ts

@@ -1,2 +1,2 @@
-export declare const playground: () => void;
+export declare const playground: () => false | undefined;
 //# sourceMappingURL=playground.d.ts.map

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,7 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => { };
+const latexParser_1 = require("./tree/parsers/latexParser");
+const playground = () => {
+    const answer = "\\left(-5x-7\\right)^2";
+    const ans = "\\left(-5x-7\\right)^2";
+    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+    if (!parsed)
+        return false;
+    console.log(parsed
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+};
 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/equations/equalNode.d.ts

@@ -1,3 +1,4 @@
+import { Affine } from "../../../math/polynomials/affine";
 import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { NodeIdentifiers } from "../nodeConstructor";
@@ -27,4 +28,5 @@ export declare class EqualNode implements Node {
     shuffle(): EqualNode;
     reverse(): EqualNode;
 }
+export declare const firstDegreeEquationResolutionTex: (affineLeft: Affine, affineRight: Affine) => void;
 //# sourceMappingURL=equalNode.d.ts.map

package/lib/tree/nodes/equations/equalNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAmB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEtE,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,OAAO;IAIP,OAAO;CAUR"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAmB,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEtE,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,IAAI,sBACL,CAAC;AAElC,qBAAa,SAAU,YAAW,IAAI;IACpC,SAAS,EAAE,IAAI,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;gBACH,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,CAAC,EAAE,WAAW;IAOjE,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ;IAIR,OAAO;IAIP,OAAO;CAUR;AAED,eAAO,MAAM,gCAAgC,eAC/B,MAAM,eACL,MAAM,SAuBpB,CAAC"}

package/lib/tree/nodes/equations/equalNode.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EqualNode = exports.isEqualNode = exports.EqualNodeConstructor = exports.equal = void 0;
-// import { equal } from "mathjs";
+exports.firstDegreeEquationResolutionTex = exports.EqualNode = exports.isEqualNode = exports.EqualNodeConstructor = exports.equal = void 0;
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const node_1 = require("../node");
 const nodeConstructor_1 = require("../nodeConstructor");
@@ -71,3 +70,27 @@ class EqualNode {
     }
 }
 exports.EqualNode = EqualNode;
+const firstDegreeEquationResolutionTex = (affineLeft, affineRight) => {
+    //ax(+-b) = (+-c)(x)(+-d)
+    // const b = affine.b;
+    // const a = affine.a;
+    // if (a === 1 && b === 0)
+    //   return new InequationNode([affine.toTree(), right], [order]).toTex();
+    // const steps: string[][] = [[affine.toTex(), order, right.toTex()]];
+    // if (b !== 0)
+    //   steps.push([
+    //     affine.add(-b).toTex(),
+    //     order,
+    //     substract(right, b).simplify().toTex(),
+    //   ]);
+    // if (a !== 1) {
+    //   if (a < 0) order = new InequationSymbol(order).reversed();
+    //   steps.push([
+    //     affine.variable,
+    //     order,
+    //     frac(substract(right, b), a).simplify().toTex(),
+    //   ]);
+    // }
+    // return alignTex(steps, true);
+};
+exports.firstDegreeEquationResolutionTex = firstDegreeEquationResolutionTex;

package/lib/tree/nodes/node.d.ts

@@ -40,6 +40,7 @@ export type ToTexOptions = {
     forceParenthesis?: boolean;
     color?: string;
     noPropagation?: boolean;
+    unit?: string;
 };
 export declare enum NodeIds {
     add = 0,

package/lib/tree/nodes/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/tree/nodes/node.ts"],"names":[],"mappings":"AAGA,oBAAY,QAAQ;IAClB,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,UAAU,IAAA;IACV,KAAK,IAAA;IACL,MAAM,IAAA;IACN,QAAQ,IAAA;IACR,OAAO,IAAA;IACP,MAAM,KAAA;IACN,GAAG,KAAA;IACH,MAAM,KAAA;IACN,KAAK,KAAA;CACN;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,oBAAY,OAAO;IACjB,GAAG,IAAA;IACH,SAAS,IAAA;IACT,QAAQ,IAAA;IACR,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,KAAK,IAAA;IACL,MAAM,IAAA;IACN,OAAO,IAAA;IACP,QAAQ,IAAA;IACR,QAAQ,KAAA;IACR,OAAO,KAAA;IACP,WAAW,KAAA;IACX,QAAQ,KAAA;IACR,KAAK,KAAA;IACL,OAAO,KAAA;IACP,KAAK,KAAA;IACL,UAAU,KAAA;IACV,gBAAgB,KAAA;IAChB,GAAG,KAAA;IACH,MAAM,KAAA;IACN,MAAM,KAAA;IACN,MAAM,KAAA;IACN,GAAG,KAAA;IACH,GAAG,KAAA;IACH,GAAG,KAAA;IACH,GAAG,KAAA;IACH,KAAK,KAAA;IACL,GAAG,KAAA;IACH,IAAI,KAAA;IACJ,QAAQ,KAAA;IACR,QAAQ,KAAA;IACR,MAAM,KAAA;IACN,MAAM,KAAA;IACN,KAAK,KAAA;IACL,MAAM,KAAA;IACN,UAAU,KAAA;IACV,kBAAkB,KAAA;IAClB,mBAAmB,KAAA;IACnB,MAAM,KAAA;IACN,KAAK,KAAA;CACN;AAED,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,YAAY,EAAE,MAAM,MAAM,CAAC;IAC3B,iBAAiB,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,IAAI,EAAE,CAAC;IAClD,cAAc,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,MAAM,EAAE,CAAC;IACjD,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;IAEvC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,aAAa,EAAE,MAAM;QAAE,EAAE,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5D"}

package/lib/tree/nodes/numbers/numberNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,EAAE,YAAY,EAAkB,MAAM,2BAA2B,CAAC;AAEzE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAKrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAGxC"}
+{"version":3,"file":"numberNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/numbers/numberNode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGlE,OAAO,EAAE,YAAY,EAAkB,MAAM,2BAA2B,CAAC;AAEzE,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,UAAU,CAErD;AACD,wBAAgB,4BAA4B,CAC1C,CAAC,EAAE,IAAI,GACN,CAAC,IAAI,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAE5C;AACD,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,EAAO;CAGhE;AACD,qBAAa,UAAW,YAAW,aAAa;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAmB;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,WAAW,CAAC;gBAEjB,KAAK,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,UAAU,CAAC,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE,WAAW;IASpB,YAAY,IAAI,MAAM;IAGtB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAQrC,QAAQ;IAGR,aAAa;;;;IAMb,cAAc;IAOd,iBAAiB;IAGjB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,MAAM,CAAC,IAAI,EAAE,aAAa;IAG1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS;CAGxC"}

package/lib/tree/nodes/numbers/numberNode.js

@@ -35,7 +35,7 @@ class NumberNode {
     toTex(options) {
         const opts = this.opts?.toTexOptions ?? options;
         const color = opts?.color;
-        return (0, colorize_1.colorize)(`${this.tex}`, color);
+        return (0, colorize_1.colorize)(`${this.tex}${options?.unit ? `\\text{ ${options.unit}}` : ""}`, color);
     }
     toMathjs() {
         return this.toMathString();

package/lib/tree/parsers/latexParser.d.ts

@@ -6,6 +6,6 @@ type ParserOptions = {
     allowStartingPower?: boolean;
 };
 export declare const parseAlgebraic: (latex: string, opts?: ParserOptions) => AlgebraicNode;
-export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
+export declare const parseLatex: (latex: string) => AlgebraicNode | InequationNode | EqualNode;
 export {};
 //# sourceMappingURL=latexParser.d.ts.map

package/lib/tree/parsers/polynomialParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AASvD,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAGF,eAAO,MAAM,gBAAgB,QAAS,MAAM,SAAS,IAAI,8OAkCxD,CAAC"}
+{"version":3,"file":"polynomialParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/polynomialParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AASvD,KAAK,IAAI,GAAG;IACV,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAIF,eAAO,MAAM,gBAAgB,QAAS,MAAM,SAAS,IAAI,8OAkCxD,CAAC"}

package/lib/tree/parsers/polynomialParser.js

@@ -10,6 +10,7 @@ const latexParser_1 = require("./latexParser");
 const monomParser_1 = require("./monomParser");
 const numberParser_1 = require("./numberParser");
 //!parses polynomes sous forme développée
+//! ne surtout pas transformer ça en un parse généraliste (qui pourrait parse une forme factorisée par exemple)
 //minDegree = 0, max = undefined
 const polynomialParser = (ans, opts) => {
     try {

package/lib/tree/parsers/powerParser.d.ts

@@ -1,2 +1,2 @@
-export declare const powerParser: (ans: string) => false | import("../nodes/functions/sqrtNode").SqrtNode | import("../nodes/operators/powerNode").PowerNode | import("../nodes/operators/fractionNode").FractionNode;
+export declare const powerParser: (ans: string) => false | import("../nodes/operators/powerNode").PowerNode | import("../nodes/functions/sqrtNode").SqrtNode | import("../nodes/operators/fractionNode").FractionNode;
 //# sourceMappingURL=powerParser.d.ts.map

package/package.json

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