math-exercises 3.0.156 → 3.0.158

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

@@ -1,4 +1,4 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { Polynomial } from "../../../../math/polynomials/polynomial.js";
@@ -10,6 +10,27 @@ import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getTexForEquationSolutionNode = (nodeAnswer, opts) => {
+    const answerInputTypeDefault = "S={...;...}";
+    const answerInputType = opts.answerInputTypes.includes(answerInputTypeDefault)
+        ? answerInputTypeDefault
+        : opts.answerInputTypes[0];
+    switch (answerInputType) {
+        case "x=... ou x=...":
+            {
+                const arrNodeAnswer = nodeAnswer.solutionsSet.elements;
+                return arrNodeAnswer
+                    .map((node) => `x=${node.toTex()}`)
+                    .join("\\text{ ou }");
+            }
+            break;
+        case "S={...;...}":
+            return nodeAnswer.toTex();
+        default:
+            throw new Error("Unsupported answerInputType: " + answerInputType);
+    }
+};
 const getStatementNode = (identifiers) => {
     const { a, b, c, d } = identifiers;
     const polynome1 = new Polynomial([b, a]);
@@ -27,13 +48,88 @@ $$
 ${getStartStatement(identifiers)}
 $$`;
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { a, b, c, d } = identifiers;
     const sol1 = new Rational(-b, a).simplify().toTree();
     const sol2 = new Rational(-d, c).simplify().toTree();
     const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
-    const answer = new EquationSolutionNode(new DiscreteSetNode(sortedSols)).toTex();
-    return answer;
+    const nodeAnswer = new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+    return nodeAnswer;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerNode = getAnswerNode(identifiers);
+    return getTexForEquationSolutionNode(answerNode, opts);
+};
+const isAnswerValid = (ans, { answer: _, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    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("=", "");
+                    console.log("formated", formated);
+                    // if (formated === "\\varnothing") {
+                    //   return EmptySet;
+                    // }
+                    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 {
+            const arrAns = getParsedNodesForAnswerInputType(ans, answerInputType);
+            return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    return opts.answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        let a, b, c, d;
+        let counter = 0;
+        do {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in multiplicationEquation");
+            a = randint(-9, 10, [0]);
+            b = randint(-9, 10, [0]);
+            c = randint(-9, 10, [0]);
+            d = randint(-9, 10, [0]);
+        } while (a / c === b / d);
+        const sol1 = new Rational(-b, a).simplify().toTree();
+        const sol2 = new Rational(-d, c).simplify().toTree();
+        const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
+        const wrongAnswer = getTexForEquationSolutionNode(new EquationSolutionNode(new DiscreteSetNode(sortedSols)), opts);
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffle(propositions);
 };
 const getHint = () => {
     return "Un produit est nul si et seulement si un des deux facteurs est nul. Il faut donc trouver les valeurs de $x$ qui rendent un des deux facteurs nul.";
@@ -59,7 +155,8 @@ ${alignTex([
   
   Ainsi, $${getAnswer(identifiers)}$`;
 };
-const getMultiplicationEquation = () => {
+const getMultiplicationEquation = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     // (ax + b)(cx + d) = 0
     let a, b, c, d;
     let counter = 0;
@@ -73,59 +170,42 @@ const getMultiplicationEquation = () => {
         d = randint(-9, 10, [0]);
     } while (a / c === b / d);
     const identifiers = { a, b, c, d };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        instruction: getInstruction(identifiers),
-        startStatement: getStartStatement(identifiers),
-        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
         keys: ["x", "S", "equal", "lbrace", "rbrace", "semicolon", "ou"],
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    propWhile(propositions, n, () => {
-        let a, b, c, d;
-        let counter = 0;
-        do {
-            counter++;
-            if (counter > 1000)
-                throw new Error("Too many iterations in multiplicationEquation");
-            a = randint(-9, 10, [0]);
-            b = randint(-9, 10, [0]);
-            c = randint(-9, 10, [0]);
-            d = randint(-9, 10, [0]);
-        } while (a / c === b / d);
-        const sol1 = new Rational(-b, a).simplify().toTree();
-        const sol2 = new Rational(-d, c).simplify().toTree();
-        const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
-        const wrongAnswer = new EquationSolutionNode(new DiscreteSetNode(sortedSols)).toTex();
-        tryToAddWrongProp(propositions, wrongAnswer);
-    });
-    return shuffle(propositions);
-};
-const isAnswerValid = (ans, { a, b, c, d }) => {
-    const parsed = discreteSetParser(ans);
-    if (!parsed)
-        return false;
-    const sol1 = new Rational(-b, a).simplify().toTree();
-    const sol2 = new Rational(-d, c).simplify().toTree();
-    const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
-    return SetVEA.isArrayOfNodesValid(parsed.elements, sortedSols);
+const optsDefault = {
+    answerInputTypes: ["x=... ou x=...", "S={...;...}"],
 };
+const options = [
+    {
+        id: "answerInputTypes",
+        label: "Format(s) de réponse",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["x=... ou x=...", "S={...;...}"],
+        defaultValue: optsDefault.answerInputTypes,
+    },
+];
 export const multiplicationEquation = {
     id: "multiplicationEquation",
     connector: "\\iff",
     label: "Résoudre une équation produit nul",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getMultiplicationEquation, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getMultiplicationEquation(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

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;AAgYF,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"}

package/lib/exercises/math/calculLitteral/inequations/exp/expOfFEqualsExpOfGInequation.js

@@ -0,0 +1,437 @@
+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 { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { EmptySet } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { zip } from "../../../../../utils/arrays/arrayZip.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../../tree/nodes/numbers/infiniteNode.js";
+import { IntervalNode } from "../../../../../tree/nodes/sets/intervalNode.js";
+import { ClosureType } from "../../../../../tree/nodes/sets/closure.js";
+import { InequationSolutionNode } from "../../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+import { InequationSymbol, InequationSymbolConstructor, } from "../../../../../math/inequations/inequation.js";
+import { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { inequationSolutionFormat } from "../../../../../exercises/options/inequationSolutionFormat.js";
+import { unionIntervalParser } from "../../../../../tree/parsers/unionIntervalParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+//reuse other exercises:  (unfortunately breaks exosTest)
+// import { reuseSecondDegreeInequation } from "../../../../../exercises/math/functions/trinoms/equation/secondDegreeInequation.js";
+// import { reuseFirstDegreeInequationsType3 } from "../../../../../exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.js";
+import { intervalParser } from "../../../../../tree/parsers/intervalParser.js";
+import { inequationParser } from "../../../../../tree/parsers/inequationParser.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { UnionIntervalNode } from "../../../../../tree/nodes/sets/unionIntervalNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const reuseSecondDegreeInequation = {
+    getAnswerNode: (identifiers) => {
+        const { a, b, c, ineqType } = identifiers;
+        const ineq = new InequationSymbol(ineqType);
+        const trinom = new Trinom(a, b, c);
+        const roots = trinom.getRootsNode();
+        const aPositive = a > 0;
+        const insideInterval = new IntervalNode(roots[0], roots[1], ineq.isStrict ? ClosureType.OO : ClosureType.FF);
+        const outsideUnion = new UnionIntervalNode([
+            new IntervalNode(MinusInfinityNode, roots[0], ineq.isStrict ? ClosureType.OO : ClosureType.OF),
+            new IntervalNode(roots[1], PlusInfinityNode, ineq.isStrict ? ClosureType.OO : ClosureType.FO),
+        ]);
+        const tree = ineq.isSup
+            ? aPositive
+                ? outsideUnion
+                : insideInterval
+            : aPositive
+                ? insideInterval
+                : outsideUnion;
+        return new InequationSolutionNode(tree);
+    },
+};
+const reuseFirstDegreeInequationsType3 = {
+    getAnswerNode: (identifiers, opts) => {
+        const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+        const { ineqType, a, b, c, d, coeff } = identifiers;
+        const affine1 = new Affine(a, b);
+        const affine2 = new Affine(c, d);
+        const result = new Rational(affine2.b - affine1.b, affine1.a - affine2.a)
+            .simplify()
+            .toTree();
+        const invIneqType = new InequationSymbol(ineqType).reversed();
+        const ineq = new InequationNode(["x".toTree(), result], coeff > 0 ? ineqType : invIneqType);
+        const node = isInterval
+            ? new InequationSolutionNode(ineq.toInterval())
+            : ineq;
+        return node;
+    },
+};
+const texXDomain = `\\mathbb{R}`;
+const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+const texbbR = intervalbbR.toTex();
+const createNodeForCoeffs = (coeffs) => {
+    //because Error: n-th coeff must be not null at new Polynomial
+    const [a, b, c] = coeffs.toReversed();
+    if (a !== 0) {
+        return new Polynomial(coeffs).toTree();
+    }
+    else if (b !== 0) {
+        return AffineConstructor.fromCoeffs(coeffs).toTree();
+    }
+    else {
+        return c.toTree();
+    }
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    const statementTree = new InequationNode([exp(nodeF), exp(nodeG)], ineqType);
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const { inequationSolutionFormat } = opts;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isZero = [a, b, c].every((k) => k === 0);
+    if (isZero) {
+        switch (ineqType) {
+            case "<":
+            case ">":
+                return new EquationSolutionNode(EmptySet);
+            case "\\le":
+            case "\\ge": {
+                const intervalbbR = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+                return new InequationSolutionNode(intervalbbR);
+            }
+        }
+    }
+    else {
+        if (a !== 0) {
+            return reuseSecondDegreeInequation.getAnswerNode({ a, b, c, ineqType });
+        }
+        else if (b !== 0) {
+            const [b, a] = coeffsF;
+            const [d, c] = coeffsG;
+            return reuseFirstDegreeInequationsType3.getAnswerNode({ a, b, c, d, ineqType, coeff: a - c }, { inequationSolutionFormat });
+        }
+        else {
+            //a==0,b==0,c!==0
+            return new EquationSolutionNode(EmptySet);
+        }
+    }
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [a, b, c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    const isCoeffsZero = [a, b, c].every((k) => k === 0);
+    if (isCoeffsZero) {
+        switch (ineqType) {
+            case "<":
+            case ">": {
+                if (opts.inequationSolutionFormat === "Inégalité (x>a)") {
+                    return `x\\in\\varnothing`;
+                }
+                else {
+                    return `S=\\varnothing`;
+                }
+            }
+            case "\\le":
+            case "\\ge": {
+                if (opts.inequationSolutionFormat === "Inégalité (x>a)") {
+                    return `x\\in${texbbR}`;
+                }
+                else {
+                    return `S=${texbbR}`;
+                }
+            }
+        }
+    }
+    else {
+        return getAnswerNode(identifiers, opts).toTex();
+    }
+};
+const getHint = () => {
+    return `Essaye de transformer l'équation originale en une équation du type $e^{h(x)}=1$, puis résous cette équation.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    const [nodeF, nodeG] = [coeffsF, coeffsG].map(createNodeForCoeffs);
+    //that would be nice, but:
+    //Error: should-throw Too many iterations in simplify
+    // const nodeFMinusGSimplified = substract(nodeF, nodeG).simplify({
+    //   towardsDistribute: true,
+    // });
+    //workaround:
+    const coeffsFMinusG = zip(coeffsF, coeffsG).map(([kF, kG]) => kF - kG);
+    const nodeFMinusGSimplified = createNodeForCoeffs(coeffsFMinusG);
+    return `On va transformer l'équation originale pour se ramener à quelque chose que l'on connaît mieux.
+
+L'ensemble image de la fonction exponentielle est $\\mathbb{R}^{+*}$ donc on peut tout diviser par le membre de droite sans changer le sens de l'inégalité.
+  
+${alignTex([
+        ["", "", getStatementNode(identifiers).toTex()],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([frac(exp(nodeF), exp(nodeG)), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([exp(substract(nodeF, nodeG)), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([exp(nodeFMinusGSimplified), (1).toTree()], ineqType).toTex(),
+        ],
+        [
+            "",
+            `\\Leftrightarrow`,
+            new InequationNode([nodeFMinusGSimplified, (0).toTree()], ineqType).toTex(),
+        ],
+    ])}
+
+On résout l'inéquation : 
+
+$$
+${getAnswer(identifiers, opts)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { coeffsF, coeffsG, ineqType } = identifiers;
+    //random coeff signs for f and g
+    {
+        function getArrSign() {
+            return getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1])).filter((arrS) => !arrS.every((s) => s === 1));
+        }
+        getCartesiansProducts([getArrSign(), getArrSign()]).forEach(([arrSignF, arrSignG]) => {
+            try {
+                const coeffsFWrong = zip(arrSignF, coeffsF).map(([s, k]) => s * k);
+                const coeffsGWrong = zip(arrSignG, coeffsG).map(([s, k]) => s * k);
+                const identifiersWrong = {
+                    coeffsF: coeffsFWrong,
+                    coeffsG: coeffsGWrong,
+                    ineqType,
+                };
+                const texWrong = getAnswer(identifiersWrong, opts);
+                tryToAddWrongProp(propositions, texWrong);
+            }
+            catch (_) {
+                (() => { })();
+            }
+        });
+    }
+    //random ineqType
+    {
+        ["<", ">", "\\le", "\\ge"].forEach((inequalitySymbol) => {
+            try {
+                const identifiersWrong = {
+                    coeffsF,
+                    coeffsG,
+                    ineqType: inequalitySymbol,
+                };
+                const texWrong = getAnswer(identifiersWrong, opts);
+                tryToAddWrongProp(propositions, texWrong);
+            }
+            catch (_) {
+                (() => { })();
+            }
+        });
+    }
+    const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+    propWhile(propositions, n, () => {
+        const wrongRes = randint(-10, 11).toTree();
+        const wrongSymb = coinFlip()
+            ? ineqType
+            : InequationSymbolConstructor.reverse(ineqType);
+        const wrongIneq = new InequationNode(["x".toTree(), wrongRes], wrongSymb);
+        tryToAddWrongProp(propositions, isInterval
+            ? new InequationSolutionNode(wrongIneq.toInterval()).toTex()
+            : wrongIneq.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_identifiers, opts) => {
+    const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+    if (isInterval)
+        return [
+            "S",
+            "equal",
+            "lbracket",
+            "semicolon",
+            "rbracket",
+            "infty",
+            "varnothing",
+        ];
+    return [
+        "x",
+        "inf",
+        "sup",
+        "leq",
+        "geq",
+        "belongs",
+        "varnothing",
+        "lbracket",
+        "semicolon",
+        "rbracket",
+        "infty",
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    if (ans === answer) {
+        return true;
+    }
+    const { coeffsF, coeffsG } = identifiers;
+    const [a, _b, _c] = zip(coeffsF, coeffsG)
+        .map(([kF, kG]) => kF - kG)
+        .toReversed();
+    if (a !== 0) {
+        try {
+            const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+            if (isInterval) {
+                const parsed = unionIntervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+                if (!parsed)
+                    return false;
+                return "S=\\ " + parsed.simplify().toTex() === answer;
+            }
+            else {
+                const parsed = inequationParser(ans);
+                if (!parsed)
+                    return false;
+                return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+            }
+        }
+        catch (err) {
+            return handleVEAError(err);
+        }
+    }
+    else {
+        try {
+            const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+            if (isInterval) {
+                const parsed = intervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+                if (!parsed)
+                    return false;
+                return ("S=\\ " + parsed.simplify({ decimalToFractions: true }).toTex() ===
+                    answer);
+            }
+            else {
+                const parsed = inequationParser(ans);
+                if (!parsed)
+                    return false;
+                return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+            }
+        }
+        catch (err) {
+            return handleVEAError(err);
+        }
+    }
+};
+const getExpOfFEqualsExpOfGInequationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { functionTypeF, functionTypeG } = opts;
+    function degreeForFunctionType(functionType) {
+        switch (functionType) {
+            case "constante":
+                return 0;
+            case "degré $1$":
+                return 1;
+            case "degré $2$":
+                return 2;
+            default:
+                throw new Error("Unsupported functionType: " + functionType);
+        }
+    }
+    const [degreeF, degreeG] = [functionTypeF, functionTypeG].map(degreeForFunctionType);
+    function createCoeffs(degree) {
+        const c = randint(-10, 11, [0]);
+        const b = degree >= 1 ? randint(-10, 11, [0]) : 0;
+        const a = degree >= 2 ? randint(-10, 11, [0]) : 0;
+        return [c, b, a];
+    }
+    const [coeffsF, coeffsG] = [degreeF, degreeG].map(createCoeffs);
+    const ineqType = InequationSymbolConstructor.randomSymbol();
+    const identifiers = { coeffsF, coeffsG, ineqType };
+    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 optsDefault = {
+    inequationSolutionFormat: inequationSolutionFormat.defaultValue,
+    functionTypeF: "degré $1$",
+    functionTypeG: "degré $1$",
+};
+const options = [
+    inequationSolutionFormat,
+    {
+        id: "functionTypeF",
+        label: "Fonction $f$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeF,
+    },
+    {
+        id: "functionTypeG",
+        label: "Fonction $g$ :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["constante", "degré $1$", "degré $2$"],
+        defaultValue: optsDefault.functionTypeG,
+    },
+];
+export const expOfFEqualsExpOfGInequation = {
+    id: "expOfFEqualsExpOfGInequation",
+    connector: "\\iff",
+    label: "Résoudre une inéquation du type $e^{f(x)}<e^{g(x)}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfFEqualsExpOfGInequationQuestion(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/inequations/exp/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./expOfFEqualsExpOfGInequation.js";
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1 @@
+export * from "./expOfFEqualsExpOfGInequation.js";