math-exercises 3.0.157 → 3.0.159

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

@@ -0,0 +1,444 @@
+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";
+import { NamedIntervalIds, NamedIntervalNodeConstructor, } from "../../../../../tree/nodes/sets/namedIntervalNode.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 = NamedIntervalNodeConstructor.fromName(NamedIntervalIds.R);
+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'inéquation originale en une inéquation du type $e^{h(x)}=1$, puis résous cette iné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'inéquation originale pour se ramener au cas $e^{f(x)} < 1$.
+
+L'exponentielle est strictement positive sur $${intervalbbR.toTex()}$ 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([exp(nodeFMinusGSimplified), "e^{0}".toTree()], //hack pour éviter de me battre avec toTex etc.
+            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";

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAY9C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwLF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CActE,CAAC"}
+{"version":3,"file":"firstDegreeInequationsType3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAY9C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4LF,KAAK,OAAO,GAAG;IACb,wBAAwB,EAAE,MAAM,CAAC;CAClC,CAAC;AAGF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CActE,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.js

@@ -23,7 +23,7 @@ $$
 ${affine1.toTex()} ${ineqType} ${affine2.toTex()}
 $$`;
 };
-const getAnswer = (identifiers, opts) => {
+const 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);
@@ -33,10 +33,13 @@ const getAnswer = (identifiers, opts) => {
         .toTree();
     const invIneqType = new InequationSymbol(ineqType).reversed();
     const ineq = new InequationNode(["x".toTree(), result], coeff > 0 ? ineqType : invIneqType);
-    const answer = isInterval
-        ? new InequationSolutionNode(ineq.toInterval()).toTex()
-        : ineq.toTex();
-    return answer;
+    const node = isInterval
+        ? new InequationSolutionNode(ineq.toInterval())
+        : ineq;
+    return node;
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
 };
 // const getHint: GetHint<Identifiers, Options> = (identifiers, opts) => {
 //   return `Isole le terme $x$ dans le membre de gauche de l'inéquation. Attention : lorsqu'on multiplie (ou divise) les deux membres d'une inéquation par un nombre négatif, le sens de l'inéquation est inversé.`;
@@ -155,3 +158,6 @@ export const firstDegreeInequationsType3 = {
     options,
     getQuestionFromIdentifiers,
 };
+// export const reuseFirstDegreeInequationsType3 = {
+//   getAnswerNode,
+// };

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

@@ -8,4 +8,5 @@ export * from "./inequationsSign.js";
 export * from "./minNumberInequality.js";
 export * from "./isInequalityTrue.js";
 export * from "./inverseInequalityWithGraph.js";
+export * from "./exp/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC"}

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

@@ -8,3 +8,4 @@ export * from "./inequationsSign.js";
 export * from "./minNumberInequality.js";
 export * from "./isInequalityTrue.js";
 export * from "./inverseInequalityWithGraph.js";
+export * from "./exp/index.js";

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAyFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAiKF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.js

@@ -18,9 +18,6 @@ $$
 f(x) = ${fct.toTex()}
 $$`;
 };
-const getAnswer = (identifiers) => {
-    return getAnswerNode(identifiers).toTex();
-};
 const getAnswerNode = (identifiers) => {
     const { affine1Coeffs, affine2Coeffs } = identifiers;
     const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
@@ -29,25 +26,75 @@ const getAnswerNode = (identifiers) => {
     const deriv = new MultiplyNode(new Affine(affine2.a * affine1.a, affine1.a + affine2.a * affine1.b).toTree(), exp);
     return deriv.simplify();
 };
-const getExpDerivativeFourQuestion = () => {
-    const affine1 = AffineConstructor.random();
-    const affine2 = AffineConstructor.random();
-    const identifiers = {
-        affine1Coeffs: affine1.coefficients,
-        affine2Coeffs: affine2.coefficients,
-    };
-    //ae^cx+d  + c(ax+b)e^cx+d = (a+c(ax+b))e^cx+d = (cax + a +cb) e^cx+d
-    return getQuestionFromIdentifiers(identifiers);
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: ["x", "epower", "exp"],
-        answerFormat: "tex",
-        identifiers,
-    };
-    return question;
+const getHint = () => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables, alors : 
+
+$$
+(uv)'(x) = u'(x)v(x) + u(x)v'(x)
+$$
+
+Si $w$ est une fonction dérivable alors :
+
+$$
+(e^{w(x)})'(x) = w'(x) \\times e^{w(x)}
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    return `Si $u$ et $v$ sont deux fonctions dérivables, alors : 
+
+$$
+(uv)'(x) = u'(x)v(x) + u(x)v'(x)
+$$
+
+Ici : 
+
+$$
+u(x) = ${affine1.toTex()}
+$$
+
+$$
+v(x) = e^{${affine2.toTex()}}
+$$
+
+$$
+u'(x) = ${affine1.toTree().derivative().simplify().toTex()}
+$$
+
+$$
+v'(x) = ${affine2
+        .toTree()
+        .derivative()
+        .simplify()
+        .toTex()} \\times e^{${affine2.toTex()}}
+$$
+
+Donc :
+
+$$
+f'(x) = ${affine1
+        .toTree()
+        .derivative()
+        .simplify()
+        .toTex()} \\times e^{${affine2.toTex()}} +  (${affine1.toTex()}) \\times (${affine2
+        .toTree()
+        .derivative()
+        .simplify()
+        .toTex()} \\times e^{${affine2.toTex()}})
+$$
+
+$$
+f'(x) = ${getAnswer(identifiers)}
+$$
+
+`;
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -69,6 +116,28 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
         return handleVEAError(err);
     }
 };
+const getExpDerivativeFourQuestion = () => {
+    const affine1 = AffineConstructor.random();
+    const affine2 = AffineConstructor.random();
+    const identifiers = {
+        affine1Coeffs: affine1.coefficients,
+        affine2Coeffs: affine2.coefficients,
+    };
+    //ae^cx+d  + c(ax+b)e^cx+d = (a+c(ax+b))e^cx+d = (cax + a +cb) e^cx+d
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "epower", "exp"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
 export const expDerivativeFour = {
     id: "expDerivativeFour",
     connector: "=",
@@ -83,4 +152,5 @@ export const expDerivativeFour = {
     getInstruction,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8IF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}