math-exercises 3.0.108 → 3.0.110

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

@@ -7,32 +7,32 @@ const getPropositions = (n, { answer, coeff, iterations, operation }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, `\`${operation}${coeff}\``, "raw");
-    tryToAddWrongProp(propositions, `\`x${operation}${iterations}\``, "raw");
+    tryToAddWrongProp(propositions, `\`a${operation}${iterations}\``, "raw");
     tryToAddWrongProp(propositions, `\`${coeff}\``, "raw");
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    return `a${identifiers.operation}${identifiers.coeff}`;
+    return `\`a${identifiers.operation}${identifiers.coeff}\``;
 };
 const getInstruction = (identifiers) => {
     let word = "";
     const { coeff, iterations, operation } = identifiers;
     switch (operation) {
         case "+":
-            word = "l'additionner";
+            word = `lui ajouter $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "-":
-            word = "le soustraire";
+            word = `lui soustraire $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "*":
-            word = "le multiplier";
+            word = `le multiplier à $${iterations}$ reprises par $${coeff}$`;
             break;
         case "/":
         default:
-            word = "le diviser";
+            word = `le diviser à $${iterations}$ reprises par $${coeff}$`;
             break;
     }
-    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word} à $${iterations}$ reprises par $${coeff}$, puis de renvoyer le résultat du calcul.
+    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word}, puis de renvoyer le résultat du calcul.
   
 Par quoi faut-il remplacer les trois points ?
 
@@ -63,14 +63,23 @@ x = x${fakeOperation}${fakeCoeff}
 };
 const getCorrection = (identifiers) => {
     const { coeff, iterations, operation } = identifiers;
-    const word = operation === "/"
-        ? "diviser"
-        : operation === "+"
-            ? "additionner"
-            : operation === "-"
-                ? "soustraire"
-                : "multiplier";
-    return `On veut ${word} \`a\` par $${coeff}$ à chaque exécution de la boucle \`for\`. En python, cela se traduit par : 
+    let word = "";
+    switch (operation) {
+        case "+":
+            word = `ajouter $${coeff}$ à \`a\``;
+            break;
+        case "-":
+            word = `soustraire $${coeff}$ à \`a\``;
+            break;
+        case "*":
+            word = `multiplier \`a\` par $${coeff}$`;
+            break;
+        case "/":
+        default:
+            word = `diviser \`a\` par $${coeff}$`;
+            break;
+    }
+    return `On veut ${word} à chaque exécution de la boucle \`for\`. En python, cela se traduit par : 
   
 \`\`\`
 a=a${operation}${coeff}

package/lib/exercises/math/python/pythonRangeCompletion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythonRangeCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonRangeCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}
+{"version":3,"file":"pythonRangeCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonRangeCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAmGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

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

@@ -6,6 +6,8 @@ import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, Number(answer) + 1 + "");
+    tryToAddWrongProp(propositions, Number(answer) - 1 + "");
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, randint(1, 20).frenchify());
     }
@@ -19,20 +21,20 @@ const getInstruction = (identifiers) => {
     const { coeff, iterations, operation } = identifiers;
     switch (operation) {
         case "+":
-            word = "l'additionner";
+            word = `lui ajouter $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "-":
-            word = "le soustraire";
+            word = `lui soustraire $${coeff}$ à $${iterations}$ reprises`;
             break;
         case "*":
-            word = "le multiplier";
+            word = `le multiplier à $${iterations}$ reprises par $${coeff}$`;
             break;
         case "/":
         default:
-            word = "le diviser";
+            word = `le diviser à $${iterations}$ reprises par $${coeff}$`;
             break;
     }
-    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word} à $${iterations}$ reprises par $${coeff}$, puis de renvoyer le résultat du calcul.
+    return `On considère la fonction en Python suivante. Cette fonction doit permettre, pour un paramètre \`a\` saisi en entrée, de ${word}, puis de renvoyer le résultat du calcul.
   
 Par quoi faut-il remplacer les trois points ?
 

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

@@ -32,8 +32,8 @@ const getInstruction = (identifiers) => {
     const { variableName, initialVariable, affines } = identifiers;
     const affinePythonStrings = affines
         .map((a) => a.toPython())
-        .join(`;\n${variableName} = `);
-    return `On exécute le script Python ci-dessous. Quelle est la valeur de \`${variableName}\` à la fin du script ?
+        .join(`\n${variableName} = `);
+    return `On exécute le script en Python ci-dessous. Quelle est la valeur de \`${variableName}\` à la fin du script ?
 
 \`\`\`
 ${variableName} = ${initialVariable}
@@ -53,7 +53,7 @@ const getCorrection = (identifiers) => {
   et on affecte cette valeur dans la variable \`${variableName}\`. On a donc :
   
 \`\`\`
-${variableName} = ${initialVariable}; # Ici ${variableName} = ${variable}
+${variableName} = ${initialVariable} # Ici ${variableName} = ${variable}
 ${affines
         .map((a) => {
         evVariable = a
@@ -62,8 +62,8 @@ ${affines
         variable = a.calculate(variable);
         return (`${variableName} = ` +
             a.toPython() +
-            `; # Ici ${variableName} = ${evVariable
-                .toTex()
+            ` # Ici ${variableName} = ${evVariable
+                .toTex({ forceNoSimplification: true })
                 .replace("\\times", "*")
                 .replaceAll("\\left", "")
                 .replaceAll("\\right", "")} = ${variable}\n`);
@@ -105,10 +105,10 @@ const getVariableAffectationQuestion = (ops) => {
             affines.push(new Affine(1, randint(-4, 5, [0]), variableName));
         }
         else if (type === 2) {
-            affines.push(new Affine(randint(-4, 5, [0]), 0, variableName));
+            affines.push(new Affine(randint(-4, 5, [0, 1]), 0, variableName));
         }
         else {
-            affines.push(AffineConstructor.random({ min: -4, max: 4 }, { min: -5, max: 5 }, variableName));
+            affines.push(AffineConstructor.random({ min: -4, max: 4, excludes: [0, 1] }, { min: -5, max: 5, excludes: [0] }, variableName));
         }
     }
     const identifiers = { variableName, initialVariable, affines };

package/lib/exercises/math/python/variableType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variableType.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/variableType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}
+{"version":3,"file":"variableType.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/variableType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}

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

@@ -7,7 +7,7 @@ const getPropositions = (n, { answer }) => {
     addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, "Nombre entier", "raw");
     tryToAddWrongProp(propositions, "Nombre flottant", "raw");
-    tryToAddWrongProp(propositions, "Chaine de caractères", "raw");
+    tryToAddWrongProp(propositions, "Chaîne de caractères", "raw");
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
@@ -19,7 +19,7 @@ const getAnswer = (identifiers) => {
         return "Nombre flottant";
     }
     else if (vType === "str") {
-        return "Chaine de caractères";
+        return "Chaîne de caractères";
     }
     else {
         throw new Error(`Unknown type: ${vType}`);
@@ -28,15 +28,16 @@ const getAnswer = (identifiers) => {
 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 ? 
+
+\`\`\`python
+v = ${vType === "str" ? `"${v}"` : v}
+\`\`\`
+
+Quel est le type de la variable \`v\` ? 
   `;
 };
 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).";
+    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;
@@ -48,9 +49,9 @@ const getCorrection = (identifiers) => {
         explanationType = "Nombre flottant";
     }
     else if (vType === "str") {
-        explanationType = "Chaine de caractères";
+        explanationType = "Chaîne 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).
+    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()}.`;
 };

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

@@ -2,7 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = ({ inputValue, threshold, }) => {
-    return `On définit la fonction en Python boucle.
+    return `On définit la fonction en Python suivante :
 
 \`\`\`python
 def boucle(x):

package/lib/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    n: number;
+};
+export declare const arithmeticFindAntecedent: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=arithmeticFindAntecedent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindAntecedent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindAntecedent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAqBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2HF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}

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

@@ -0,0 +1,110 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode, equationResolutionTex, } from "../../../../tree/nodes/equations/equalNode.js";
+import { NumberNode, NumberNodeConstructor, } from "../../../../tree/nodes/numbers/numberNode.js";
+const varName = "n";
+const getInstruction = (identifiers) => {
+    const { a, b, n } = identifiers;
+    const affineWithN = new Affine(a, b, varName);
+    const u = affineWithN.calculate(n);
+    const affineWithNTex = affineWithN.toTree().toTex();
+    const uTex = u.frenchify();
+    return `On donne la suite numérique $u$ définie par :
+  
+$$
+u_${varName}= ${affineWithNTex}
+$$
+
+Calculer la valeur de $ ${varName} $ pour laquelle $ u_${varName} = ${uTex} $.`;
+};
+const getPropositions = (nb_prop, { answer, a, b, n }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affineWithN = new Affine(a, b, varName);
+    const u = affineWithN.calculate(n);
+    tryToAddWrongProp(propositions, new Affine(a, b).solve(0).toTex());
+    tryToAddWrongProp(propositions, affineWithN.calculate(u).toTree().toTex());
+    tryToAddWrongProp(propositions, new NumberNode(n + 1).toTex());
+    if (propositions.length < nb_prop) {
+        if (n - 1 >= 0) {
+            tryToAddWrongProp(propositions, new NumberNode(n - 1).toTex());
+        }
+    }
+    while (propositions.length < nb_prop) {
+        const wrongAnswer = NumberNodeConstructor.random(0, 20);
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffleProps(propositions, nb_prop);
+};
+const getAnswer = (identifiers) => {
+    const { n } = identifiers;
+    return n.frenchify();
+};
+const getHint = (identifiers) => {
+    // const {affineWithNTex, uTex} = getTailoredTex(identifiers);
+    const { a, b, n } = identifiers;
+    const affineWithN = new Affine(a, b, varName);
+    const u = affineWithN.calculate(n);
+    const equationNode = new EqualNode(affineWithN.toTree(), new NumberNode(u));
+    const equationTex = equationNode.toTex();
+    return `Résous l'équation $${equationTex} $.`;
+};
+/*
+    a n + b = k
+    n = (k - b) / a
+*/
+const getCorrection = (identifiers) => {
+    const { a, b, n } = identifiers;
+    const affineWithN = new Affine(a, b, varName);
+    const u = affineWithN.calculate(n);
+    return `On résout l'équation $u_${varName} = ${u}$ :
+  
+$$
+${equationResolutionTex(a.toTree(), b.toTree(), (0).toTree(), u.toTree(), varName)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, a, b, n }) => {
+    return numberVEA(ans, answer);
+};
+const getArithmeticFindAntecedentQuestion = (ops) => {
+    const affine = AffineConstructor.random(undefined, {
+        excludes: [0],
+    });
+    const n = randint(0, 20, []);
+    const identifiers = { a: affine.a, b: affine.b, n: n };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const arithmeticFindAntecedent = {
+    id: "arithmeticFindAntecedent",
+    label: "Déterminer un antécedent via une suite arithmétique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindAntecedentQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -14,4 +14,5 @@ export * from "./arithmeticFindExplictFormulaFirstTermRandom.js";
 export * from "./arithmeticFindReasonRandomRange.js";
 export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
+export * from "./arithmeticFindAntecedent.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}

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

@@ -14,3 +14,4 @@ export * from "./arithmeticFindExplictFormulaFirstTermRandom.js";
 export * from "./arithmeticFindReasonRandomRange.js";
 export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
+export * from "./arithmeticFindAntecedent.js";

package/lib/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceCoordinatesInPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA8KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"spaceCoordinatesInPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesInPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA8KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}

package/lib/exercises/math/trigonometry/arcLength.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arcLength.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,EAAE,GAAG,GAAG,SAAS,CAAC;IACnC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA2GF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}
+{"version":3,"file":"arcLength.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,EAAE,GAAG,GAAG,SAAS,CAAC;IACnC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA2GF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

package/lib/exercises/math/trigonometry/basicEquationCos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicEquationCos.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicEquationCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"basicEquationCos.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicEquationCos.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/trigonometry/basicEquationSin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicEquationSin.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicEquationSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+FF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"basicEquationSin.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicEquationSin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+FF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/trigonometry/basicTrigoSystemEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicTrigoSystemEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicTrigoSystemEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAgB1D,CAAC"}
+{"version":3,"file":"basicTrigoSystemEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/basicTrigoSystemEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAgB1D,CAAC"}

package/lib/exercises/math/trigonometry/degreeToRadians.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"degreeToRadians.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/degreeToRadians.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,GAAG,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AA8JF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"degreeToRadians.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/degreeToRadians.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,GAAG,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AA8JF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/math/trigonometry/mainAngleMeasure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mainAngleMeasure.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainAngleMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,GAAG,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"mainAngleMeasure.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/mainAngleMeasure.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,GAAG,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

package/lib/index.d.ts

@@ -231,6 +231,8 @@ declare const mathExercises: (Exercise<{
 }, {
     precisionAsked: number;
 }> | Exercise<{
+    factIndex: number;
+}, {}> | Exercise<{
     nb: number;
     rankAsked: number;
 }, {}> | Exercise<{
@@ -522,6 +524,15 @@ declare const mathExercises: (Exercise<{
     sysIds: import("./math/systems/generalSystem.js").GeneralSystemIdentifiers;
     x: number;
     y: number;
+}, {}> | Exercise<{
+    formula: {
+        title: string;
+        func: (variables: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[]) => import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+        variables: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+        variableNames: string[];
+        keys: (import("./types/keyIds.js").KeyId | import("./types/keyProps.js").KeyProps)[];
+    };
+    values: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
 }, {}> | Exercise<{
     word: string;
 }, {}> | Exercise<{
@@ -719,6 +730,11 @@ declare const mathExercises: (Exercise<{
     coin: number;
     racine1: number;
     racine2: number;
+}, {}> | Exercise<{
+    a: number;
+    coin: number;
+    r1: number;
+    r2: number;
 }, {}> | Exercise<{
     a: number;
     b: number;
@@ -1077,6 +1093,11 @@ declare const mathExercises: (Exercise<{
     isLog10: boolean;
 }, {
     isLog10: boolean;
+}> | Exercise<{
+    a: number;
+    b: number;
+}, {
+    useLog10?: boolean;
 }> | Exercise<{
     type: string;
     fctTex: string;
@@ -2256,6 +2277,10 @@ declare const mathExercises: (Exercise<{
     firstTerm: number;
     reason: number;
     askedRank: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    n: number;
 }, {}> | Exercise<{
     firstValue: number;
     reason: number;
@@ -2525,6 +2550,7 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     opName: string;
+    ineqs: string[];
 }, {}> | Exercise<{
     coeff: number;
     iterations: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/playground.d.ts.map

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

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

@@ -38,6 +38,6 @@ export declare class EqualNode implements AlgebraicNode {
     toDetailedEvaluation(vars: Record<string, AlgebraicNode>): EqualNode;
     isVerified(): boolean;
 }
-export declare const equationResolutionTex: (a: AlgebraicNode, b: AlgebraicNode, c: AlgebraicNode, d: AlgebraicNode) => string | string[];
+export declare const equationResolutionTex: (a: AlgebraicNode, b: AlgebraicNode, c: AlgebraicNode, d: AlgebraicNode, str__var?: string) => string | string[];
 export {};
 //# sourceMappingURL=equalNode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAQ/B,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc;IAqG9C,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;IAG3C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM;IAGvE,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS;IAMpE,UAAU;CAIX;AAED,eAAO,MAAM,qBAAqB,MAC7B,aAAa,KACb,aAAa,KACb,aAAa,KACb,aAAa,sBA2DjB,CAAC"}
+{"version":3,"file":"equalNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/equations/equalNode.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,aAAa,EACb,eAAe,EACf,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAEL,eAAe,EAEhB,MAAM,uBAAuB,CAAC;AAQ/B,eAAO,MAAM,KAAK,MACb,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,cAOnC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,EAAE,EAAE,OAAO,CAAC,KAAK,CAAC;IAClB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB,CAAC;AAEF,8BAAsB,oBAAoB;IACxC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,oBAAoB,GAAG,SAAS;CAOrE;AAED,eAAO,MAAM,WAAW,SAAU,aAAa,KAAG,IAAI,IAAI,SACzB,CAAC;AAElC,KAAK,cAAc,GAAG;IACpB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,SAAU,YAAW,aAAa;IAC7C,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IASpB,aAAa,IAAI,oBAAoB;IAQrC,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW;IAmBpC,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAM5C,YAAY,IAAI,MAAM;IAGtB,KAAK,IAAI,MAAM;IAIf,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe;IAQ/B,OAAO;IAIP,OAAO;IAIP,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc;IAqG9C,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa;IAG3C,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO;IAGpC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,MAAM;IAGvE,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,SAAS;IAMpE,UAAU;CAIX;AAED,eAAO,MAAM,qBAAqB,MAC7B,aAAa,KACb,aAAa,KACb,aAAa,KACb,aAAa,aACN,MAAM,sBA2DjB,CAAC"}

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

@@ -198,7 +198,7 @@ export class EqualNode {
         return this.leftChild.simplify().equals(this.rightChild.simplify());
     }
 }
-export const equationResolutionTex = (a, b, c, d) => {
+export const equationResolutionTex = (a, b, c, d, str__var = "x") => {
     //(+-a)x(+-b) = (+-c)x(+-d)
     const steps = [];
     const iteration = (a, b, c, d) => {
@@ -210,24 +210,24 @@ export const equationResolutionTex = (a, b, c, d) => {
                 //ax = d
                 if (aEv === 1) {
                     //x = d
-                    steps.push(`x=${d.toTex()}`);
+                    steps.push(`${str__var}=${d.toTex()}`);
                     return;
                 }
                 else {
                     //ax = d
-                    steps.push(`${multiply(a, "x").toTex()}=${d.toTex()}`);
+                    steps.push(`${multiply(a, str__var).toTex()}=${d.toTex()}`);
                     iteration((1).toTree(), (0).toTree(), (0).toTree(), frac(d, a).simplify());
                 }
             }
             else {
-                steps.push(`${monom(a, 1).toTex()}=${add(monom(c, 1), d).toTex()}`);
+                steps.push(`${monom(a, 1, { variable: str__var }).toTex()}=${add(monom(c, 1, { variable: str__var }), d).toTex()}`);
                 //ax = c!x + d
                 iteration(substract(a, c).simplify(), (0).toTree(), (0).toTree(), d);
             }
         }
         else {
             //ax + b! = cx + d
-            steps.push(`${add(multiply(a, "x"), b).simplify().toTex()}=${add(multiply(c, "x"), d)
+            steps.push(`${add(multiply(a, str__var), b).simplify().toTex()}=${add(multiply(c, str__var), d)
                 .simplify()
                 .toTex()}`);
             iteration(a, (0).toTree(), c, substract(d, b).simplify());

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.108",
+  "version": "3.0.110",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [