math-exercises 3.0.71 → 3.0.73

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

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Nombre entier", "raw");
+    tryToAddWrongProp(propositions, "Nombre flottant", "raw");
+    tryToAddWrongProp(propositions, "Chaine de caractères", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { v, vType } = identifiers;
+    if (vType === "int") {
+        return "Nombre entier";
+    }
+    else if (vType === "float") {
+        return "Nombre flottant";
+    }
+    else if (vType === "str") {
+        return "Chaine de caractères";
+    }
+    else {
+        throw new Error(`Unknown type: ${vType}`);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { v, vType } = identifiers;
+    return `On exécute le script en Python ci-dessous :\n
+  \`\`\`python
+  v = ${vType === "str" ? `"${v}"` : v}
+  \`\`\`
+  \n
+  Quel est le type de la variable var ? 
+  `;
+};
+const getHint = (identifiers) => {
+    return "En Python, le type d'une variable peut être : un nombre entier, un nombre flottant (c'est à dire avec une virgule), ou une chaîne de caractère (c'est à dire un texte).";
+};
+const getCorrection = (identifiers) => {
+    const { v, vType } = identifiers;
+    let explanationType = "";
+    if (vType === "int") {
+        explanationType = "Nombre entier";
+    }
+    else if (vType === "float") {
+        explanationType = "Nombre flottant";
+    }
+    else if (vType === "str") {
+        explanationType = "Chaine de caractères";
+    }
+    return `En Python, le type d'une variable peut être : un nombre entier, un nombre flottant (c'est à dire avec une virgule), ou une chaîne de caractère (c'est à dire un texte).
+  
+Ici, la variable \`v\` est de type ${explanationType.toLocaleLowerCase()}.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getVariableTypeQuestion = (ops) => {
+    const vTypes = ["int", "float", "str"];
+    const vType = vTypes[randint(0, vTypes.length)];
+    let v;
+    if (vType === "int") {
+        v = randint(0, 100);
+    }
+    else if (vType === "float") {
+        v = randint(0, 100) + Math.random().toFixed(2);
+    }
+    else {
+        const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        const length = randint(3, 8);
+        let result = "";
+        for (let i = 0; i < length; i++) {
+            result += chars.charAt(randint(0, chars.length));
+        }
+        v = result;
+    }
+    const identifiers = { v, vType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const variableType = {
+    id: "variableType",
+    label: "Déterminer le type d’une variable en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVariableTypeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -17,7 +17,7 @@ const getAnswer = (identifiers) => {
 const getInstruction = (identifiers) => {
     const { a, initialValue, iterations, opIndex, step, x } = identifiers;
     const op = operations[opIndex];
-    return `Qu'affichera le programme suivant ?
+    return `Qu'affichera le programme suivant \`var\` ?
 \`\`\`
 a = ${a}
 n = ${initialValue}

package/lib/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}
+{"version":3,"file":"arithmeticExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticExplicitFormulaUsage.js

@@ -71,6 +71,7 @@ const getPropositions = (n, { answer, firstValue, askedRank, reason }) => {
 const isAnswerValid = (ans, { answer, askedRank }) => {
     return [
         answer,
+        `u${askedRank}=${answer}`,
         `u_${askedRank}=${answer}`,
         `u_{${askedRank}}=${answer}`,
     ].includes(ans);

package/lib/exercises/math/sequences/arithmetic/arithmeticFindReason.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"arithmeticFindReason.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindReason.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindReason.js

@@ -1,5 +1,6 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -63,7 +64,7 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
 export const arithmeticFindReason = {
     id: "arithmeticFindReason",

package/lib/exercises/math/sets/intervals/inequalityToInterval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AA6GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"inequalityToInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/inequalityToInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAwIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/sets/intervals/inequalityToInterval.js

@@ -41,6 +41,24 @@ const getInequalityToIntervalQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `
+- L'intervalle $[a;b]$ représente l'ensemble des nombres $x$ compris entre $a$ et $b$ inclus. 
+- L'intervalle $]a;b[$ représente l'ensemble des nombres $x$ compris entre $a$ et $b$ exclus.
+- L'intervalle $[a;b[$ représente l'ensemble des nombres $x$ compris entre $a$ inclus et $b$ exclus.
+- L'intervalle $]a;b]$ représente l'ensemble des nombres $x$ compris entre $a$ exclus et $b$ inclus.
+- L'intervalle $]-\\infty; b]$ représente l'ensemble des nombres inférieurs ou égaux à $b$.
+- L'intervalle $[a; +\\infty[$ représente l'ensemble des nombres supérieurs ou égaux à $a$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { intervalIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
+    const inequality = interval.toInequality();
+    return `Si $${inequality.toTex()}$, alors $x$ est ${interval.toText(true, false)}.
+  
+On a donc $${inequality.toTex()} \\iff ${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -59,6 +77,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -96,4 +116,5 @@ export const inequalityToInterval = {
     subject: "Mathématiques",
     rebuildIdentifiers,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sets/intervals/intervalToInequality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalToInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalToInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AA2FF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"intervalToInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalToInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAM/C,KAAK,WAAW,GAAG;IAIjB,mBAAmB,EAAE,uBAAuB,CAAC;CAC9C,CAAC;AAqHF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/sets/intervals/intervalToInequality.js

@@ -39,6 +39,23 @@ const getIntervalToInequalityQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `
+- L'intervalle $[a;b]$ représente l'ensemble des nombres $x$ compris entre $a$ et $b$ inclus. 
+- L'intervalle $]a;b[$ représente l'ensemble des nombres $x$ compris entre $a$ et $b$ exclus.
+- L'intervalle $[a;b[$ représente l'ensemble des nombres $x$ compris entre $a$ inclus et $b$ exclus.
+- L'intervalle $]a;b]$ représente l'ensemble des nombres $x$ compris entre $a$ exclus et $b$ inclus.
+- L'intervalle $]-\\infty; b]$ représente l'ensemble des nombres inférieurs ou égaux à $b$.
+- L'intervalle $[a; +\\infty[$ représente l'ensemble des nombres supérieurs ou égaux à $a$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { intervalIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(identifiers.intervalIdentifiers);
+    return `L'intervalle $${interval.toTex()}$ représente tous les nombres ${interval.toText(true, false)}.
+  
+On a donc $x\\in ${interval.toTex()} \\iff ${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -46,6 +63,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "inf", "sup", "geq", "leq", "infty"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -78,4 +97,5 @@ export const intervalToInequality = {
     subject: "Mathématiques",
     rebuildIdentifiers,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sets/intervals/intervalsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAOjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAoHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"intervalsUnion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAK/C,KAAK,WAAW,GAAG;IAOjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAwIF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/sets/intervals/intervalsUnion.js

@@ -73,6 +73,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["infty", "lbracket", "rbracket", "semicolon", "cup", "cap"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -101,6 +103,22 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const getCorrection = (identifiers) => {
+    const [int1, int2] = [
+        IntervalNodeConstructor.fromIdentifiers(identifiers.int1Identifiers),
+        IntervalNodeConstructor.fromIdentifiers(identifiers.int2Identifiers),
+    ];
+    const union = int1.union(int2);
+    const answer = union.toTex();
+    return `$I$ contient les nombres ${int1.toText(true, false)}. 
+    
+$J$ contient les nombres ${int2.toText(false, false)}.
+
+$I\\cup J$ contient donc l'ensemble de ces nombres : c'est à dire $I\\cup J = ${answer}$.`;
+};
+const getHint = (identifiers) => {
+    return `Détermine l'ensemble des nombres qui appartiennent à $I$ et/ou à $J$.`;
+};
 export const intervalsUnion = {
     id: "intervalsUnion",
     connector: "=",
@@ -114,4 +132,5 @@ export const intervalsUnion = {
     subject: "Mathématiques",
     rebuildIdentifiers,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sets/setBelonging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setBelonging.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/setBelonging.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}
+{"version":3,"file":"setBelonging.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/setBelonging.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

package/lib/exercises/math/sets/setBelonging.js

@@ -25,6 +25,27 @@ const getAnswer = (identifiers) => {
     }
     return "";
 };
+const getHint = (identifiers) => {
+    return `
+- $\\mathbb{N}$ est l'ensemble des nombres naturels (c'est à dire les nombres entiers positifs) ;
+- $\\mathbb{Z}$ est l'ensemble des nombres relatifs (c'est à dire les nombres entiers positifs et négatifs) ;
+- $\\mathbb{D}$ est l'ensemble des nombres décimaux (c'est à dire les nombres à virgule avec un nombre fini de chiffres après la virgule) 
+- $\\mathbb{Q}$ est l'ensemble des nombres rationnels (c'est à dire les fractions de numérateur et dénominateur entiers) 
+- $\\mathbb{R}$ est l'ensemble des nombres réels (c'est à dire l'ensemble des nombres qu'on peut placer sur une droite graduée) 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nb, type } = identifiers;
+    const sets = ["N", "Z", "D", "Q", "R"];
+    const labels = [
+        "nombre entier positif",
+        "nombre entier négatif",
+        "nombre décimal",
+        "nombre rationnel",
+        "nombre réel",
+    ];
+    return `$${nb}$ est un ${labels[type]}. On a donc $x \\in ${getAnswer(identifiers)}$.`;
+};
 const getIdentifiers = (prevIdentifiers) => {
     //N Z D Q R (racine2, pi)
     //fraction simplifiable en décimal/entier
@@ -68,6 +89,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
 };
 const getSetBelongingQuestion = () => {
@@ -105,4 +128,5 @@ export const setBelonging = {
     getAnswer,
     getQuestionFromIdentifiers,
     hotFix,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/chemicalElements/weightPercent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weightPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/weightPercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8IF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAY/C,CAAC"}
+{"version":3,"file":"weightPercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/weightPercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA6IF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAY/C,CAAC"}

package/lib/exercises/pc/chemicalElements/weightPercent.js

@@ -97,7 +97,6 @@ const getPropositions = (n, { answer, type, elWeight, percent, totalWeight }) =>
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, round(randfloat(1, 100), 1).frenchify() + (type === 3 ? "\\%" : "g"));
     }
-    console.log("done");
     return shuffleProps(propositions, n);
 };
 //m_A = P_A*m

package/lib/exercises/utils/getDistinctQuestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAC/B,MAAM,QACJ,MAAM,kBACI,CAAC,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,KAC1E,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAapB,CAAC"}
+{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAC/B,MAAM,QACJ,MAAM,kBACI,CAAC,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,KAC1E,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAkBpB,CAAC"}

package/lib/exercises/utils/getDistinctQuestions.js

@@ -21,10 +21,16 @@ export function equalTab(array1, array2) {
 export const getDistinctQuestions = (generator, nb, max, discriminator) => {
     const res = [];
     const trueStop = max === undefined ? nb : Math.min(nb, max);
+    const maxAttempts = 1000;
+    let attempts = 0;
     for (let i = 0; i < trueStop; i++) {
         let question;
         do {
             question = generator();
+            // Coupe si boucle probablement infinie
+            // (lorsque le nombre de questions possibles à générer est inférieur à `trueStop`)
+            if (attempts++ > maxAttempts)
+                throw Error("Possiblement pas assez de questions possibles à generer");
         } while (res.some((q) => compare(q, question, discriminator)));
         res.push(question);
     }

package/lib/index.d.ts

@@ -32,6 +32,41 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: number;
     b: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    isAskingParity: boolean;
+}, {}> | Exercise<{
+    n: number;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    x: number;
+    left: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    right: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    inequalitySign: boolean;
+}, {}> | Exercise<{
+    aLimit: number;
+    bLimit: number;
+    x: number;
+    y: number;
+    case: "lt" | "lte" | "lt_gt";
+    expressionToCheck: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    x: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    y: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+    func: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -102,6 +137,10 @@ declare const mathExercises: (Exercise<{
 }, {
     allowNonIrreductible?: boolean;
 }> | Exercise<{
+    a: number;
+    n: number;
+    isSimplified: boolean;
+}, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
     rand: number;
@@ -231,6 +270,8 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: number;
     sign: number;
+}, {}> | Exercise<{
+    n: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -350,6 +391,10 @@ declare const mathExercises: (Exercise<{
     b: number;
     c?: number;
     type: number;
+}, {}> | Exercise<{
+    a: number;
+    isSum: boolean;
+    b: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -409,6 +454,10 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     k: number;
     inequationSymbol: import("./math/inequations/inequation.js").InegalitySymbols;
+}, {}> | Exercise<{
+    a: number;
+    lt: boolean;
+    b: number;
 }, {}> | Exercise<{
     rand: boolean;
     poly1: number[];
@@ -524,6 +573,10 @@ declare const mathExercises: (Exercise<{
     hours: number;
     mins: number;
     seconds: number;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
 }, {}> | Exercise<{
     a: number;
 }, {}> | Exercise<{
@@ -668,6 +721,12 @@ declare const mathExercises: (Exercise<{
     b: number;
     c: number;
     isStrict: boolean;
+}, {}> | Exercise<{
+    isSup: boolean;
+    n: number;
+}, {}> | Exercise<{
+    isSup: boolean;
+    n: number;
 }, {}> | Exercise<{
     xA: number;
     yA: number;
@@ -786,8 +845,12 @@ declare const mathExercises: (Exercise<{
     inegalitySymbol: import("./math/inequations/inequation.js").InegalitySymbols;
     a: number;
     b: number;
+}, {}> | Exercise<{
+    test: number;
 }, {}> | Exercise<{
     k: number;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -945,6 +1008,8 @@ declare const mathExercises: (Exercise<{
     b: number;
     closure: import("./tree/nodes/sets/closure.js").ClosureType;
     type: number;
+}, {}> | Exercise<{
+    a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {}> | Exercise<{
     lowerBound: number;
     upperBound: number;
@@ -2077,6 +2142,12 @@ declare const mathExercises: (Exercise<{
     op: string;
     n: number;
     p: number;
+}, {}> | Exercise<{
+    isCondition: boolean;
+    inputValue: number;
+}, {}> | Exercise<{
+    v: string | number;
+    vType: string;
 }, {}> | Exercise<{
     p: number;
     n: number;

package/lib/index.d.ts.map

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

package/lib/latexTester.d.ts.map

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

package/lib/latexTester.js

@@ -99,7 +99,8 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                 if (cmd === "\\begin") {
                     //lstlisting
                     //array / tabular
-                    if (substring.startsWith("\\begin{lstlisting}")) {
+                    if (substring.startsWith("\\begin{lstlisting}") ||
+                        substring.startsWith("\\lstInLine")) {
                         if (inPython)
                             throw new Error("Python not closed");
                         inPython = true;
@@ -142,10 +143,11 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
         throw new Error("Python not closed");
     return true;
 };
-const mustEscapeCharacters = ["%", "`"];
+const mustEscapeCharacters = ["%"];
 const mustBeInMath = ["%", "#", "_", "~", "^"];
 const mustBeInArrays = ["&", "\\tabularnewline", "\\hline"];
 const validCmds = [
+    "\\lstInLine",
     "\\frac",
     "\\exp",
     "\\cos",
@@ -233,4 +235,5 @@ const validCmds = [
     "\\Rightarrow",
     "\\eta",
     "\\Leftrightarrow",
+    "\\lstinline",
 ];

package/lib/math/numbers/decimals/decimal.d.ts

@@ -31,7 +31,7 @@ export declare class Decimal implements Nombre {
     toScientificPart(): number;
     toScientificNotation(decimals?: number): NumberNode | MultiplyNode;
     getDigitAtRank(rank: number): number;
-    toRational(): Rational | import("../integer/integer.js").Integer;
+    toRational(simplify?: boolean): Rational | import("../integer/integer.js").Integer;
     toTree(): NumberNode;
     toPercentNode(): PercentNode;
     toLowerBound(tenthPower: number): Decimal;

package/lib/math/numbers/decimals/decimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAE1E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;gBACf,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IASxB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAiClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAuCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU;IAMV,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../src/math/numbers/decimals/decimal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,4CAA4C,CAAC;AAE1E,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,eAAO,MAAM,iBAAiB,UAAyC,CAAC;AACxE,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,GAAE,MAAU,GAAG,MAAM;IAY1E,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAMpE,MAAM,CAAC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAK/D,MAAM,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;CAMrD;AAED,qBAAa,OAAQ,YAAW,MAAM;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,aAAsB;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;gBACf,KAAK,EAAE,MAAM,GAAG,MAAM;IASlC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IASxB,MAAM,CAAC,CAAC,EAAE,MAAM;IAIhB;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIhC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAiClC,gBAAgB;IA6BhB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM;IAuCtC,cAAc,CAAC,IAAI,EAAE,MAAM;IAS3B,UAAU,CAAC,QAAQ,CAAC,EAAE,OAAO;IAQ7B,MAAM;IAIN,aAAa;IAIb,YAAY,CAAC,UAAU,EAAE,MAAM;IAS/B,YAAY,CAAC,UAAU,EAAE,MAAM;CAShC"}

package/lib/math/numbers/decimals/decimal.js

@@ -173,8 +173,11 @@ export class Decimal {
             return Number(this.decimalPart[-rank - 1]);
         }
     }
-    toRational() {
-        return new Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision).simplify();
+    toRational(simplify) {
+        const ratio = new Rational(this.multiplyByPowerOfTen(this.precision).value, 10 ** this.precision);
+        if (simplify)
+            return ratio.simplify();
+        return ratio;
     }
     toTree() {
         return new NumberNode(this.value, this.tex);

package/lib/math/utils/stats/median.d.ts

@@ -0,0 +1,2 @@
+export declare const median: (sortedValues: number[], effectifs?: number[]) => number;
+//# sourceMappingURL=median.d.ts.map

package/lib/math/utils/stats/median.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"median.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/stats/median.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,MAAM,iBAAkB,MAAM,EAAE,cAAc,MAAM,EAAE,WAgClE,CAAC"}