math-exercises 2.2.65 → 2.2.66

package/lib/exercises/math/calcul/fractions/fractionsSum.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAyGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBvD,CAAC"}
+{"version":3,"file":"fractionsSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAyGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBvD,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsSumsMultiplesDenominators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsSumsMultiplesDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsMultiplesDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2FF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAkBpE,CAAC"}
+{"version":3,"file":"fractionsSumsMultiplesDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsMultiplesDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2FF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAkBpE,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fractionsSumsPrimeDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA6FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAkBhE,CAAC"}
+{"version":3,"file":"fractionsSumsPrimeDenominators.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumsPrimeDenominators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA6FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAkBhE,CAAC"}

package/lib/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findCoeffInProportionalTableNonIntegers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqHF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAoBF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAC5D,WAAW,EACX,OAAO,CAsBR,CAAC"}
+{"version":3,"file":"findCoeffInProportionalTableNonIntegers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,0BAA0B,CAAC;AAiBlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,GAAG,CAAC;IACd,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,OAAO,EAAE,GAAG,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAyHF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAoBF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAC5D,WAAW,EACX,OAAO,CAsBR,CAAC"}

package/lib/exercises/math/calcul/proportionality/findCoeffInProportionalTableNonIntegers.js

@@ -51,10 +51,15 @@ const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
-    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-    if (!parsed)
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
         return false;
-    return parsed.simplify().toTex() === answer;
+    }
 };
 const getFindCoeffInProportionalTableNonIntegersQuestion = (opts) => {
     let coeff;

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

@@ -30,7 +30,7 @@ const getFirstIdentityQuestion = () => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers: { a: affine.a, b: affine.b },
-        hint: `Utilise l'identité remarquable 
+        hint: `Utilise l'identité remarquable :
     
 $$
 (a+b)^2 = a^2 + 2ab+b^2

package/lib/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.d.ts

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

package/lib/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.d.ts.map

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

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

@@ -0,0 +1,122 @@
+"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 { randint } from "../../../../math/utils/random/randint";
+// import {
+//   EqualNode,
+//   EqualNodeConstructor,
+//   EqualNodeIdentifiers,
+// } from "../../../../tree/nodes/equations/equalNode";
+// import {
+//   NodeConstructor,
+//   NodeIdentifiers,
+// } from "../../../../tree/nodes/nodeConstructor";
+// type Identifiers = {
+//   equaIdentifiers: EqualNodeIdentifiers;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   tryToAddWrongProp(propositions, "une soustraction", "raw");
+//   tryToAddWrongProp(propositions, "une addition", "raw");
+//   tryToAddWrongProp(propositions, "une division", "raw");
+//   tryToAddWrongProp(propositions, "une multiplication", "raw");
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   return;
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const equation = EqualNodeConstructor.fromIdentifiers(
+//     identifiers.equaIdentifiers,
+//   );
+//   return `Pour résoudre l'équation :
+// $$
+// ${equation.toTex()}
+// $$
+// il faut d'abord effectuer :
+// `;
+// };
+// // const getHint: GetHint<Identifiers> = (identifiers) => {};
+// // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   throw Error("VEA not implemented");
+// };
+// const getChoseOperationToSolveEquationQuestion: QuestionGenerator<
+//   Identifiers
+// > = (ops) => {
+//   //ax=b avec a entier, ax+b = c tout entier, x/a = b tout entier, x+-a = b entiers ,
+//   let a: number;
+//   let b: number;
+//   let c: number | undefined;
+//   const type = randint(1, 7);
+//   switch (type) {
+//     case 1:
+//       //ax = b tous entiers
+//       a = randint(-10);
+//       break;
+//     case 2:
+//       break;
+//     case 3:
+//       break;
+//     case 4:
+//       break;
+//     case 5:
+//       break;
+//     case 6:
+//       break;
+//     case 7:
+//       break;
+//   }
+//   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 choseOperationToSolveEquation: Exercise<Identifiers> = {
+//   id: "choseOperationToSolveEquation",
+//   connector: "=",
+//   label:
+//     "Choisir la bonne opération pour résoudre une équation du premier degré",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(
+//       () => getChoseOperationToSolveEquationQuestion(opts),
+//       nb,
+//     ),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   getInstruction,
+//   // getHint,
+//   // getCorrection,
+//   getAnswer,
+//   answerType: "QCU",
+// };

package/lib/exercises/math/calculLitteral/equation/equationType2Exercise.d.ts

@@ -1,11 +1,17 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor";
 /**
  *  type ax=b
  */
 type Identifiers = {
-    a: number;
-    b: number;
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
 };
-export declare const equationType2Exercise: Exercise<Identifiers>;
+type Options = {
+    aNumberType: string[];
+};
+export declare const equationType2Exercise: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=equationType2Exercise.d.ts.map

package/lib/exercises/math/calculLitteral/equation/equationType2Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationType2Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType2Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAiBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}
+{"version":3,"file":"equationType2Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType2Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAsBlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAK1C;;GAEG;AAGH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA+GF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBhE,CAAC"}

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

@@ -5,7 +5,6 @@ const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const equationKeys_1 = require("../../../../exercises/utils/keys/equationKeys");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
-const affine_1 = require("../../../../math/polynomials/affine");
 const randint_1 = require("../../../../math/utils/random/randint");
 const equationSolutionNode_1 = require("../../../../tree/nodes/equations/equationSolutionNode");
 const equalNode_1 = require("../../../../tree/nodes/equations/equalNode");
@@ -14,30 +13,59 @@ const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
-const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
-const getEquationType2ExerciseQuestion = () => {
-    const b = (0, randint_1.randint)(-10, 11);
-    const a = (0, randint_1.randint)(-9, 10, [0, 1]);
-    const solution = new rational_1.Rational(b, a).simplify();
-    const affine = new affine_1.Affine(a, 0).toTree();
-    const tree = new equalNode_1.EqualNode(affine, b.toTree());
-    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution.toTree()).toTex();
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const random_1 = require("../../../../utils/alea/random");
+const generalAffine_1 = require("../../../../math/polynomials/generalAffine");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const substractNode_1 = require("../../../../tree/nodes/operators/substractNode");
+const addNode_1 = require("../../../../tree/nodes/operators/addNode");
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (!!oldIdentifiers.numberType)
+        return oldIdentifiers;
+    return {
+        a: oldIdentifiers.a.toTree().toIdentifiers(),
+        b: oldIdentifiers.b.toTree().toIdentifiers(),
+        isXRight: false,
+        aNumberType: "Entier",
+    };
+};
+const getEquationType2ExerciseQuestion = (opts) => {
+    const types = opts?.aNumberType ?? ["Entier"];
+    const b = (0, randint_1.randint)(-10, 11).toTree();
+    const type = (0, random_1.random)(types);
+    const a = type === "Entier"
+        ? (0, randint_1.randint)(-9, 10, [0, 1]).toTree()
+        : rational_1.RationalConstructor.randomIrreductibleWithSign().toTree();
+    const solution = (0, fractionNode_1.frac)(b, a).simplify();
+    const affine = new generalAffine_1.GeneralAffine(a, 0).toTree();
+    const isXRight = (0, coinFlip_1.coinFlip)();
+    const equalTree = new equalNode_1.EqualNode(affine, b);
+    const tree = isXRight ? equalTree.reverse() : equalTree;
+    const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), solution).toTex();
     const statementTex = tree.toTex();
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b: b.toIdentifiers(),
+        isXRight,
+        aNumberType: type,
+    };
     const question = {
         instruction: `Résoudre : $${statementTex}$`,
         startStatement: statementTex,
         answer,
         keys: equationKeys_1.equationKeys,
         answerFormat: "tex",
-        identifiers: { a, b: b },
-        hint: `Il faut isoler $x$ à gauche. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${a}$.`,
-        correction: `Pour isoler $x$ à gauche, on divise les deux côtés de l'équation par $${a}$: 
+        identifiers: identifiers,
+        hint: `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${a.toTex()}$.`,
+        correction: `Pour isoler $x$ à ${isXRight ? "droite" : "gauche"}, on divise les deux côtés de l'équation par $${a.toTex()}$ : 
     
 ${(0, alignTex_1.alignTex)([
             [
                 `${statementTex}`,
                 "\\iff",
-                new equalNode_1.EqualNode(new fractionNode_1.FractionNode(affine, new numberNode_1.NumberNode(a)), new fractionNode_1.FractionNode(b.toTree(), new numberNode_1.NumberNode(a))).toTex(),
+                isXRight
+                    ? (0, equalNode_1.equal)((0, fractionNode_1.frac)(b, a), (0, fractionNode_1.frac)(affine, a)).toTex()
+                    : (0, equalNode_1.equal)((0, fractionNode_1.frac)(affine, a), (0, fractionNode_1.frac)(b, a)).toTex(),
             ],
             ["", "\\iff", answer],
         ])}
@@ -46,22 +74,39 @@ ${(0, alignTex_1.alignTex)([
     return question;
 };
 const getPropositions = (n, { answer, a, b }) => {
+    const aNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(a);
+    const bNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(b);
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, substractNode_1.substract)(bNode, aNode).simplify().toTex());
     while (propositions.length < n) {
-        const wrongAnswer = new rational_1.Rational(b + (0, randint_1.randint)(-7, 8, [0, -b]), a + (0, randint_1.randint)(-7, 8, [-a, 0])).simplify();
-        (0, exercise_1.tryToAddWrongProp)(propositions, new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), wrongAnswer.toTree()).toTex());
+        const bEv = (0, randint_1.randint)(-7, 8, [0, -bNode.evaluate()]);
+        const a = (0, addNode_1.add)(aNode, (0, randint_1.randint)(-7, 8, [-aNode.evaluate(), 0]));
+        const wrongAnswer = (0, fractionNode_1.frac)(bEv, a).simplify();
+        (0, exercise_1.tryToAddWrongProp)(propositions, new equalNode_1.EqualNode(new variableNode_1.VariableNode("x"), wrongAnswer).toTex());
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { a, b }) => {
-    const solution = new rational_1.Rational(b, a).simplify().toTree();
+    const aNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(a);
+    const bNode = nodeConstructor_1.NodeConstructor.fromIdentifiers(b);
+    const solution = (0, fractionNode_1.frac)(bNode, aNode).simplify();
     const answerTree = new equationSolutionNode_1.EquationSolutionNode(new discreteSetNode_1.DiscreteSetNode([solution]), {
         opts: { allowFractionToDecimal: true, allowRawRightChildAsSolution: true },
     });
     const validLatexs = answerTree.toAllValidTexs();
     return validLatexs.includes(ans);
 };
+const options = [
+    {
+        id: "aNumberType",
+        label: "Autoriser des fractions pour $a$",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.multiselect,
+        defaultValue: ["Entier"],
+        values: ["Entier", "Rationnel"],
+    },
+];
 exports.equationType2Exercise = {
     id: "equa2",
     connector: "\\iff",
@@ -69,11 +114,13 @@ exports.equationType2Exercise = {
     levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
     sections: ["Équations"],
     isSingleStep: true,
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEquationType2ExerciseQuestion, nb),
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getEquationType2ExerciseQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    options,
+    rebuildIdentifiers,
 };

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

@@ -12,7 +12,7 @@ const getAlgebricExpressionOfAffineQuestion = () => {
     const question = {
         answer: f.toTex(),
         instruction: `Soit une fonction affine $f$ dont le coefficient directeur vaut $${a}$ et l'ordonnée à l'origine vaut $${b}$. Écrire l'expression algébrique de $f(x)$.`,
-        keys: ["x", "equal"],
+        keys: ["x"],
         answerFormat: "tex",
         identifiers: { a, b },
     };

package/lib/exercises/math/functions/trinoms/coefficientsIdentification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}
+{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAuIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}

package/lib/exercises/math/functions/trinoms/coefficientsIdentification.js

@@ -72,10 +72,15 @@ const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
-    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-    if (!parsed)
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
         return false;
-    return parsed.simplify().toTex() === answer;
+    }
 };
 const getCoefficientsIdentificationQuestion = () => {
     const a = (0, random_1.random)([

package/lib/exercises/math/geometry/cartesian/drawAlineInGGB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawAlineInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/drawAlineInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"drawAlineInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/drawAlineInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA2DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}

package/lib/exercises/math/geometry/cartesian/drawAlineInGGB.js

@@ -64,8 +64,7 @@ exports.drawAlineInGGB = {
     answerType: "GGB",
     sections: ["Géométrie cartésienne"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDrawAlineInGgbQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
 };

package/lib/exercises/math/geometry/cartesian/placeAPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"placeAPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA+B5C,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAY/C,CAAC"}
+{"version":3,"file":"placeAPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AA+B5C,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAW/C,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAPoint.js

@@ -40,8 +40,7 @@ exports.testGGBAnswer = {
     sections: ["Géométrie euclidienne"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPlaceAPointQuestion, nb),
     answerType: "GGB",
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
 };

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildMediatriceWithCompass.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAsGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}
+{"version":3,"file":"buildMediatriceWithCompass.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAsGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.js

@@ -108,8 +108,7 @@ exports.buildMediatriceWithCompass = {
     isSingleStep: true,
     sections: [],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBuildMediatriceWithCompassQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     getPropositions,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/geometry/vectors/drawAVectorInGGB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawAVectorInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/drawAVectorInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkCF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"drawAVectorInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/drawAVectorInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkCF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}

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

@@ -45,8 +45,7 @@ exports.drawAVectorInGGB = {
     isSingleStep: true,
     sections: ["Géométrie cartésienne"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDrawAVectorInGgbQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     answerType: "GGB",
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/squareRoots/squareRootIdentities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAmBlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootIdentities.js

@@ -57,7 +57,11 @@ const getSquareRootIdentitiesQuestion = () => {
     const answer = getAnswer(type, firstTerm, secondTerm).toTex();
     const question = {
         answer,
-        instruction: `Développer et simplifier : $${statement.toTex()}$`,
+        instruction: `Développer et simplifier : 
+    
+$$
+${statement.toTex()}
+$$`,
         keys: [],
         answerFormat: "tex",
         identifiers: { type, a: a.operand, b: b?.operand, x, y },

package/lib/exercises/math/squareRoots/squareRootsDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsDistributivity.js

@@ -27,7 +27,11 @@ const getSquareRootsDistributivityQuestion = () => {
         .toTex();
     const question = {
         answer,
-        instruction: `Développer et simplifier : $${statement.toTex()}$`,
+        instruction: `Développer et simplifier : 
+    
+$$
+${statement.toTex()}
+$$`,
         keys: [],
         answerFormat: "tex",
         identifiers: { a, b: b.operand, c, d },

package/lib/exercises/pc/calibrationCurveOfSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calibrationCurveOfSolution.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/calibrationCurveOfSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA0FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"calibrationCurveOfSolution.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/calibrationCurveOfSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA0FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/pc/calibrationCurveOfSolution.js

@@ -89,8 +89,7 @@ exports.calibrationCurveOfSolution = {
     isSingleStep: true,
     sections: ["Spectrophotométrie"],
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalibrationCurveOfSolutionQuestion, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
+    ggbTimer: 60,
     isGGBAnswerValid,
     answerType: "GGB",
     subject: "Physique",

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,eAAgB,MAAM,UAAU,MAAM,YAK7D,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,eAAgB,MAAM,UAAU,MAAM,YAS7D,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -8,7 +8,12 @@ const rationalVEA = (studentAns, answer) => {
     const parsed = (0, rationalParser_1.rationalParser)(studentAns);
     if (!parsed)
         return false;
-    const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
-    return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+    try {
+        const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
+        return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+    }
+    catch (err) {
+        return false;
+    }
 };
 exports.rationalVEA = rationalVEA;

package/lib/index.d.ts

@@ -233,9 +233,13 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
 }, {}> | Exercise<{
-    a: number;
-    b: number;
-}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: number;
@@ -1711,9 +1715,13 @@ declare const pcExercises: (Exercise<{
     a: number;
     b: number;
 }, {}> | Exercise<{
-    a: number;
-    b: number;
-}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+}, {
+    aNumberType: string[];
+}> | Exercise<{
     a: number;
     b: number;
     c: 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/math/polynomials/generalAffine.d.ts

@@ -0,0 +1,10 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+export declare class GeneralAffine {
+    a: AlgebraicNode;
+    b: AlgebraicNode;
+    variable: string;
+    constructor(a: number | AlgebraicNode, b: number | AlgebraicNode, variable?: string);
+    getRoot(): AlgebraicNode;
+    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
+}
+//# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalAffine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalAffine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/generalAffine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,qBAAa,aAAa;IACxB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAGf,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,CAAC,EAAE,MAAM,GAAG,aAAa,EACzB,QAAQ,GAAE,MAAY;IAWxB,OAAO,IAAI,aAAa;IAIxB,MAAM;CAKP"}

package/lib/math/polynomials/generalAffine.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralAffine = void 0;
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+class GeneralAffine {
+    constructor(a, b, variable = "x") {
+        if (typeof a === "number")
+            this.a = a.toTree();
+        else
+            this.a = a;
+        if (this.a.evaluate() === 0)
+            throw new Error("Forbidden division by zero");
+        if (typeof b === "number")
+            this.b = b.toTree();
+        else
+            this.b = b;
+        this.variable = variable;
+    }
+    getRoot() {
+        return (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(this.b), this.a).simplify();
+    }
+    toTree() {
+        const monom = (0, multiplyNode_1.multiply)(this.a, this.variable);
+        if (this.b.evaluate() === 0)
+            return monom;
+        return (0, addNode_1.add)(monom, this.b);
+    }
+}
+exports.GeneralAffine = GeneralAffine;

package/lib/playground.js

@@ -4,7 +4,7 @@ exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
 const playground = () => {
     // logIdentifiers();
-    // const parsed = parseLatex("^{^3}");
+    // const parsed = parseLatex("x\\times +3");
     // console.log(parsed.toTex());
 };
 exports.playground = playground;

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

@@ -1,6 +1,16 @@
 import { AlgebraicNode } from "../algebraicNode";
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
+import { NodeIdentifiers } from "../nodeConstructor";
 export declare const equal: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string) => EqualNode;
+export type EqualNodeIdentifiers = {
+    id: NodeIds.equal;
+    leftChild: NodeIdentifiers;
+    rightChild: NodeIdentifiers;
+    opts?: NodeOptions;
+};
+export declare abstract class EqualNodeConstructor {
+    static fromIdentifiers(identifiers: EqualNodeIdentifiers): EqualNode;
+}
 export declare const isEqualNode: (node: Node) => node is EqualNode;
 export declare class EqualNode implements Node {
     leftChild: Node;
@@ -8,19 +18,13 @@ export declare class EqualNode implements Node {
     opts?: NodeOptions;
     type: NodeType;
     constructor(leftChild: Node, rightChild: Node, opts?: NodeOptions);
-    toIdentifiers(): {
-        id: NodeIds;
-        leftChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-        rightChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-    };
+    toIdentifiers(): EqualNodeIdentifiers;
     toEquivalentNodes(opts?: NodeOptions): Node[];
     toAllValidTexs(opts?: NodeOptions): string[];
     toMathString(): string;
     toTex(): string;
     simplify(): this;
+    shuffle(): EqualNode;
+    reverse(): EqualNode;
 }
 //# 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":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAE/D,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,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;;;;;;;;;IAOb,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;CAUT"}
+{"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"}

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

@@ -1,13 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EqualNode = exports.isEqualNode = exports.equal = void 0;
+exports.EqualNode = exports.isEqualNode = exports.EqualNodeConstructor = exports.equal = void 0;
+// import { equal } from "mathjs";
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const node_1 = require("../node");
+const nodeConstructor_1 = require("../nodeConstructor");
 const equal = (a, b) => {
     const nodeA = typeof a === "number" ? a.toTree() : typeof a === "string" ? a.toTree() : a;
     const nodeB = typeof b === "number" ? b.toTree() : typeof b === "string" ? b.toTree() : b;
     return new EqualNode(nodeA, nodeB);
 };
 exports.equal = equal;
+class EqualNodeConstructor {
+    static fromIdentifiers(identifiers) {
+        return new EqualNode(nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.leftChild), nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.rightChild), identifiers.opts);
+    }
+}
+exports.EqualNodeConstructor = EqualNodeConstructor;
 const isEqualNode = (node) => node.type === node_1.NodeType.equality;
 exports.isEqualNode = isEqualNode;
 class EqualNode {
@@ -22,6 +31,7 @@ class EqualNode {
             id: node_1.NodeIds.equal,
             leftChild: this.leftChild.toIdentifiers(),
             rightChild: this.rightChild.toIdentifiers(),
+            opts: this.opts,
         };
     }
     toEquivalentNodes(opts) {
@@ -53,5 +63,11 @@ class EqualNode {
     simplify() {
         return this;
     }
+    shuffle() {
+        return (0, coinFlip_1.coinFlip)() ? this : this.reverse();
+    }
+    reverse() {
+        return new EqualNode(this.rightChild, this.leftChild, this.opts);
+    }
 }
 exports.EqualNode = EqualNode;

package/lib/tree/nodes/inequations/inequationSolutionNode.d.ts

@@ -22,7 +22,7 @@ export declare class InequationSolutionNode implements Node {
     };
     toAllTexs(): string[];
     toAllValidTexs(): string[];
-    toEquivalentNodes(opts?: NodeOptions): (InequationSolutionNode | import("./inequationNode").InequationNode)[];
+    toEquivalentNodes(opts?: NodeOptions): (import("./inequationNode").InequationNode | InequationSolutionNode)[];
     toMathString(): string;
     toMathjs(): string;
     toTex(): string;

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

@@ -1 +1 @@
-{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAOvD,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,wFAiBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAOvD,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,wFAqBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -7,20 +7,25 @@ const multiplyNode_1 = require("../nodes/operators/multiplyNode");
 const variableNode_1 = require("../nodes/variables/variableNode");
 const latexParser_1 = require("./latexParser");
 const affineParser = (ans, variable = "x") => {
-    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-    if ((0, variableNode_1.isVariableNode)(parsed)) {
-        if (parsed.name !== variable)
-            return false;
-        return parsed;
-    }
-    //!won't handle Affines à coefficients non entiers
-    if ((0, multiplyNode_1.isMultiplyNode)(parsed)) {
-        if ((0, variableNode_1.isVariableNode)(parsed.rightChild) &&
-            parsed.rightChild.name === variable &&
-            (0, numberNode_1.isNumberNode)(parsed.leftChild)) {
-            return new affine_1.Affine(parsed.leftChild.value, 0, variable);
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if ((0, variableNode_1.isVariableNode)(parsed)) {
+            if (parsed.name !== variable)
+                return false;
+            return parsed;
+        }
+        //!won't handle Affines à coefficients non entiers
+        if ((0, multiplyNode_1.isMultiplyNode)(parsed)) {
+            if ((0, variableNode_1.isVariableNode)(parsed.rightChild) &&
+                parsed.rightChild.name === variable &&
+                (0, numberNode_1.isNumberNode)(parsed.leftChild)) {
+                return new affine_1.Affine(parsed.leftChild.value, 0, variable);
+            }
         }
     }
+    catch (err) {
+        return false;
+    }
     //"x" ou a*x ou a*x+b ou x+b
 };
 exports.affineParser = affineParser;

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

@@ -3,5 +3,5 @@ import { EqualNode } from "../nodes/equations/equalNode";
 import { InequationNode } from "../nodes/inequations/inequationNode";
 export declare const tokenize: (latex: string) => string[];
 export declare const parseAlgebraic: (latex: string) => AlgebraicNode;
-export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
+export declare const parseLatex: (latex: string) => AlgebraicNode | InequationNode | EqualNode;
 //# sourceMappingURL=latexParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA8CrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,cAAc,UAAW,MAAM,kBAa3C,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}
+{"version":3,"file":"latexParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/latexParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAGzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAkDrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA4BrC,CAAC;AAEF,eAAO,MAAM,cAAc,UAAW,MAAM,kBAa3C,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA2CvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -26,7 +26,9 @@ const functions = [
 const operators = ["+", "-", "\\div", "\\times", "^"];
 //cmds childless, like \\pi
 const symbols = [{ tex: "\\pi", node: piNode_1.PiNode }];
+//separators between trees
 const separators = ["=", "<", ">", "\\leq", "\\geq"];
+//le nombre de parentheses est il respecté
 const isDyck = (tokens) => {
     const brackets = tokens.filter((el) => el === "(" || el === ")");
     while (brackets.length) {
@@ -47,6 +49,8 @@ const isDyck = (tokens) => {
     }
     return true;
 };
+//?on push les nb, commands, variables, symboles dans un array de token
+//?ex [3 ; +  ; \\pi ; \\frac ; { ; 2 ; x ; } ; { 3 ; x ; }]
 const tokenize = (latex) => {
     const tokens = [];
     for (let i = 0; i < latex.length; i++) {
@@ -136,6 +140,9 @@ const parseLatex = (latex) => {
     }
 };
 exports.parseLatex = parseLatex;
+//? parcours en profondeur dans le sens où profondeur = ouverture d'un sous arbre math
+//? genre dans 3exp(x^2) , x^2 est à la profondeur 2 et ^2 est pronfondeur 3
+//
 const buildTree = (tokens) => {
     let currentDepth = 0;
     let maxDepth = 0;
@@ -152,7 +159,14 @@ const buildTree = (tokens) => {
         if (token === ")" || token === "}")
             currentDepth--;
     }
-    // console.log("depthed: ", depthedTokens);
+    //? on parcours en partant de profondeur max, pour chaque profondeur on build le tree de l'expression
+    //? ce tree remplace les tokens de cette profondeur
+    //? donc 3exp(x^2)
+    //?    -> via tokenize : [3, exp, x, ^, 2]
+    //?    -> to depthed: [{3, 0}, {exp, 0}, {x, 1}, {^, 1}, {2, 2}]
+    //?    -> itération 1 : [{3, 0}, {exp, 0}, {x, 1}, {^, 1}, {NumberNode(2), 1}]
+    //?    -> itération 2 : [{3, 0}, {exp, 0}, {SquareNode(x), 1}]
+    //?    -> itération 3 : Multiply(3, ExpNode(SquareNode(x)))
     while (true) {
         if (maxDepth === 0) {
             const tree = buildTreeForSameDepthTokens(depthedTokens.map((el) => el.token));
@@ -160,30 +174,33 @@ const buildTree = (tokens) => {
         }
         for (let i = 0; i < depthedTokens.length; i++) {
             const token = depthedTokens[i];
+            //? on commence par les tokens de depth max
             if (token.depth < maxDepth)
                 continue;
-            //le token est forcément ici ( ou {
-            //et on est sur qu'il n'y a aucun autre nestage à l'intérieur
+            //? le token est forcément ici ( ou {
+            //? et on est sur qu'il n'y a aucun autre nestage à l'intérieur
             const endIndex = depthedTokens.findIndex((el, index) => index > i && (el.token === ")" || el.token === "}"));
             const tree = buildTreeForSameDepthTokens(depthedTokens.slice(i + 1, endIndex).map((el) => el.token));
             depthedTokens.splice(i, endIndex - i + 1, {
                 token: tree,
                 depth: token.depth - 1,
             });
-            // console.log(`depthed after iter ${i}`, depthedTokens);
         }
         maxDepth--;
     }
 };
 const buildTreeForSameDepthTokens = (tokens) => {
-    // console.log("start: ", tokens);
+    //? à ce stade les tokens sont soit des charactères soit des nodes déjà build (par buildTree)
+    //? ici on n'est dans une profondeur unique
     let tempTokens = [];
     for (let i = 0; i < tokens.length; i++) {
         const token = tokens[i];
+        //?buildTree a déjà pu build des expressions de profondeur plus grande
         if (typeof token !== "string") {
             tempTokens[i] = token;
             continue;
         }
+        //? les nombres, variables et symboles (pi) sont direct push en node
         if (token[0].match(/[0-9]/)) {
             tempTokens[i] = new numberNode_1.NumberNode(Number(token));
         }
@@ -203,8 +220,7 @@ const buildTreeForSameDepthTokens = (tokens) => {
         else
             throw Error(`token not implemented: ${token}`);
     }
-    // console.log("after parses : ", tempTokens);
-    //1 build les fct
+    //?1 build les fct
     for (let i = 0; i < tempTokens.length; i++) {
         if (typeof tempTokens[i] !== "string")
             continue;
@@ -223,7 +239,6 @@ const buildTreeForSameDepthTokens = (tokens) => {
             }
         }
         if (token === "^") {
-            console.log(tempTokens[i - 1]);
             if (!tempTokens[i - 1] ||
                 typeof tempTokens[i - 1] === "string" ||
                 !tempTokens[i + 1] ||
@@ -312,7 +327,17 @@ const buildTreeForSameDepthTokens = (tokens) => {
         const token = tempTokens[i];
         if (!currentAdd) {
             if (typeof token === "string") {
-                if (token === "+" || token === "-") {
+                //ici on accepte +3 (mais seulement en début de tree)
+                //donc +3 + X est ok
+                //mais pas x \\times +3
+                if (token === "+" &&
+                    !!tempTokens[i + 1] &&
+                    typeof tempTokens[i + 1] !== "string" &&
+                    (0, numberNode_1.isNumberNode)(tempTokens[i + 1])) {
+                    currentAdd = tempTokens[i + 1];
+                    i++;
+                }
+                else if (token === "+" || token === "-") {
                     throw Error("Addition with no first term");
                 }
                 else

package/package.json

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