math-exercises 2.2.93 → 2.2.94

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

@@ -23,7 +23,11 @@ const getInstruction = ({ isPercentToDecimal, nb, }) => {
     const instru = isPercentToDecimal ? percentTex : tex;
     return `Ecrire le nombre suivant ${isPercentToDecimal
         ? "sous forme de nombre décimal"
-        : "sous forme de pourcentage"} : $${instru}$`;
+        : "sous forme de pourcentage"} : 
+  
+$$
+${instru}
+$$`;
 };
 const getHint = ({ isPercentToDecimal }) => {
     return `${isPercentToDecimal
@@ -64,7 +68,7 @@ const getPercentToDecimalQuestion = () => {
     const nb = percentNb.times(0.01);
     const identifiers = {
         isPercentToDecimal,
-        nb: nb.value,
+        nb: (0, round_1.round)(nb.value, 10),
     };
     const question = {
         answer: getAnswer(identifiers),

package/lib/exercises/math/percent/percentWritings.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    percent: number;
+    target: "decimalToPercent" | "fractionToPercent" | "percentToDecimal" | "percentToFraction";
+};
+export declare const percentWritings: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=percentWritings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"percentWritings.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentWritings.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EACF,kBAAkB,GAClB,mBAAmB,GACnB,kBAAkB,GAClB,mBAAmB,CAAC;CACzB,CAAC;AA0IF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC"}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.percentWritings = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const numberVEA_1 = require("../../../exercises/vea/numberVEA");
+const rationalVEA_1 = require("../../../exercises/vea/rationalVEA");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const percentParser_1 = require("../../../tree/parsers/percentParser");
+const random_1 = require("../../../utils/alea/random");
+const getPropositions = (n, { answer, percent, target }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    switch (target) {
+        case "decimalToPercent":
+            break;
+        case "fractionToPercent":
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(percent / 10, 5).frenchify() + "\\%");
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(percent / 100, 5).frenchify() + "\\%");
+            break;
+        case "percentToDecimal":
+            break;
+        case "percentToFraction":
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)(100, percent).toTex());
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)(percent, 10).toTex());
+            (0, exercise_1.tryToAddWrongProp)(propositions, (0, fractionNode_1.frac)((0, round_1.round)(percent / 100, 5), 100).toTex());
+            break;
+    }
+    while (propositions.length < n) {
+        switch (target) {
+            case "decimalToPercent":
+                break;
+            case "fractionToPercent":
+                break;
+            case "percentToDecimal":
+                break;
+            case "percentToFraction":
+                (0, exercise_1.tryToAddWrongProp)(propositions, rational_1.RationalConstructor.randomIrreductible().toTree().toTex());
+                break;
+        }
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { percent, target } = identifiers;
+    const dec = (0, round_1.round)(percent / 100, 4).frenchify();
+    const fraction = (0, fractionNode_1.frac)(percent, 100).toTex();
+    switch (target) {
+        case "decimalToPercent":
+        case "fractionToPercent":
+            return percent + "\\%";
+        case "percentToDecimal":
+            return dec;
+        case "percentToFraction":
+            return fraction;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { percent, target } = identifiers;
+    const dec = (0, round_1.round)(percent / 100, 4).frenchify();
+    const fraction = (0, fractionNode_1.frac)(percent, 100).toTex();
+    const nb = target === "decimalToPercent"
+        ? dec
+        : target === "fractionToPercent"
+            ? fraction
+            : percent + "\\%";
+    const targetType = target === "percentToDecimal"
+        ? "nombre décimal"
+        : target === "percentToFraction"
+            ? "fraction"
+            : "pourcentage";
+    return `Écrire le nombre $${nb}$ sous forme de ${targetType}.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer, percent, target }) => {
+    try {
+        switch (target) {
+            case "decimalToPercent":
+            case "fractionToPercent":
+                return (0, percentParser_1.percentParser)(ans) === answer;
+            case "percentToDecimal":
+                return (0, numberVEA_1.numberVEA)(ans, answer);
+            case "percentToFraction":
+                return (0, rationalVEA_1.rationalVEA)(ans, answer);
+        }
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getPercentWritingsQuestion = (ops) => {
+    const percent = (0, randint_1.randint)(1, 150);
+    const target = (0, random_1.random)([
+        "decimalToPercent",
+        "fractionToPercent",
+        "percentToDecimal",
+        "percentToFraction",
+    ]);
+    const identifiers = {
+        percent,
+        target,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.percentWritings = {
+    id: "percentWritings",
+    connector: "=",
+    label: "Passer d'une écriture de pourcentage à une autre",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPercentWritingsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAczC,CAAC"}
+{"version":3,"file":"ttcToHT.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/ttcToHT.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AA6EF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAkBzC,CAAC"}

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

@@ -9,18 +9,22 @@ const round_1 = require("../../../math/utils/round");
 const numberParser_1 = require("../../../tree/parsers/numberParser");
 const coinFlip_1 = require("../../../utils/alea/coinFlip");
 const random_1 = require("../../../utils/alea/random");
-const getTtcToHtQuestion = () => {
-    const TVA = (0, random_1.random)([20, 5.5]);
-    const TTC = (0, coinFlip_1.coinFlip)() ? (0, randint_1.randint)(50, 1000) : (0, randfloat_1.randfloat)(20, 200, 2);
+const getInstruction = (identifiers) => {
+    const { TVA, TTC } = identifiers;
+    return `Un objet coûte $${TTC.frenchify()}€$ en TTC. Quel est son prix HT, sachant que la TVA est de $${TVA.frenchify()}\\%$ ? (arrondir au centième)`;
+};
+const getAnswer = (identifiers) => {
+    const { TVA, TTC } = identifiers;
     const answer = (0, round_1.round)(TTC / (1 + TVA / 100), 2).frenchify();
-    const question = {
-        answer,
-        instruction: `Un objet coûte $${TTC.frenchify()}€$ en TTC. Quel est son prix HT, sachant que la TVA est de $${TVA.frenchify()}\\%$ ? (arrondir au centième)`,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { TTC, TVA },
-        hint: `Pour retrouver le prix HT d'un objet après une hausse de $t\\%$, on divise le prix TTC par $1 + \\frac{t}{100}$.`,
-        correction: `Pour retrouver le prix HT après une hausse de  $${TVA.frenchify()}\\%$, on divise le prix TTC par :
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Pour retrouver le prix HT d'un objet après une hausse de $t\\%$, on divise le prix TTC par $1 + \\frac{t}{100}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { TVA, TTC } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `Pour retrouver le prix HT après une hausse de  $${TVA.frenchify()}\\%$, on divise le prix TTC par :
     
 $$
 1 + \\frac{${TVA.frenchify()}}{100} = ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()}
@@ -31,7 +35,20 @@ Le prix HT est donc :
 $$
 ${TTC.frenchify()} \\div ${(0, round_1.round)(1 + TVA / 100, 3).frenchify()} \\approx ${answer}
 $$
-`,
+`;
+};
+const getTtcToHtQuestion = () => {
+    const TVA = (0, random_1.random)([20, 5.5]);
+    const TTC = (0, coinFlip_1.coinFlip)() ? (0, randint_1.randint)(50, 1000) : (0, randfloat_1.randfloat)(20, 200, 2);
+    const identifiers = { TTC, TVA };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -62,4 +79,8 @@ exports.ttcToHT = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getAnswer,
 };

package/lib/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}
+{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.js

@@ -10,40 +10,66 @@ const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
 const variableNode_1 = require("../../../../tree/nodes/variables/variableNode");
 const alignTex_1 = require("../../../../utils/latex/alignTex");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const latexParser_1 = require("../../../../tree/parsers/latexParser");
+const getInstruction = (identifiers) => {
+    const { firstValue, reason, askedRank } = identifiers;
+    const formula = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), new variableNode_1.VariableNode("n")));
+    const formulaTex = formula.toTex();
+    return `$(u_n)$ est une suite géométrique définie par $u_n = ${formulaTex}$. Calculer : $u_{${askedRank}}$`;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason, askedRank } = identifiers;
+    const answer = (firstValue * Math.pow(reason, askedRank)).toString();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { askedRank } = identifiers;
+    return `Il suffit de remplacer $n$ par $${askedRank}$ dans la formule donnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstValue, reason, askedRank } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `On remplace $n$ par $${askedRank}$ dans la formule donnée : 
+    
+${(0, alignTex_1.alignTex)([
+        [
+            `u_{${askedRank}}`,
+            "=",
+            new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), askedRank.toTree())).toTex(),
+        ],
+        ["", "=", answer],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
 const getGeometricExplicitFormulaUsage = () => {
     const askedRank = (0, randint_1.randint)(0, 10);
     const firstValue = (0, randint_1.randint)(-5, 10, [0]);
     const reason = (0, randint_1.randint)(2, 10);
-    const formula = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), new variableNode_1.VariableNode("n")));
-    const formulaTex = formula.toTex();
-    const answer = (firstValue * Math.pow(reason, askedRank)).toString();
+    const identifiers = { firstValue, reason, askedRank };
     const question = {
-        instruction: `$(u_n)$ est une suite géométrique définie par $u_n = ${formulaTex}$. Calculer : $u_{${askedRank}}$`,
+        instruction: getInstruction(identifiers),
         startStatement: `u_{${askedRank}}`,
-        answer,
-        keys: ["u", "underscore", "equal"],
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
         answerFormat: "tex",
-        identifiers: { firstValue, reason, askedRank },
-        hint: `Il suffit de remplacer $n$ par $${askedRank}$ dans la formule donnée.`,
-        correction: `On remplace $n$ par $${askedRank}$ dans la formule donnée : 
-    
-${(0, alignTex_1.alignTex)([
-            [
-                `u_{${askedRank}}`,
-                "=",
-                new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(firstValue), new powerNode_1.PowerNode(new numberNode_1.NumberNode(reason), askedRank.toTree())).toTex(),
-            ],
-            ["", "=", answer],
-        ])}`,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
 const isAnswerValid = (ans, { answer, askedRank }) => {
-    return [
-        answer,
-        `u_{${askedRank}}=${answer}`,
-        `u_${askedRank}=${answer}`,
-    ].includes(ans);
+    try {
+        const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
 };
 const getPropositions = (n, { answer, firstValue, reason, askedRank }) => {
     const propositions = [];
@@ -67,4 +93,9 @@ exports.geometricExplicitFormulaUsage = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    getKeys,
 };

package/lib/index.d.ts

@@ -80,6 +80,9 @@ declare const mathExercises: (Exercise<{
     denom2: number;
 }, {}> | Exercise<{
     statementIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+}, {}> | Exercise<{
+    num: number;
+    denum: number;
 }, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -313,6 +316,11 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     a: number;
     b: number;
+    c?: number | undefined;
+    type: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1323,6 +1331,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     vd: number;
     percentRate: number;
+}, {}> | Exercise<{
+    type: number;
+    price: number;
+    evolution: number;
+    askingFinalPrice: boolean;
 }, {}> | Exercise<{
     int: number;
     power: number;

package/lib/index.d.ts.map

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

package/lib/playground.d.ts.map

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

package/lib/playground.js

@@ -2,18 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.playground = void 0;
 const nodeConstructor_1 = require("./tree/nodes/nodeConstructor");
-const playground = () => {
-    // const formated = "\\sqrt{5;4}";
-    // const elements = formated.split(";").map((e) => {
-    //   console.log(e);
-    //   const r = parseAlgebraic(e);
-    //   console.log(r.toTex());
-    //   return r;
-    // });
-    // console.log(elements.map((e) => e.toTex()));
-    // const p = parseAlgebraic("\\sqrt{3");
-    // console.log(p.toTex());
-};
+const playground = () => { };
 exports.playground = playground;
 const logIdentifiers = () => {
     const ids = '{"xA":-3,"yA":-2,"yPrimeA":{"id":31,"child":{"id":3,"leftChild":{"id":7,"value":3},"rightChild":{"id":7,"value":2}}},"trinomCoeffs":[0.3888888888888889,0.833333333333333,-3]}';

package/lib/tree/nodes/functions/oppositeNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAM/D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAgB,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,sFAMpB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAI/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"version":3,"file":"oppositeNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/functions/oppositeNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAM/D,OAAO,EAAE,YAAY,EAAE,YAAY,EAAkB,MAAM,gBAAgB,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAgB,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAMlE,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,sFAMpB,CAAC;AAEF,qBAAa,YAAY,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,CAC/D,YAAW,YAAY,CAAC,CAAC,CAAC;IAE1B,EAAE,EAAE,YAAY,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;IACT,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;gBACP,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;IAQxC,aAAa;;;;;;IAMb,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAef,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,aAAa,EAAE;IAgCtD;;;;OAIG;IACH,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAQ5C,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAGtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAK/B,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAGxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -82,7 +82,7 @@ class OppositeNode {
     }
     simplify(opts) {
         if ((0, numberNode_1.isNumberNode)(this.child))
-            return new numberNode_1.NumberNode(-this.child.value);
+            return new numberNode_1.NumberNode(-this.child.value).simplify(opts);
         return new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(-1), this.child).simplify(opts);
     }
     equals(node) {

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,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAKrD,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;IA2Bf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAgN/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}
+{"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;AAKrD,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;IA2Bf,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAMtC,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAkN/C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAOpC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAOxD,sBAAsB;IAQtB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAGxD"}

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

@@ -218,7 +218,8 @@ class FractionNode {
             }
             if (opts?.forceIsolateMonomCoeffs && (0, numberNode_1.isNumberNode)(denum)) {
                 if ((0, variableNode_1.isVariableNode)(num)) {
-                    return new multiplyNode_1.MultiplyNode(new FractionNode(new numberNode_1.NumberNode(1), denum), num).simplify(opts);
+                    //!do not simplify elsewise infinite loop
+                    return new multiplyNode_1.MultiplyNode(new FractionNode(new numberNode_1.NumberNode(1), denum), num);
                 }
                 // if (isMultiplyNode(num)) {
                 //   if (isVariableNode(num.leftChild)) {

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

@@ -1 +1 @@
-{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAY,MAAM,+BAA+B,CAAC;AAI1E,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAqB5C,CAAC"}
+{"version":3,"file":"discreteSetParser.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/discreteSetParser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,eAAe,EAAY,MAAM,+BAA+B,CAAC;AAI1E,eAAO,MAAM,iBAAiB,QAAS,MAAM,4BAmB5C,CAAC"}

package/lib/tree/parsers/discreteSetParser.js

@@ -15,9 +15,7 @@ const discreteSetParser = (str) => {
         if (formated === "\\varnothing") {
             return discreteSetNode_1.EmptySet;
         }
-        console.log(formated);
         const elements = formated.split(";").map((e) => (0, latexParser_1.parseAlgebraic)(e));
-        console.log(elements.map((e) => e.toTex()));
         if (elements.some((e) => !e))
             return false;
         return new discreteSetNode_1.DiscreteSetNode(elements);

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;AAMzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AA6DrE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA2CrC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,UAAW,MAAM,SAAS,aAAa,kBAyBjE,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;AAMzD,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAgErE,eAAO,MAAM,QAAQ,UAAW,MAAM,aA2CrC,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AACF,eAAO,MAAM,cAAc,UAAW,MAAM,SAAS,aAAa,kBA0BjE,CAAC;AAEF,eAAO,MAAM,UAAU,UAAW,MAAM,+CA6CvC,CAAC"}

package/lib/tree/parsers/latexParser.js

@@ -41,7 +41,11 @@ const separators = ["=", "<", ">", "\\leq", "\\geq"];
 //le nombre de parentheses est il respecté
 const isDyck = (tokens) => {
     const brackets = tokens.filter((el) => el === "(" || el === ")");
+    let counter = 0;
     while (brackets.length) {
+        counter++;
+        if (counter > 1000)
+            throw Error("Too many iterations");
         const rightIndex = brackets.findIndex((el) => el == ")");
         if (rightIndex === -1 || rightIndex === 0)
             return false;
@@ -103,6 +107,7 @@ const tokenize = (latex) => {
 };
 exports.tokenize = tokenize;
 const parseAlgebraic = (latex, opts) => {
+    // console.log("parsingAlg ", latex);
     let formatedLatex = latex;
     if (!opts?.allowStartingPower && latex.startsWith("^")) {
         if (latex[1] === "{") {
@@ -133,6 +138,7 @@ const parseAlgebraic = (latex, opts) => {
 };
 exports.parseAlgebraic = parseAlgebraic;
 const parseLatex = (latex) => {
+    // console.log("parsingLatex ", latex);
     const formattedLatex = latex
         .replaceAll("\\left", "")
         .replaceAll("\\right", "");
@@ -204,12 +210,18 @@ const buildTree = (tokens) => {
     //?    -> 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)))
+    let counter = 0;
     while (true) {
+        counter++;
+        if (counter > 1000)
+            throw Error("Too many iterations");
         if (maxDepth === 0) {
             const tree = buildTreeForSameDepthTokens(depthedTokens.map((el) => el.token));
             return tree;
         }
         for (let i = 0; i < depthedTokens.length; i++) {
+            if (i > 1000)
+                throw Error("Too many iterations");
             const token = depthedTokens[i];
             //? on commence par les tokens de depth max
             if (token.depth < maxDepth)

package/package.json

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