math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/calculLitteral/equation/exp/expOfTrinomEquals1Equation.js

@@ -0,0 +1,371 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { SetVEA } from "../../../../../exercises/vea/setVEA.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { round } from "../../../../../math/utils/round.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { sqrt } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+const texXDomain = `\\mathbb{R}`;
+const texNoSolution = (() => {
+    const trinom = new Trinom(1, 1, 1);
+    return trinom.getRootsEquationSolutionTex(true);
+})();
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getChildOfExpNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return new Polynomial([c, b, a]).toTree();
+};
+const getStatementNode = (identifiers) => {
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    const statementTree = new EqualNode(exp(nodeChildOfExp), (1).toTree());
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const sortedSols = trinom.getRootsNode();
+    return new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const answer = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+    return answer;
+};
+const getHint = () => {
+    return `Pour quelle valeur de $t$ a-t-on $e^t=1$ ? 
+  
+Quelle équation faut-il donc résoudre ?`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { a, b, c } = identifiers;
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    const nodeDelta = substract(power(b, 2), multiply(4, multiply(a, c)));
+    const delta = nodeDelta.evaluate();
+    return `L'équation est de la forme $e^{u(x)}=1$ avec $u(x)=${nodeChildOfExp.toTex()}$.
+
+Pour t dans $\\mathbb{R}$, on sait que :
+
+$$
+e^t=1 \\Leftrightarrow t=0
+$$
+
+Ici, on a donc :
+
+$$
+e^{u(x)}=1 \\Leftrightarrow u(x)=0
+$$
+
+Par conséquent : 
+
+${alignTex([
+        ["", "", `e^{${nodeChildOfExp.toTex()}}=1`],
+        ["", `\\Leftrightarrow`, `${nodeChildOfExp.toTex()}=0`],
+    ])}
+
+On calcule le discriminant : 
+
+$$
+\\Delta = ${nodeDelta.toTex()} = ${round(delta, 2).frenchify()}
+$$
+
+${(() => {
+        if (delta > 0) {
+            const nodeX1 = frac(substract(opposite(b), sqrt("\\Delta".toTree())), multiply(2, a));
+            const nodeX2 = frac(add(opposite(b), sqrt("\\Delta".toTree())), multiply(2, a));
+            return `$\\Delta > 0$ donc
+    
+$$
+x_1 = ${nodeX1.toTex()} = ${nodeX1.evaluate({ "\\Delta": delta }).frenchify()}
+$$
+
+$$
+x_2 = ${nodeX2.toTex()} = ${nodeX2.evaluate({ "\\Delta": delta }).frenchify()}
+$$
+
+`;
+        }
+        else if (delta === 0) {
+            const nodeX1 = frac(opposite(b), multiply(2, a));
+            return `$\\Delta = 0$ donc
+    
+$$
+x_1 = x_2 = ${nodeX1.toTex()} = ${nodeX1.evaluate().frenchify()}
+$$
+
+`;
+        }
+        else {
+            return `$\\Delta < 0$ donc il n'y a pas de racines réelles.`;
+        }
+    })()}
+
+Conclusion : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, c } = identifiers;
+    //random coeff signs
+    {
+        const arrIdentifiersWrong = getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1]))
+            .filter((arrS) => !arrS.every((s) => s === 1))
+            .map(([sA, sB, sC]) => {
+            const identifiersWrong = {
+                a: sA * a,
+                b: sB * b,
+                c: sC * c,
+            };
+            return identifiersWrong;
+        });
+        arrIdentifiersWrong.forEach((identifiersWrong) => {
+            const texWrong = getAnswer(identifiersWrong, opts);
+            tryToAddWrongProp(propositions, texWrong);
+        });
+    }
+    //student makes as if exp was not there
+    {
+        const trinom = new Trinom(a, b, c - 1);
+        const texWrong = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student divides both sides by e
+    // {
+    //   const trinom = new Trinom(a, b, c - frac(1, exp(1)));
+    //   const texWrong = trinom.getRootsEquationSolutionTex(
+    //     opts.solutionFormat === "$x=\\ldots$",
+    //   );
+    //   tryToAddWrongProp(propositions, texWrong);
+    // }
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new Rational(-b + randint(-7, 8, [0, +b]), a + randint(-7, 8, [-a, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    return [
+        ...answerInputTypes.reduce((acc, answerInputType) => {
+            const specialSet = new Set((() => {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return [
+                            ...["x", "equal", "ou"],
+                            ...[
+                                (() => {
+                                    return {
+                                        id: "custom",
+                                        label: texNoSolution,
+                                        labelType: "tex",
+                                        mathfieldInstructions: {
+                                            method: "write",
+                                            content: texNoSolution,
+                                        },
+                                    };
+                                })(),
+                            ],
+                        ];
+                    case "S={...;...}":
+                        return [
+                            "S",
+                            "equal",
+                            "lbrace",
+                            "semicolon",
+                            "rbrace",
+                            "varnothing",
+                        ];
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            })());
+            return new Set([...acc, ...specialSet]);
+        }, new Set()),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    function getParsedNodesForAnswerInputType(ans, answerInputType) {
+        switch (answerInputType) {
+            case "x=... ou x=...":
+                {
+                    const formated = ans
+                        .replaceAll("text{ ou }", ";")
+                        .replaceAll("x", "")
+                        .replaceAll("=", "");
+                    const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                    return elements;
+                }
+                break;
+            case "S={...;...}":
+                {
+                    const discreteSetNodeCandidate = discreteSetParser(ans);
+                    if (discreteSetNodeCandidate) {
+                        return discreteSetNodeCandidate.elements;
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                break;
+            default:
+                throw new Error("Unsupported answerInputType: " + answerInputType);
+        }
+    }
+    function isAnswerValidForAnswerInputType(answerInputType) {
+        try {
+            if (arrNodeAnswer.length === 0) {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return ans === texNoSolution;
+                    case "S={...;...}":
+                        return ans === `S=\\varnothing`;
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            }
+            else {
+                const arrAns = getParsedNodesForAnswerInputType(ans, answerInputType);
+                return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+            }
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+};
+const getExpOfTrinomEquals1EquationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    function createRandomCoeffs(rootPool) {
+        const roots = randomMany(rootPool, randint(0, 3));
+        let a;
+        let b;
+        let c;
+        switch (roots.length) {
+            case 0:
+                {
+                    [a, b, c] = [...Array(3).keys()].map(() => randint(1, 10));
+                    const isPositive = coinFlip();
+                    if (!isPositive) {
+                        [a, b, c] = [a, b, c].map((v) => v * -1);
+                    }
+                }
+                break;
+            case 1:
+            case 2:
+                {
+                    const rootsExplicit = roots.length === 1 ? [roots[0], roots[0]] : roots;
+                    a = randint(1, 6);
+                    b = a * rootsExplicit.reduce((acc, v) => acc + v);
+                    c = a * rootsExplicit.reduce((acc, v) => acc * v);
+                }
+                break;
+        }
+        return [c, b, a];
+    }
+    const rootPool = [...Array(41).keys()].map((i) => i - 20);
+    const [c, b, a] = createRandomCoeffs(rootPool);
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getAnswerInputTypes = (opts) => {
+    const { solutionFormat } = opts;
+    switch (solutionFormat) {
+        case "$x=\\ldots$":
+            return ["x=... ou x=..."];
+        case "Ensemble":
+            return ["S={...;...}"];
+        case "Permettre les deux":
+            return ["x=... ou x=...", "S={...;...}"];
+        default:
+            throw new Error("Unsupported solutionFormat: " + solutionFormat);
+    }
+};
+const optsDefault = {
+    solutionFormat: "Ensemble",
+};
+const options = [
+    {
+        id: "solutionFormat",
+        label: "Donner la solution sous la forme :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Ensemble", "$x=\\ldots$", "Permettre les deux"],
+        defaultValue: optsDefault.solutionFormat,
+    },
+];
+export const expOfTrinomEquals1Equation = {
+    id: "expOfTrinomEquals1Equation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $e^{ax^2+bx+c}=1$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfTrinomEquals1EquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/calculLitteral/equation/exp/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/equation/exp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/calculLitteral/equation/exp/index.js

@@ -0,0 +1,3 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";

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

@@ -1 +1 @@
-{"version":3,"file":"factorizeEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/factorizeEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAyCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+QF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB5D,CAAC"}
+{"version":3,"file":"factorizeEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/factorizeEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAyCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqRF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB5D,CAAC"}

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

@@ -147,7 +147,14 @@ const getKeys = (_, optsIn) => {
                     case "x=... ou x=...":
                         return ["x", "equal", "ou"];
                     case "S={...;...}":
-                        return ["S", "equal", "lbrace", "semicolon", "rbrace"];
+                        return [
+                            "S",
+                            "equal",
+                            "lbrace",
+                            "semicolon",
+                            "rbrace",
+                            "varnothing",
+                        ];
                     default:
                         throw new Error("Unsupported answerInputType: " + answerInputType);
                 }
@@ -168,7 +175,6 @@ const isAnswerValid = (ans, { answer: _, ...identifiers }, optsIn) => {
                         .replaceAll("text{ ou }", ";")
                         .replaceAll("x", "")
                         .replaceAll("=", "");
-                    console.log("formated", formated);
                     // if (formated === "\\varnothing") {
                     //   return EmptySet;
                     // }

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

@@ -13,4 +13,5 @@ export * from "./solveByFactorizingWithIdRmq3.js";
 export * from "./equationFromFrenchDescription.js";
 export * from "./firstDegree/index.js";
 export * from "./square/index.js";
+export * from "./exp/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,wBAAwB,CAAC;AACvC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC"}

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

@@ -13,3 +13,4 @@ export * from "./solveByFactorizingWithIdRmq3.js";
 export * from "./equationFromFrenchDescription.js";
 export * from "./firstDegree/index.js";
 export * from "./square/index.js";
+export * from "./exp/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAuCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqMF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAejE,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAwCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsOF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAejE,CAAC"}

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

@@ -61,6 +61,32 @@ const getAnswer = (identifiers, optsIn) => {
     const answerNode = getAnswerNode(identifiers);
     return getTexForEquationSolutionNode(answerNode, opts);
 };
+const getKeys = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { answerInputTypes } = opts;
+    return [
+        ...answerInputTypes.reduce((acc, answerInputType) => {
+            const specialSet = new Set((() => {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return ["x", "equal", "ou"];
+                    case "S={...;...}":
+                        return [
+                            "S",
+                            "equal",
+                            "lbrace",
+                            "semicolon",
+                            "rbrace",
+                            "varnothing",
+                        ];
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            })());
+            return new Set([...acc, ...specialSet]);
+        }, new Set()),
+    ];
+};
 const isAnswerValid = (ans, { answer: _, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;
     const answerNode = getAnswerNode(identifiers);
@@ -73,7 +99,6 @@ const isAnswerValid = (ans, { answer: _, ...identifiers }, optsIn) => {
                         .replaceAll("text{ ou }", ";")
                         .replaceAll("x", "")
                         .replaceAll("=", "");
-                    console.log("formated", formated);
                     // if (formated === "\\varnothing") {
                     //   return EmptySet;
                     // }
@@ -177,7 +202,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         instruction: getInstruction(identifiers, opts),
         startStatement: getStartStatement(identifiers, opts),
         answer: getAnswer(identifiers, opts),
-        keys: ["x", "S", "equal", "lbrace", "rbrace", "semicolon", "ou"],
+        keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers, opts),

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

@@ -1 +1 @@
-{"version":3,"file":"solveByFactorizingWithIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA2LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAUF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}
+{"version":3,"file":"solveByFactorizingWithIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAUF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}

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

@@ -125,7 +125,6 @@ const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
         if (opts?.useSetAsAnswer) {
             const setParsed = discreteSetParser(ans);
             //!!!TODO
-            console.log(setParsed);
             return false;
         }
         else {

package/lib/exercises/math/calculLitteral/equation/square/equationSquareWithSteps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationSquareWithSteps.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/square/equationSquareWithSteps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}
+{"version":3,"file":"equationSquareWithSteps.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/square/equationSquareWithSteps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAkBzD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/square/equationSquareWithSteps.js

@@ -102,7 +102,6 @@ const isAnswerValid = (ans, { answer }) => {
         const parsed = discreteSetParser(ans);
         if (!parsed)
             return false;
-        console.log(parsed.simplify().toTex());
         return "S=" + parsed.simplify().toTex() === answer;
     }
     catch (err) {

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+/**
+ *  e^{f(x)}<e^{g(x)}
+ */
+type Identifiers = {
+    coeffsF: number[];
+    coeffsG: number[];
+    ineqType: InegalitySymbols;
+};
+type Options = {
+    inequationSolutionFormat: string;
+    functionTypeF: string;
+    functionTypeG: string;
+};
+export declare const expOfFEqualsExpOfGInequation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=expOfFEqualsExpOfGInequation.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expOfFEqualsExpOfGInequation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAqBrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAiH9C;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAwYF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA2BF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBvE,CAAC"}