math-exercises 2.2.66 → 2.2.67

package/lib/exercises/math/calcul/fractions/fractionAndIntegerSum.d.ts

@@ -1,5 +1,6 @@
 import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
+    isIntegerFirst: boolean;
     integer: number;
     rational: [number, number];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"fractionAndIntegerSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionAndIntegerSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AA4ClC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,CAAC;AAgCF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAwBF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAehE,CAAC"}
+{"version":3,"file":"fractionAndIntegerSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionAndIntegerSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAgBlC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,CAAC;AA+FF,KAAK,OAAO,GAAG;IACb,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAcF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBhE,CAAC"}

package/lib/exercises/math/calcul/fractions/fractionAndIntegerSum.js

@@ -4,35 +4,60 @@ exports.fractionAndIntegerSum = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const allowNonIrreductibleFractions_1 = require("../../../../exercises/options/allowNonIrreductibleFractions");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
 const integer_1 = require("../../../../math/numbers/integer/integer");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../../math/utils/random/randint");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
-const rationalParser_1 = require("../../../../tree/parsers/rationalParser");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (oldIdentifiers.isIntegerFirst !== undefined)
+        return oldIdentifiers;
+    return {
+        integer: oldIdentifiers.integer,
+        isIntegerFirst: (0, coinFlip_1.coinFlip)(),
+        rational: oldIdentifiers.rational,
+    };
+};
+const getStatementNode = (identifiers) => {
+    const ratio = (0, fractionNode_1.frac)(identifiers.rational[0], identifiers.rational[1]);
+    const statement = identifiers.isIntegerFirst
+        ? (0, addNode_1.add)(identifiers.integer, ratio)
+        : (0, addNode_1.add)(ratio, identifiers.integer);
+    return statement;
+};
+const getInstruction = (identifiers, opts) => {
+    const statement = getStatementNode(identifiers);
+    return `Calculer ${opts?.allowNonIrreductible
+        ? ""
+        : "et donner le résultat sous la forme la plus simplifiée possible"} : 
+  
+$$
+${statement.toTex()}
+$$`;
+};
+const getAnswer = (identifiers, opts) => {
+    const answerTree = getStatementNode(identifiers);
+    return answerTree.simplify().toTex();
+};
 const getFractionAndIntegerSum = (opts) => {
     const rational = rational_1.RationalConstructor.randomIrreductible();
-    const integer = new integer_1.Integer((0, randint_1.randint)(-10, 11, [0]));
-    const statementTree = new addNode_1.AddNode(rational.toTree(), integer.toTree());
-    statementTree.shuffle();
-    const answerTree = rational.add(integer).toTree();
-    const answer = answerTree.toTex();
+    const integer = (0, randint_1.randint)(-10, 11, [0]);
+    const isIntegerFirst = (0, coinFlip_1.coinFlip)();
+    const identifiers = {
+        integer: integer,
+        rational: [rational.num, rational.denum],
+        isIntegerFirst,
+    };
     const question = {
-        instruction: `Calculer ${opts?.allowNonIrreductible
-            ? ""
-            : "et donner le résultat sous la forme la plus simplifiée possible"} : 
-  
-$$
-${statementTree.toTex()}
-$`,
-        startStatement: statementTree.toTex(),
-        answer,
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStatementNode(identifiers).toTex(),
+        answer: getAnswer(identifiers, opts),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            integer: integer.value,
-            rational: [rational.num, rational.denum],
-        },
+        identifiers,
     };
     return question;
 };
@@ -52,30 +77,16 @@ const getPropositions = (n, { answer, integer, rational }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const options = [allowNonIrreductibleFractions_1.allowNonIrreductibleOption];
-const isAnswerValid = (ans, { integer, rational }, opts) => {
-    const integerObj = new integer_1.Integer(integer);
-    const rationalObj = new rational_1.Rational(rational[0], rational[1]);
-    const answerTree = rationalObj
-        .add(integerObj)
-        .toTree({ allowFractionToDecimal: true });
-    const texs = answerTree.toAllValidTexs();
-    if (opts?.allowNonIrreductible) {
-        const parsed = (0, rationalParser_1.rationalParser)(ans);
-        if (!parsed)
-            return false;
-        return texs.includes(parsed.simplify().toTex());
-    }
-    else {
-        return texs.includes(ans);
-    }
+const isAnswerValid = (ans, { answer, integer, rational }, opts) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer, {
+        allowNonIrreductible: !!opts?.allowNonIrreductible,
+    });
 };
 exports.fractionAndIntegerSum = {
     id: "fractionAndIntegerSum",
     connector: "=",
     label: "Somme d'un entier et d'une fraction",
-    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro"],
     isSingleStep: false,
-    sections: ["Fractions"],
     generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getFractionAndIntegerSum(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -83,4 +94,7 @@ exports.fractionAndIntegerSum = {
     isAnswerValid,
     subject: "Mathématiques",
     options,
+    getAnswer,
+    getInstruction,
+    rebuildIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"distanceBetweenTwoPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/distanceBetweenTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAgHF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}
+{"version":3,"file":"distanceBetweenTwoPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/distanceBetweenTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkHF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

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

@@ -18,7 +18,9 @@ const getDistanceBetweenTwoPoints = () => {
         .toTree()
         .toTex();
     const question = {
-        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Calculer la distance $AB$.`,
+        instruction: `Dans un repère orthonormé, soit deux points $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. 
+    
+Calculer la distance $AB$.`,
         startStatement: "AB",
         answer,
         keys: [],

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

@@ -1 +1 @@
-{"version":3,"file":"applyPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/applyPercent.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAqFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAwB9C,CAAC"}
+{"version":3,"file":"applyPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/applyPercent.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAmFF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAwB9C,CAAC"}

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

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyPercent = void 0;
+const numberVEA_1 = require("../../../exercises/vea/numberVEA");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
@@ -74,9 +74,7 @@ const getPropositions = (n, { answer }) => {
     return (0, shuffle_1.shuffle)(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(ans);
+    return (0, numberVEA_1.numberVEA)(ans, answer);
 };
 exports.applyPercent = {
     id: "applyPercent",

package/lib/exercises/math/probaStat/probabilityTree.d.ts

@@ -1,15 +1,18 @@
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor";
 import { Exercise } from "../../exercise";
 type Identifiers = {
-    type: number;
-    A: number;
-    B: number;
-    AC: number;
-    AD: number;
-    BC: number;
-    BD: number;
+    A: NodeIdentifiers;
+    B: NodeIdentifiers;
+    AC: NodeIdentifiers;
+    AD: NodeIdentifiers;
+    BC: NodeIdentifiers;
+    BD: NodeIdentifiers;
+    probaName: string;
 };
 type Options = {
     allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 };
 export declare const probabilityTree: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/probaStat/probabilityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAWT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwIF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA0CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB1D,CAAC"}
+{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probabilityTree.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAY1C,OAAO,EACL,QAAQ,EAeT,MAAM,gBAAgB,CAAC;AAmCxB,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4MF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC"}

package/lib/exercises/math/probaStat/probabilityTree.js

@@ -1,72 +1,181 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.probabilityTree = void 0;
+const rationalVEA_1 = require("../../../exercises/vea/rationalVEA");
 const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
-const gcd_1 = require("../../../math/utils/arithmetic/gcd");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const nodeConstructor_1 = require("../../../tree/nodes/nodeConstructor");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const latexParser_1 = require("../../../tree/parsers/latexParser");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const random_1 = require("../../../utils/alea/random");
 const shuffle_1 = require("../../../utils/alea/shuffle");
 const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
-const getAnswerNode = ({ type, A, B, AC, AD, BC, BD }) => {
-    const pA = (0, fractionNode_1.frac)(A, A + B);
-    const pB = (0, fractionNode_1.frac)(B, A + B);
-    const pA_C = (0, fractionNode_1.frac)(AC, AC + AD);
-    const pA_D = (0, fractionNode_1.frac)(AD, AC + AD);
-    const pB_C = (0, fractionNode_1.frac)(BC, BC + BD);
-    const pB_D = (0, fractionNode_1.frac)(BD, BC + BD);
-    switch (type) {
+const rebuildIdentifiers = (oldIdentifiers) => {
+    if (oldIdentifiers.probaName)
+        return oldIdentifiers;
+    const ABTotal = oldIdentifiers.A + oldIdentifiers.B;
+    const ASubTotal = oldIdentifiers.AC + oldIdentifiers.AD;
+    const BSubTotal = oldIdentifiers.BC + oldIdentifiers.BD;
+    let probaName = "";
+    switch (oldIdentifiers.type) {
         case 1:
-            return (0, multiplyNode_1.multiply)(pA, pA_C).simplify();
+            probaName = "P(A\\cap C)";
+            break;
         case 2:
-            return (0, multiplyNode_1.multiply)(pA, pA_D).simplify();
+            probaName = "P(A\\cap D)";
+            break;
         case 3:
-            return (0, multiplyNode_1.multiply)(pB, pB_C).simplify();
+            probaName = "P(B\\cap C)";
+            break;
         case 4:
+            probaName = "P(B\\cap D)";
+            break;
+    }
+    return {
+        probaName,
+        A: (0, fractionNode_1.frac)(oldIdentifiers.A, ABTotal).simplify().toIdentifiers(),
+        B: (0, fractionNode_1.frac)(oldIdentifiers.B, ABTotal).simplify().toIdentifiers(),
+        AC: (0, fractionNode_1.frac)(oldIdentifiers.AC, ASubTotal).simplify().toIdentifiers(),
+        AD: (0, fractionNode_1.frac)(oldIdentifiers.AD, ASubTotal).simplify().toIdentifiers(),
+        BC: (0, fractionNode_1.frac)(oldIdentifiers.BC, BSubTotal).simplify().toIdentifiers(),
+        BD: (0, fractionNode_1.frac)(oldIdentifiers.BD, BSubTotal).simplify().toIdentifiers(),
+    };
+};
+const optionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
+];
+const defaultOptionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+];
+const buildAll = (identifiers) => {
+    return {
+        pA: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.A),
+        pAC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AC),
+        pAD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.AD),
+        pB: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.B),
+        pBC: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BC),
+        pBD: nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.BD),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const probas = buildAll(identifiers);
+    switch (identifiers.probaName) {
+        case "P(A)":
+            return probas.pA;
+        case "P(B)":
+            return probas.pB;
+        case "P(A\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAC).simplify();
+        case "P(A\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pA, probas.pAD).simplify();
+        case "P(B\\cap C)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBC).simplify();
+        case "P(B\\cap D)":
+            return (0, multiplyNode_1.multiply)(probas.pB, probas.pBD).simplify();
+        case "P_A(C)":
+            return probas.pAC;
+        case "P_A(D)":
+            return probas.pAD;
+        case "P_B(C)":
+            return probas.pBC;
+        case "P_B(D)":
+            return probas.pBD;
+        case "P(C)":
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAC), (0, multiplyNode_1.multiply)(probas.pB, probas.pBC)).simplify();
+        case "P(D)":
         default:
-            return (0, multiplyNode_1.multiply)(pB, pB_D).simplify();
+            return (0, addNode_1.add)((0, multiplyNode_1.multiply)(probas.pA, probas.pAD), (0, multiplyNode_1.multiply)(probas.pB, probas.pBD)).simplify();
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers, options) => {
+    let instr = `On considère l'arbre de probabilités ci-dessous. Calculer : 
+  
+$$
+${identifiers.probaName}
+$$`;
+    if (options?.allowApproximate) {
+        instr += `
+
+Donner la valeur exacte ou une valeur arrondie au ${options.allowApproximate}.`;
+    }
+    return instr;
+};
+const getProbaAndOpposite = (decimal = false) => {
+    if (!decimal) {
+        const proba = rational_1.RationalConstructor.randomIrreductibleProba().toTree();
+        return [proba, (0, substractNode_1.substract)(1, proba).simplify()];
+    }
+    else {
+        const proba = (0, round_1.round)((0, randfloat_1.randfloat)(0.01, 1, 2), 2);
+        return [proba.toTree(), (0, round_1.round)(1 - proba, 2).toTree()];
     }
 };
 const getProbabilityTree = (opts) => {
-    const A = (0, randint_1.randint)(2, 9);
-    const B = (0, randint_1.randint)(2, 10 - A);
-    const AC = (0, randint_1.randint)(2, 9);
-    const AD = (0, randint_1.randint)(2, 10 - AC);
-    const BC = (0, randint_1.randint)(2, 9);
-    const BD = (0, randint_1.randint)(2, 10 - BC);
-    let instruction = `En utilisant l'arbre de probabilité suivant, `;
-    let startStatement = "";
-    const type = (0, randint_1.randint)(1, 5);
-    const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-    const answerTex = answer.toTex();
-    switch (type) {
-        case 1: {
-            instruction += `calculer $P(A \\cap C)$.`;
-            startStatement = `P(A \\cap C)`;
+    const isDecimal = opts?.probaType === "Décimales";
+    const [pA, pB] = getProbaAndOpposite(isDecimal);
+    const [pC_A, pD_A] = getProbaAndOpposite(isDecimal);
+    const [pC_B, pD_B] = getProbaAndOpposite(isDecimal);
+    const eventTypes = opts?.eventTypes?.length
+        ? opts.eventTypes
+        : defaultOptionValues;
+    const type = (0, random_1.random)(eventTypes);
+    const index = optionValues.indexOf(type);
+    let probaName = "";
+    switch (index) {
+        case 0: //inter
+            probaName = (0, random_1.random)([
+                "P(A\\cap C)",
+                "P(A\\cap D)",
+                "P(B\\cap C)",
+                "P(B\\cap D)",
+            ]);
             break;
-        }
-        case 2: {
-            instruction += `calculer $P(A \\cap D)$.`;
-            startStatement = `P(A \\cap D)`;
+        case 1: //totale
+            probaName = (0, random_1.random)(["P(C)", "P(D)"]);
             break;
-        }
-        case 3: {
-            instruction += `calculer $P(B \\cap C)$.`;
-            startStatement = `P(B \\cap C)`;
+        case 2: //conditionnal
+            probaName = (0, random_1.random)(["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"]);
             break;
-        }
-        case 4: {
-            instruction += `calculer $P(B \\cap D)$.`;
-            startStatement = `P(B \\cap D)`;
+        case 3: //simple
+            probaName = (0, random_1.random)(["P(A)", "P(B)"]);
             break;
-        }
-    }
-    if (opts?.allowApproximate) {
-        instruction += ` Donner la valeur exacte ou une valeur arrondie au ${opts.allowApproximate}.`;
     }
+    const identifiers = {
+        A: pA.toIdentifiers(),
+        B: pB.toIdentifiers(),
+        AC: pC_A.toIdentifiers(),
+        AD: pD_A.toIdentifiers(),
+        BC: pC_B.toIdentifiers(),
+        BD: pD_B.toIdentifiers(),
+        probaName,
+    };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: probaName,
+        answer: getAnswer(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getGGBOptions = (identifiers, opts) => {
+    const probas = buildAll(identifiers);
     let commands = [
         "A = Point({2,2})",
         "B = Point({2,-2})",
@@ -80,12 +189,12 @@ const getProbabilityTree = (opts) => {
         "Segment(Point({0,0}),B)",
         "Segment(B,BC)",
         "Segment(B,BD)",
-        `Text("\\scriptsize ${A / (0, gcd_1.gcd)(A, A + B)}/${(A + B) / (0, gcd_1.gcd)(A, A + B)}", (0.3, 2.1), true, true)`,
-        `Text("\\scriptsize ${AC / (0, gcd_1.gcd)(AC, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AC, AC + AD)}", (2.8, 3.5), true, true)`,
-        `Text("\\scriptsize ${AD / (0, gcd_1.gcd)(AD, AC + AD)}/${(AC + AD) / (0, gcd_1.gcd)(AD, AC + AD)}", (2.8, 1.4), true, true)`,
-        `Text("\\scriptsize ${B / (0, gcd_1.gcd)(B, A + B)}/${(A + B) / (0, gcd_1.gcd)(B, A + B)}", (0.3, -1.2), true, true)`,
-        `Text("\\scriptsize ${BC / (0, gcd_1.gcd)(BC, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BC, BC + BD)}", (2.8, -0.6), true, true)`,
-        `Text("\\scriptsize ${BD / (0, gcd_1.gcd)(BD, BC + BD)}/${(BC + BD) / (0, gcd_1.gcd)(BD, BC + BD)}", (2.8, -2.5), true, true)`,
+        `Text("\\scriptsize ${probas.pA.toTex()}", (0.1, 2.2), true, true)`,
+        `Text("\\scriptsize ${probas.pAC.toTex()}", (2.8, 4), true, true)`,
+        `Text("\\scriptsize ${probas.pAD.toTex()}", (2.8, 1.6), true, true)`,
+        `Text("\\scriptsize ${probas.pB.toTex()}", (0.1, -0.8), true, true)`,
+        `Text("\\scriptsize ${probas.pBC.toTex()}", (2.8, -0.6), true, true)`,
+        `Text("\\scriptsize ${probas.pBD.toTex()}", (2.8, -2.5), true, true)`,
         'Text("A", (1.85 , 2.5))',
         'Text("B", (1.85 , -2.8))',
         'Text("C", (5.5 , 2.85))',
@@ -98,44 +207,30 @@ const getProbabilityTree = (opts) => {
         hideAxes: true,
         hideGrid: true,
     });
-    const question = {
-        instruction,
-        startStatement,
-        answer: answerTex,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-2, 8, -5, 5],
-        }),
-        answerFormat: "tex",
-        identifiers: { A, AC, AD, B, BC, BD, type },
-    };
-    return question;
+    return ggb.getOptions({
+        coords: [-2, 8, -5, 5],
+    });
 };
-const getPropositions = (n, { answer, A, AC, AD, B, BC, BD, type }) => {
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
-    const answerNode = getAnswerNode({ A, AC, AD, B, BC, BD, type });
+    const answerNode = getAnswerNode(identifiers);
     while (propositions.length < n) {
         const wrongAnswer = (0, multiplyNode_1.multiply)(answerNode, (0, randint_1.randint)(2, 11)).simplify();
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { answer, A, AC, AD, B, BC, BD, type }, opts) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
-        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-        if (!parsed)
-            return false;
-        const simplified = parsed.simplify();
-        if (opts?.allowApproximate) {
-            const rank = ["dixième", "centième", "millième"].indexOf(opts.allowApproximate);
-            return (answer === simplified.toTex() ||
-                simplified.evaluate() ===
-                    (0, round_1.round)(getAnswerNode({ type, A, AC, AD, B, BC, BD }).evaluate(), rank + 1));
-        }
-        return answer === simplified.toTex();
-        // const answer = getAnswerNode({ type, A, AC, AD, B, BC, BD });
-        // const texs = answer.toTree({ allowFractionToDecimal: true }).toAllValidTexs();
+        const rank = opts?.allowApproximate
+            ? ["dixième", "centième", "millième"].indexOf(opts.allowApproximate) + 1
+            : undefined;
+        return (0, rationalVEA_1.rationalVEA)(ans, answer, {
+            allowNonIrreductible: true,
+            allowDecimal: true,
+            decimalPrecision: rank,
+        });
     }
     catch (err) {
         return false;
@@ -147,25 +242,31 @@ const options = [
         label: "Autoriser les valeurs approchées au : ",
         target: exercise_1.GeneratorOptionTarget.vea,
         type: exercise_1.GeneratorOptionType.select,
-        defaultValue: "centieme",
+        defaultValue: "centième",
         values: ["dixième", "centième", "millième"],
     },
+    {
+        id: "eventTypes",
+        label: "Types de questions",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.multiselect,
+        defaultValue: defaultOptionValues,
+        values: optionValues,
+    },
+    {
+        id: "probaType",
+        label: "Format des probabilités",
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.select,
+        defaultValue: "Fractions",
+        values: ["Fractions", "Décimales"],
+    },
 ];
 exports.probabilityTree = {
     id: "probabilityTree",
     connector: "=",
     label: "Calculs de probabilités à l'aide d'un arbre pondéré",
-    levels: [
-        "2nde",
-        "1reESM",
-        "1reSpé",
-        "1reTech",
-        "1rePro",
-        "TermPro",
-        "TermTech",
-    ],
     isSingleStep: false,
-    sections: ["Probabilités"],
     generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -174,4 +275,7 @@ exports.probabilityTree = {
     hasGeogebra: true,
     subject: "Mathématiques",
     options,
+    rebuildIdentifiers,
+    getInstruction,
+    getAnswer,
 };

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}
+{"version":3,"file":"spaceVectorNormCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorNormCalculation.js

@@ -10,11 +10,11 @@ const addNode_1 = require("../../../../tree/nodes/operators/addNode");
 const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const getHint = (identifiers) => {
-    return "La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées.";
+    return "Dans un repère dans l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées.";
 };
 const getCorrection = ({ x, y, z }) => {
     const answer = getAnswer({ x, y, z });
-    return `La norme d'un vecteur de l'espace est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
+    return `Dans un repère de l'espace orthonormé, la norme d'un vecteur  est la racine carrée de la somme des carrés de ses coordonnées. Ici, on a donc : 
  
 ${(0, alignTex_1.alignTex)([
         [
@@ -35,7 +35,11 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const u = new spaceVector_1.SpaceVector("u", identifiers.x.toTree(), identifiers.y.toTree(), identifiers.z.toTree());
-    return `Cacluler la norme du vecteur $${u.toTexWithCoords()}$`;
+    return `On se place dans un repère de l'espace orthonormé. Calculer la norme du vecteur : 
+
+$$
+${u.toTexWithCoords()}
+$$`;
 };
 const getSpaceVectorNormCalculationQuestion = () => {
     const u = spaceVector_1.SpaceVectorConstructor.random("u", false);

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

@@ -1,2 +1,8 @@
-export declare const rationalVEA: (studentAns: string, answer: string) => boolean;
+type Opts = {
+    allowNonIrreductible?: boolean;
+    allowDecimal?: boolean;
+    decimalPrecision?: number;
+};
+export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal }?: Opts) => boolean;
+export {};
 //# sourceMappingURL=rationalVEA.d.ts.map

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,YAS7D,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAKA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,eACV,MAAM,UACV,MAAM,6DAC4C,IAAI,YAqC/D,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,16 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rationalVEA = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const latexParser_1 = require("../../tree/parsers/latexParser");
 const rationalParser_1 = require("../../tree/parsers/rationalParser");
-//return true if studentAns is a number or rational, and if it evaluates to answer
-const rationalVEA = (studentAns, answer) => {
+const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
+    allowNonIrreductible: true,
+    decimalPrecision: undefined,
+    allowDecimal: true,
+}) => {
+    allowDecimal = allowDecimal ?? true;
+    allowNonIrreductible = allowNonIrreductible ?? true;
+    decimalPrecision = decimalPrecision ?? undefined;
     const parsed = (0, rationalParser_1.rationalParser)(studentAns);
     if (!parsed)
         return false;
     try {
         const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
-        return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        if ((0, numberNode_1.isNumberNode)(parsed)) {
+            if (!allowDecimal)
+                return false;
+            if (decimalPrecision === undefined)
+                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001);
+            else {
+                //! accepte bien les arrondis au centième par ex, mais va aussi accepter les arrondis au millième
+                //! je juge ca ok
+                return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                    Math.pow(10, -decimalPrecision - 1));
+            }
+        }
+        else if (allowNonIrreductible) {
+            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+        }
+        else {
+            //parsed est une fraction ou opposite(frac)
+            return parsed.equals(parsedAnswer);
+        }
     }
     catch (err) {
         return false;

package/lib/index.d.ts

@@ -35,6 +35,7 @@ declare const mathExercises: (Exercise<{
 }, {
     allowNonIrreductible?: boolean | undefined;
 }> | Exercise<{
+    isIntegerFirst: boolean;
     integer: number;
     rational: [number, number];
 }, {
@@ -1327,15 +1328,17 @@ declare const mathExercises: (Exercise<{
     nbFaces: number;
     faceAsked: number;
 }, {}> | Exercise<{
-    type: number;
-    A: number;
-    B: number;
-    AC: number;
-    AD: number;
-    BC: number;
-    BD: number;
+    A: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    B: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    AD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BC: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    BD: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    probaName: string;
 }, {
     allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 }> | Exercise<{
     randomValues: number[];
     randomEffectives: 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/complex/complex.d.ts

@@ -18,7 +18,7 @@ export declare class Complex {
     times(n: number): Complex;
     opposite(): Complex;
     conjugate(): Complex;
-    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | FractionNode | OppositeNode | undefined;
+    toArgumentTree(): NumberNode | import("../../tree/nodes/numbers/constantNode").ConstantNode | OppositeNode | FractionNode | undefined;
     toModuleTree(): import("../../tree/nodes/algebraicNode").AlgebraicNode;
     toTree(): ComplexNode;
 }

package/lib/math/numbers/rationals/rational.d.ts

@@ -28,7 +28,7 @@ export declare class Rational implements Nombre {
     reverse(shouldSimplify: boolean): Nombre;
     divide(nb: Nombre): Nombre;
     opposite(): Rational;
-    toTree(opts?: NodeOptions): FractionNode | OppositeNode;
+    toTree(opts?: NodeOptions): OppositeNode | FractionNode;
     isIrreductible(): boolean;
     simplify(): Integer | Rational;
 }

package/lib/math/numbers/reals/extendedRingElement.d.ts

@@ -13,6 +13,6 @@ export declare class ExtendedRingElement {
     b: number;
     algebraicElement: Nombre;
     constructor(a: number, b: number, algebraicElement: Nombre);
-    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | OppositeNode | MultiplyNode | AddNode | SubstractNode;
+    toTree(): import("../../../tree/nodes/algebraicNode").AlgebraicNode | NumberNode | SubstractNode | AddNode | OppositeNode | MultiplyNode;
 }
 //# sourceMappingURL=extendedRingElement.d.ts.map

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

@@ -5,6 +5,6 @@ export declare class GeneralAffine {
     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;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
 }
 //# sourceMappingURL=generalAffine.d.ts.map

package/lib/math/polynomials/generalTrinom.d.ts

@@ -51,7 +51,7 @@ export declare class GeneralTrinom {
     constructor(a: AlgebraicNode | number, b: AlgebraicNode | number, c: AlgebraicNode | number, opts?: GeneralTrinomOptions);
     getDelta(): AlgebraicNode;
     getRoots(): AlgebraicNode[];
-    toTree(): import("../../tree/nodes/operators/multiplyNode").MultiplyNode | import("../../tree/nodes/operators/addNode").AddNode;
+    toTree(): import("../../tree/nodes/operators/addNode").AddNode | import("../../tree/nodes/operators/multiplyNode").MultiplyNode;
     toTex(): string;
     getCoeffs(): number[];
     toIdentifiers(): GeneralTrinomIdentifiers;

package/lib/math/polynomials/trinom.d.ts

@@ -65,11 +65,11 @@ export declare class Trinom extends Polynomial {
     getRootsNode(): AlgebraicNode[];
     getRootsEquationSolutionTex(): string;
     getAlpha(): number;
-    getAlphaNode(): NumberNode | FractionNode | OppositeNode;
+    getAlphaNode(): NumberNode | OppositeNode | FractionNode;
     getBeta(): number;
-    getBetaNode(): NumberNode | FractionNode | OppositeNode;
+    getBetaNode(): NumberNode | OppositeNode | FractionNode;
     getFactorizedForm(): AlgebraicNode | MultiplyNode;
-    getCanonicalForm(): MultiplyNode | AddNode;
+    getCanonicalForm(): AddNode | MultiplyNode;
     getSommet(): Point;
     getCoords(): number[];
     toPython(): string;

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
+const affineParser_1 = require("./tree/parsers/affineParser");
 const playground = () => {
-    // logIdentifiers();
-    // const parsed = parseLatex("x\\times +3");
-    // console.log(parsed.toTex());
+    console.log((0, affineParser_1.affineParser)("8"));
 };
 exports.playground = playground;
 const logIdentifiers = () => {

package/lib/prototypesEnhancement.d.ts

@@ -1,8 +1,10 @@
 import { AlgebraicNode } from "./tree/nodes/algebraicNode";
 import { NodeOptions } from "./tree/nodes/node";
+import { ConstantNode } from "./tree/nodes/numbers/constantNode";
+import { NumberNode } from "./tree/nodes/numbers/numberNode";
 declare global {
     interface Number {
-        toTree: (opts?: NodeOptions) => AlgebraicNode;
+        toTree: (opts?: NodeOptions) => NumberNode | ConstantNode;
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }

package/lib/prototypesEnhancement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAStD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,aAAa,CAAC;QAC9C,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}
+{"version":3,"file":"prototypesEnhancement.d.ts","sourceRoot":"","sources":["../src/prototypesEnhancement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAQ,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAKjE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAI7D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,WAAW,KAAK,UAAU,GAAG,YAAY,CAAC;QAC1D,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;IACD,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,WAAW,EAAE,MAAM,MAAM,CAAC;KAC3B;CACF;AAqBD,OAAO,EAAE,CAAC"}

package/lib/tree/nodes/functions/absNode.d.ts

@@ -18,7 +18,7 @@ export declare class AbsNode implements FunctionNode {
     toTex(): string;
     toEquivalentNodes(): AlgebraicNode[];
     toAllValidTexs(): string[];
-    simplify(): AlgebraicNode | AbsNode;
+    simplify(): AlgebraicNode | import("../numbers/numberNode").NumberNode | import("../numbers/constantNode").ConstantNode | AbsNode;
     evaluate(vars?: Record<string, number>): number;
     equals(node: AlgebraicNode): boolean;
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): AbsNode;

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

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

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

@@ -14,6 +14,7 @@ const numberNode_1 = require("../numbers/numberNode");
 const multiplyNode_1 = require("./multiplyNode");
 const fractionNode_1 = require("./fractionNode");
 const colorize_1 = require("../../../utils/latex/colorize");
+const round_1 = require("../../../math/utils/round");
 function isAddNode(a) {
     return (0, operatorNode_1.isOperatorNode)(a) && a.id === operatorNode_1.OperatorIds.add;
 }
@@ -203,7 +204,7 @@ class AddNode {
                 return new fractionNode_1.FractionNode(new AddNode(new oppositeNode_1.OppositeNode(c), new multiplyNode_1.MultiplyNode(d, a)), d).simplify(opts);
             }
             if ((0, numberNode_1.isNumberNode)(a) && (0, numberNode_1.isNumberNode)(b)) {
-                return new numberNode_1.NumberNode(a.value + b.value);
+                return new numberNode_1.NumberNode((0, round_1.round)(a.value + b.value, 12));
             }
             if ((0, oppositeNode_1.isOppositeNode)(a) && (0, numberNode_1.isNumberNode)(a.child) && (0, numberNode_1.isNumberNode)(b)) {
                 return new numberNode_1.NumberNode(-a.child.value + b.value);

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

@@ -1,8 +1,14 @@
 import { Node, NodeIds, NodeOptions, NodeType } from "../node";
 import { OperatorIds, OperatorNode } from "./operatorNode";
 import { AlgebraicNode, SimplifyOptions } from "../algebraicNode";
+import { NodeIdentifiers } from "../nodeConstructor";
 export declare function isFractionNode(a: Node): a is FractionNode;
 export declare const frac: (a: AlgebraicNode | number | string, b: AlgebraicNode | number | string, opts?: NodeOptions) => FractionNode;
+export type FractionNodeIdentifiers = {
+    id: NodeIds.fraction;
+    leftChild: NodeIdentifiers;
+    rightChild: NodeIdentifiers;
+};
 export declare class FractionNode implements OperatorNode {
     opts?: NodeOptions;
     /**
@@ -16,18 +22,11 @@ export declare class FractionNode implements OperatorNode {
     isNumeric: boolean;
     constructor(leftChild: AlgebraicNode, rightChild: AlgebraicNode, opts?: NodeOptions);
     toMathString(): string;
-    toIdentifiers(): {
-        id: NodeIds;
-        leftChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-        rightChild: {
-            id: NodeIds;
-        } & Record<string, any>;
-    };
+    toIdentifiers(): FractionNodeIdentifiers;
     toInversed(): FractionNode;
     toEquivalentNodes(opts?: NodeOptions): AlgebraicNode[];
     toAllValidTexs(opts?: NodeOptions): string[];
+    isDecimal(): boolean;
     toTex(): string;
     evaluate(vars?: Record<string, number>): number;
     simplify(opts?: SimplifyOptions): AlgebraicNode;

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

@@ -1 +1 @@
-{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa;;;;;;;;;IAQb,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAI5C,KAAK,IAAI,MAAM;IAsBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;CAQvB"}
+{"version":3,"file":"fractionNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/fractionNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAK3E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,IAAI,MACZ,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAC,QAAQ,CAAC;IACrB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AACF,qBAAa,YAAa,YAAW,YAAY;IAC/C,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAiBpB,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,uBAAuB;IAQxC,UAAU;IAGV,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IA+BpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,SAAS;IAUT,KAAK,IAAI,MAAM;IAsBf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAyJ/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;CAQvB"}

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

@@ -77,6 +77,21 @@ class FractionNode {
     toAllValidTexs(opts) {
         return this.toEquivalentNodes(opts).map((node) => node.toTex());
     }
+    isDecimal() {
+        if (!(0, numberNode_1.isNumberNode)(this.leftChild))
+            return false;
+        if (!(0, numberNode_1.isNumberNode)(this.rightChild))
+            return false;
+        const simp = this.simplify();
+        if ((0, numberNode_1.isNumberNode)(simp))
+            return true;
+        let denum = simp.leftChild.evaluate();
+        while (denum % 2 === 0)
+            denum = denum / 2;
+        while (denum % 5 === 0)
+            denum = denum / 5;
+        return denum === 1;
+    }
     toTex() {
         if (!this.opts?.allowMinusAnywhereInFraction &&
             ((0, oppositeNode_1.isOppositeNode)(this.leftChild) ||

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

@@ -1,3 +1,2 @@
-import { Affine } from "../../math/polynomials/affine";
-export declare const affineParser: (ans: string, variable?: string) => false | import("../nodes/variables/variableNode").VariableNode | Affine | undefined;
+export declare const affineParser: (ans: string, variable?: string) => false | import("../nodes/algebraicNode").AlgebraicNode | import("../nodes/operators/substractNode").SubstractNode | import("../nodes/operators/addNode").AddNode;
 //# sourceMappingURL=affineParser.d.ts.map

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,wFAqBzD,CAAC"}
+{"version":3,"file":"affineParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/affineParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,qKAqBzD,CAAC"}

package/lib/tree/parsers/affineParser.js

@@ -1,31 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.affineParser = void 0;
-const affine_1 = require("../../math/polynomials/affine");
-const numberNode_1 = require("../nodes/numbers/numberNode");
-const multiplyNode_1 = require("../nodes/operators/multiplyNode");
-const variableNode_1 = require("../nodes/variables/variableNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
 const latexParser_1 = require("./latexParser");
+const monomParser_1 = require("./monomParser");
 const affineParser = (ans, variable = "x") => {
     try {
+        const monom = (0, monomParser_1.monomParser)(ans, { variable, maxDegree: 1 });
+        if (monom)
+            return monom;
         const parsed = (0, latexParser_1.parseAlgebraic)(ans);
-        if ((0, variableNode_1.isVariableNode)(parsed)) {
-            if (parsed.name !== variable)
+        if ((0, addNode_1.isAddNode)(parsed) || (0, substractNode_1.isSubstractNode)(parsed)) {
+            const numericChild = parsed.leftChild.isNumeric
+                ? "left"
+                : parsed.rightChild.isNumeric
+                    ? "right"
+                    : undefined;
+            if (!numericChild)
                 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);
-            }
+            const varChild = numericChild === "left" ? parsed.rightChild : parsed.leftChild;
+            return (0, monomParser_1.isMonomNode)(varChild, { variable, maxDegree: 1 }) ? parsed : false;
         }
+        return false;
     }
     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 | InequationNode | EqualNode;
+export declare const parseLatex: (latex: string) => AlgebraicNode | EqualNode | InequationNode;
 //# sourceMappingURL=latexParser.d.ts.map

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

@@ -1,2 +1,10 @@
-export declare const monomParser: (str: string) => void;
+import { AlgebraicNode } from "../nodes/algebraicNode";
+type Opts = {
+    variable: string;
+    maxDegree?: number;
+    minDegree?: number;
+};
+export declare const monomParser: (str: string, { variable, maxDegree, minDegree }?: Opts) => false | AlgebraicNode;
+export declare const isMonomNode: (node: AlgebraicNode, { variable, maxDegree, minDegree }?: Opts) => boolean;
+export {};
 //# sourceMappingURL=monomParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,QAAS,MAAM,SAAO,CAAC"}
+{"version":3,"file":"monomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/monomParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAQvD,KAAK,IAAI,GAAG;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,WAAW,QACjB,MAAM,uCACyB,IAAI,0BAkBzC,CAAC;AAEF,eAAO,MAAM,WAAW,SAChB,aAAa,uCACiB,IAAI,YAsCzC,CAAC"}

package/lib/tree/parsers/monomParser.js

@@ -1,5 +1,68 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.monomParser = void 0;
-const monomParser = (str) => { };
+exports.isMonomNode = exports.monomParser = void 0;
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+const latexParser_1 = require("./latexParser");
+const monomParser = (str, { variable, maxDegree, minDegree } = {
+    variable: "x",
+    maxDegree: undefined,
+    minDegree: 0,
+}) => {
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(str);
+        return (0, exports.isMonomNode)(parsed, { variable, maxDegree, minDegree })
+            ? parsed
+            : false;
+        if ((0, fractionNode_1.isFractionNode)(parsed)) {
+            //!unimplemented
+            return false;
+        }
+        else
+            return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
 exports.monomParser = monomParser;
+const isMonomNode = (node, { variable, maxDegree, minDegree } = {
+    variable: "x",
+    maxDegree: undefined,
+    minDegree: 0,
+}) => {
+    variable = variable ?? "x";
+    maxDegree = maxDegree ?? undefined;
+    minDegree = minDegree ?? 0;
+    if (node.isNumeric && minDegree === 0)
+        return true;
+    if ((0, variableNode_1.isVariableNode)(node) && node.name === variable && minDegree < 2)
+        return true;
+    if ((0, multiplyNode_1.isMultiplyNode)(node)) {
+        const numericChild = node.leftChild.isNumeric
+            ? "left"
+            : node.rightChild.isNumeric
+                ? "right"
+                : undefined;
+        if (!numericChild)
+            return false;
+        const varChild = numericChild === "left" ? node.rightChild : node.leftChild;
+        if ((0, variableNode_1.isVariableNode)(varChild) && varChild.name === "x" && minDegree < 2)
+            return true;
+        if ((0, powerNode_1.isPowerNode)(varChild) &&
+            (0, variableNode_1.isVariableNode)(varChild.leftChild) &&
+            varChild.leftChild.name === "x" &&
+            varChild.rightChild.isNumeric) {
+            const powerEv = varChild.rightChild.evaluate();
+            if (maxDegree && powerEv > maxDegree)
+                return false;
+            if (minDegree && powerEv < minDegree)
+                return false;
+            return true;
+        }
+    }
+    return false;
+};
+exports.isMonomNode = isMonomNode;

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

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

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

@@ -0,0 +1,9 @@
+/**
+ * supprime les éléments superflus sans aucun calcul maths
+ * ex : transforme (2) en 2
+ * ex : transforme (9)/3 en 9/3 mais pas en 3
+ * doit-il transformer 1*x en x ?
+ * @param str réponse élève
+ */
+export declare const purifyLatex: (str: string) => void;
+//# sourceMappingURL=purifyLatex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"purifyLatex.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/purifyLatex.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,MAAM,SAKtC,CAAC"}

package/lib/tree/parsers/purifyLatex.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purifyLatex = void 0;
+/**
+ * supprime les éléments superflus sans aucun calcul maths
+ * ex : transforme (2) en 2
+ * ex : transforme (9)/3 en 9/3 mais pas en 3
+ * doit-il transformer 1*x en x ?
+ * @param str réponse élève
+ */
+const purifyLatex = (str) => {
+    //on peut supprimer des parenthèses si :
+    //* pas suivi/précédé d'une multiplication
+    //* pas arguments d'une fonction
+    //* .. ?
+};
+exports.purifyLatex = purifyLatex;

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

@@ -1,3 +1,3 @@
 import { FractionNode } from "../nodes/operators/fractionNode";
-export declare const rationalParser: (ans: string) => false | import("../nodes/algebraicNode").AlgebraicNode | FractionNode | import("../nodes/functions/oppositeNode").OppositeNode | undefined;
+export declare const rationalParser: (ans: string) => false | import("../nodes/numbers/numberNode").NumberNode | import("../nodes/numbers/constantNode").ConstantNode | import("../nodes/functions/oppositeNode").OppositeNode | FractionNode | undefined;
 //# sourceMappingURL=rationalParser.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAQ,MAAM,iCAAiC,CAAC;AAGrE,eAAO,MAAM,cAAc,QAAS,MAAM,+IA0BzC,CAAC"}
+{"version":3,"file":"rationalParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/rationalParser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAQ,MAAM,iCAAiC,CAAC;AAGrE,eAAO,MAAM,cAAc,QAAS,MAAM,wMA0BzC,CAAC"}

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

@@ -0,0 +1,2 @@
+export declare const trinomParser: (ans: string, variable?: string) => false | undefined;
+//# sourceMappingURL=trinomParser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trinomParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/trinomParser.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,YAAY,QAAS,MAAM,aAAY,MAAM,sBAyBzD,CAAC"}

package/lib/tree/parsers/trinomParser.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trinomParser = void 0;
+const trinomParser = (ans, variable = "x") => {
+    try {
+        //! difficile !
+        //! peut etre que je fais fausse, il faut peut etre simplifier canoniquement et checker si ca ressemble à un trinome
+        //! mais ce qui m'embete dans cette approche c'est que la simplification va etre trop "gentille", on va accepter des trucs qu'on aurait pas du ...
+        // const monom = monomParser(ans, { variable, maxDegree: 2, minDegree: 2 });
+        // if (monom) return monom;
+        // const parsed = parseAlgebraic(ans);
+        // if (isAddNode(parsed) || isSubstractNode(parsed)) {
+        //   const numericChild = parsed.leftChild.isNumeric
+        //     ? "left"
+        //     : parsed.rightChild.isNumeric
+        //     ? "right"
+        //     : undefined;
+        // //si numeric : alors ax^2 + b ou ax+b
+        // //sinon : ax^2 + bx + c car monom déjà exclu
+        //   if (!numericChild) return false;
+        //   const varChild =
+        //     numericChild === "left" ? parsed.rightChild : parsed.leftChild;
+        //   return isMonomNode(varChild, { variable, maxDegree: 1 }) ? parsed : false;
+        // }
+        // return false;
+    }
+    catch (err) {
+        return false;
+    }
+};
+exports.trinomParser = trinomParser;

package/package.json

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