math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/functions/logarithm/findLargestPossibleDomainOfLogF.js

@@ -0,0 +1,622 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { EmptySet } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+const createDictNodeIds = (dictNode) => {
+    return Object.entries(dictNode).reduce((acc, [key, node]) => {
+        const nodeIds = node.toIdentifiers();
+        return { ...acc, [key]: nodeIds };
+    }, {});
+};
+const createDictNode = (dictNodeIds) => {
+    return Object.entries(dictNodeIds).reduce((acc, [key, nodeIds]) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        return { ...acc, [key]: node };
+    }, {});
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, typeF, dictNodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const dictNode = createDictNode(dictNodeIds);
+    const nodeVarX = new VariableNode("x");
+    const [arrNodeIneq, nodeInterval] = (() => {
+        switch (typeF) {
+            case "$x \\mapsto k(x-a)$": {
+                const { k: nodeK, a: nodeA } = dictNode;
+                const nodeXMinusA = substract(nodeVarX, nodeA).simplify();
+                const arrNodeIneq = [
+                    new InequationNode([nodeF, (0).toTree()], ">"),
+                    new InequationNode([nodeXMinusA, (0).toTree()], nodeK.evaluate() > 0 ? ">" : "<"),
+                    new InequationNode([nodeVarX, nodeA], nodeK.evaluate() > 0 ? ">" : "<"),
+                ];
+                const nodeInterval = (() => {
+                    const [nodeIneq] = arrNodeIneq.slice(-1);
+                    return nodeIneq.toInterval();
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto k(x-a)(x-b)$": {
+                const { k: nodeK, a: nodeA, b: nodeB } = dictNode;
+                const nodeXMinusA = substract(nodeVarX, nodeA).simplify();
+                const nodeXMinusB = substract(nodeVarX, nodeB).simplify();
+                const arrNodeIneq = (() => {
+                    return [
+                        new InequationNode([nodeF, (0).toTree()], ">"),
+                        new InequationNode([multiply(nodeXMinusA, nodeXMinusB), (0).toTree()], nodeK.evaluate() > 0 ? ">" : "<"),
+                    ];
+                })();
+                const nodeInterval = (() => {
+                    const [nodeRoot1, nodeRoot2] = [nodeA, nodeB].toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+                    if (nodeK.evaluate() > 0) {
+                        return new IntervalNode(MinusInfinityNode, nodeRoot1, ClosureType.OO).union(new IntervalNode(nodeRoot2, PlusInfinityNode, ClosureType.OO));
+                    }
+                    else {
+                        return new IntervalNode(nodeRoot1, nodeRoot2, ClosureType.OO);
+                    }
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto k(x-a)(x-b)(x-c)$": {
+                const { k: nodeK, a: nodeA, b: nodeB, c: nodeC } = dictNode;
+                const nodeXMinusA = substract(nodeVarX, nodeA).simplify();
+                const nodeXMinusB = substract(nodeVarX, nodeB).simplify();
+                const nodeXMinusC = substract(nodeVarX, nodeC).simplify();
+                const arrNodeIneq = (() => {
+                    return [
+                        new InequationNode([nodeF, (0).toTree()], ">"),
+                        new InequationNode([
+                            multiply(nodeXMinusA, multiply(nodeXMinusB, nodeXMinusC)),
+                            (0).toTree(),
+                        ], nodeK.evaluate() > 0 ? ">" : "<"),
+                    ];
+                })();
+                const nodeInterval = (() => {
+                    const [nodeRoot1, nodeRoot2, nodeRoot3] = [
+                        nodeA,
+                        nodeB,
+                        nodeC,
+                    ].toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+                    if (nodeK.evaluate() > 0) {
+                        return new IntervalNode(nodeRoot1, nodeRoot2, ClosureType.OO).union(new IntervalNode(nodeRoot3, PlusInfinityNode, ClosureType.OO));
+                    }
+                    else {
+                        return new IntervalNode(MinusInfinityNode, nodeRoot1, ClosureType.OO).union(new IntervalNode(nodeRoot2, nodeRoot3, ClosureType.OO));
+                    }
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto a \\sqrt{x} + b$": {
+                const { a: nodeA, b: nodeB } = dictNode;
+                const nodeG = sqrt(nodeVarX);
+                const nodeLhs = multiply(nodeA, nodeG).simplify();
+                //a sqrt(x) + b > 0
+                //a sqrt(x)     > -b
+                //a > 0 :
+                //  sqrt(x)     > -b/a
+                //        x     > (-b/a)^2
+                const arrNodeIneq = [
+                    new InequationNode([nodeF, (0).toTree()], ">"),
+                    new InequationNode([nodeLhs, opposite(nodeB)], ">"),
+                    new InequationNode([nodeG, frac(opposite(nodeB), nodeA).simplify()], nodeA.evaluate() > 0 ? ">" : "<"),
+                    new InequationNode([nodeVarX, square(frac(opposite(nodeB), nodeA).simplify())], nodeA.evaluate() > 0 ? ">" : "<"),
+                ];
+                const nodeInterval = (() => {
+                    const [nodeIneq] = arrNodeIneq.slice(-1);
+                    return nodeIneq.toInterval();
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto a \\ln(x) + b$": {
+                const { a: nodeA, b: nodeB } = dictNode;
+                const nodeG = new LogNode(nodeVarX);
+                const nodeLhs = multiply(nodeA, nodeG).simplify();
+                //a ln(x) + b > 0
+                //a ln(x)     > -b
+                //a > 0 :
+                //  ln(x)     > -b/a
+                //     x      > exp(-b/a)   && 0 < x
+                const arrNodeIneq = [
+                    new InequationNode([nodeF, (0).toTree()], ">"),
+                    new InequationNode([nodeLhs, opposite(nodeB)], ">"),
+                    new InequationNode([nodeG, frac(opposite(nodeB), nodeA).simplify()], nodeA.evaluate() > 0 ? ">" : "<"),
+                    nodeA.evaluate() > 0
+                        ? new InequationNode([nodeVarX, exp(frac(opposite(nodeB), nodeA).simplify())], ">")
+                        : new InequationNode([
+                            (0).toTree(),
+                            nodeVarX,
+                            exp(frac(opposite(nodeB), nodeA).simplify()),
+                        ], "<"),
+                ];
+                const nodeInterval = (() => {
+                    const [nodeIneq] = arrNodeIneq.slice(-1);
+                    return nodeIneq.toInterval();
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto a e^{x} + b$": {
+                const { a: nodeA, b: nodeB } = dictNode;
+                const nodeG = exp(nodeVarX);
+                const nodeLhs = multiply(nodeA, nodeG).simplify();
+                //a exp(x) + b > 0
+                //a exp(x)     > -b
+                //a > 0 :
+                //  exp(x)     > -b/a
+                //        x in \\mathbb{R}
+                //a < 0 :
+                //  exp(x)     < -b/a
+                //b > 0 :  x   < ln(-b/a)
+                //b < 0 :  x in varnothing
+                const arrNodeIneq = [
+                    new InequationNode([nodeF, (0).toTree()], ">"),
+                    new InequationNode([nodeLhs, opposite(nodeB).simplify()], ">"),
+                    new InequationNode([nodeG, frac(opposite(nodeB), nodeA).simplify()], nodeA.evaluate() > 0 ? ">" : "<"),
+                    ...(() => {
+                        if (nodeA.evaluate() > 0) {
+                            if (nodeB.evaluate() > 0) {
+                                return [];
+                            }
+                            else {
+                                return [
+                                    new InequationNode([
+                                        nodeVarX,
+                                        new LogNode(frac(opposite(nodeB), nodeA).simplify()),
+                                    ], nodeA.evaluate() > 0 ? ">" : "<"),
+                                ];
+                            }
+                        }
+                        else {
+                            if (nodeB.evaluate() > 0) {
+                                return [
+                                    new InequationNode([
+                                        nodeVarX,
+                                        new LogNode(frac(opposite(nodeB), nodeA).simplify()),
+                                    ], nodeA.evaluate() > 0 ? ">" : "<"),
+                                ];
+                            }
+                            else {
+                                return [];
+                            }
+                        }
+                    })(),
+                ];
+                const nodeInterval = (() => {
+                    if (nodeA.evaluate() > 0) {
+                        if (nodeB.evaluate() > 0) {
+                            return new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO);
+                        }
+                        else {
+                            const [nodeIneq] = arrNodeIneq.slice(-1);
+                            return nodeIneq.toInterval();
+                        }
+                    }
+                    else {
+                        if (nodeB.evaluate() > 0) {
+                            const [nodeIneq] = arrNodeIneq.slice(-1);
+                            return nodeIneq.toInterval();
+                        }
+                        else {
+                            return EmptySet;
+                        }
+                    }
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            case "$x \\mapsto \\frac{a}{x} + b$": {
+                const { a: nodeA, b: nodeB } = dictNode;
+                const nodeLhs = frac(nodeA, nodeVarX);
+                //a / x + b > 0
+                //a / x     > -b
+                //a > 0 :
+                //  1/x     > -b/a
+                //    x     < a/(-b)
+                const arrNodeIneq = [
+                    new InequationNode([nodeF, (0).toTree()], ">"),
+                    new InequationNode([nodeLhs, opposite(nodeB)], ">"),
+                    new InequationNode([frac(1, nodeVarX), frac(opposite(nodeB), nodeA).simplify()], nodeA.evaluate() > 0 ? ">" : "<"),
+                    new InequationNode([nodeVarX, frac(nodeA, opposite(nodeB)).simplify()], nodeA.evaluate() > 0 ? "<" : ">"),
+                ];
+                const nodeInterval = (() => {
+                    const [nodeIneq] = arrNodeIneq.slice(-1);
+                    return nodeIneq.toInterval();
+                })();
+                return [arrNodeIneq, nodeInterval];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return {
+        nodeF,
+        dictNode,
+        typeF,
+        arrNodeIneq,
+        nodeInterval,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `Déterminer l'ensemble de définition de la fonction $h$ définie par : 
+
+$$
+h(x) = \\ln(${nodeF.toTex()})
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeInterval } = getHydrated(identifiers);
+    return nodeInterval.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `La fonction $x \\mapsto \\ln(x)$ est définie sur $]0;+\\infty[$. 
+Détermine donc les intervalles sur lesquels $x \\mapsto ${nodeF.toTex()}$ est strictement positive.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeF, arrNodeIneq, nodeInterval } = getHydrated(identifiers);
+    return `La fonction $x \\mapsto \\ln(x)$ est définie sur $]0;+\\infty[$. 
+On va donc déterminer les intervalles sur lesquels $x \\mapsto ${nodeF.toTex()}$ est strictement positive.
+
+${alignTex(arrNodeIneq.map((nodeIneq, i) => {
+        const texPrefix = i === 0 ? "\\ \\ " : "\\Leftrightarrow";
+        const [ineqSymbol] = nodeIneq.symbols;
+        return [texPrefix, ...splitAndKeep(nodeIneq.toTex(), ineqSymbol)];
+    }))}
+
+L'ensemble de définition de $h$ est donc :
+
+$$
+${nodeInterval.toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { dictNode, typeF } = getHydrated(identifiers);
+    //student: ln(f(x)) -> ln(x)
+    {
+        const nodeIntervalWrong = new IntervalNode((0).toTree(), PlusInfinityNode, ClosureType.OO);
+        tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+    }
+    const { k: nodeK, a: nodeA, b: nodeB, c: nodeC } = dictNode;
+    //function-specific
+    {
+        switch (typeF) {
+            case "$x \\mapsto k(x-a)$":
+                {
+                    const dictNodeWrong = {
+                        ...dictNode,
+                        k: opposite(nodeK).simplify(),
+                    };
+                    const identifiersWrong = {
+                        ...identifiers,
+                        dictNodeIds: createDictNodeIds(dictNodeWrong),
+                    };
+                    const { nodeInterval: nodeIntervalWrong } = getHydrated(identifiersWrong);
+                    tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+                }
+                break;
+            case "$x \\mapsto k(x-a)(x-b)$":
+            case "$x \\mapsto k(x-a)(x-b)(x-c)$":
+                {
+                    {
+                        const dictNodeWrong = {
+                            ...dictNode,
+                            k: opposite(nodeK).simplify(),
+                        };
+                        const identifiersWrong = {
+                            ...identifiers,
+                            dictNodeIds: createDictNodeIds(dictNodeWrong),
+                        };
+                        const { nodeInterval: nodeIntervalWrong } = getHydrated(identifiersWrong);
+                        tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+                    }
+                    {
+                        const dictNodeWrong = {
+                            ...dictNode,
+                            ...(nodeA ? { a: abs(nodeA).simplify() } : {}),
+                            ...(nodeB ? { b: abs(nodeB).simplify() } : {}),
+                            ...(nodeC ? { c: abs(nodeC).simplify() } : {}),
+                        };
+                        const identifiersWrong = {
+                            ...identifiers,
+                            dictNodeIds: createDictNodeIds(dictNodeWrong),
+                        };
+                        const { nodeInterval: nodeIntervalWrong } = getHydrated(identifiersWrong);
+                        tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+                    }
+                    {
+                        const dictNodeWrong = {
+                            ...dictNode,
+                            k: opposite(nodeK).simplify(),
+                            ...(nodeA ? { a: abs(nodeA).simplify() } : {}),
+                            ...(nodeB ? { b: abs(nodeB).simplify() } : {}),
+                            ...(nodeC ? { c: abs(nodeC).simplify() } : {}),
+                        };
+                        const identifiersWrong = {
+                            ...identifiers,
+                            dictNodeIds: createDictNodeIds(dictNodeWrong),
+                        };
+                        const { nodeInterval: nodeIntervalWrong } = getHydrated(identifiersWrong);
+                        tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    //messing with coeffs
+    {
+        const identityOrOpposite = (node) => coinFlip() ? node : opposite(node).simplify();
+        [...Array(16).keys()].forEach(() => {
+            const dictNodeWrong = {
+                ...dictNode,
+                ...(nodeK ? { k: identityOrOpposite(nodeK) } : {}),
+                ...(nodeA ? { a: identityOrOpposite(nodeA) } : {}),
+                ...(nodeB ? { b: identityOrOpposite(nodeB) } : {}),
+                ...(nodeC ? { c: identityOrOpposite(nodeC) } : {}),
+            };
+            const identifiersWrong = {
+                ...identifiers,
+                dictNodeIds: createDictNodeIds(dictNodeWrong),
+            };
+            const { nodeInterval: nodeIntervalWrong } = getHydrated(identifiersWrong);
+            if (propositions.length < n) {
+                tryToAddWrongProp(propositions, nodeIntervalWrong.toTex());
+            }
+        });
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers(typeF);
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [
+        "x",
+        "equal",
+        "lnBrackets",
+        "e",
+        "epower",
+        "lbracket",
+        "S",
+        "semicolon",
+        "rbracket",
+        "varnothing",
+        "infty",
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        //S=\ \varnothing
+        {
+            const answerRefined = answer.replace("\\ ", "");
+            if (ans === answerRefined) {
+                return true;
+            }
+        }
+        //else
+        const [arrNodeIntervalAns, arrNodeIntervalAnswer] = [ans, answer].map((str) => {
+            const arrStrInterval = str.split("\\cup");
+            const arrNodeInterval = arrStrInterval.map((str) => intervalParser(str));
+            return arrNodeInterval;
+        });
+        if (arrNodeIntervalAns.length !== arrNodeIntervalAnswer.length) {
+            return false;
+        }
+        if (arrNodeIntervalAns.some((elt) => elt === false) ||
+            arrNodeIntervalAnswer.some((elt) => elt === false)) {
+            return false;
+        }
+        // console.log(
+        //   "arrNodeIntervalAns",
+        //   (arrNodeIntervalAns as IntervalNode[]).map((nodeInterval) => {
+        //     return {
+        //       a: nodeInterval.a.toTex(),
+        //       b: nodeInterval.b.toTex(),
+        //     };
+        //   }),
+        // );
+        // console.log(
+        //   "arrNodeIntervalAnswer",
+        //   (arrNodeIntervalAnswer as IntervalNode[]).map((nodeInterval) => {
+        //     return {
+        //       a: nodeInterval.a.toTex(),
+        //       b: nodeInterval.b.toTex(),
+        //     };
+        //   }),
+        // );
+        return zip(arrNodeIntervalAns, arrNodeIntervalAnswer).every(([nodeIntervalAns, nodeIntervalAnswer]) => {
+            return zip([nodeIntervalAns.a, nodeIntervalAns.b], [nodeIntervalAnswer.a, nodeIntervalAnswer.b]).every(([nodeAns, nodeAnswer]) => NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+                NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+        });
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = (typeF) => {
+    const nodeVarX = new VariableNode("x");
+    const [nodeF, dictNode] = (() => {
+        switch (typeF) {
+            case "$x \\mapsto k(x-a)$": {
+                const k = randint(-8, 9, [0, 1]);
+                const a = randint(-10, 11, [0]);
+                const nodeF = multiply(k, substract(nodeVarX, a).simplify());
+                const dictNode = {
+                    k: k.toTree(),
+                    a: a.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto k(x-a)(x-b)$": {
+                const k = randint(-8, 9, [0, 1]);
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0, a]);
+                const nodeF = multiply(k, multiply(substract(nodeVarX, a).simplify(), substract(nodeVarX, b).simplify()));
+                const dictNode = {
+                    k: k.toTree(),
+                    a: a.toTree(),
+                    b: b.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto k(x-a)(x-b)(x-c)$": {
+                const k = randint(-8, 9, [0, 1]);
+                const a = randint(-10, 11, [0]);
+                const b = randint(-10, 11, [0, a]);
+                const c = randint(-10, 11, [0, a, b]);
+                const nodeF = multiply(k, multiply(substract(nodeVarX, a).simplify(), multiply(substract(nodeVarX, b).simplify(), substract(nodeVarX, c).simplify())));
+                const dictNode = {
+                    k: k.toTree(),
+                    a: a.toTree(),
+                    b: b.toTree(),
+                    c: c.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto a \\sqrt{x} + b$": {
+                const a = randint(-8, 9, [0, 1]);
+                const b = randint(-10, 11, [0, a]);
+                const nodeF = add(multiply(a, sqrt(nodeVarX)), b);
+                const dictNode = {
+                    a: a.toTree(),
+                    b: b.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto a \\ln(x) + b$": {
+                const a = randint(-8, 9, [0, 1]);
+                const b = randint(-10, 11, [0, a]);
+                const nodeF = add(multiply(a, new LogNode(nodeVarX)), b);
+                const dictNode = {
+                    a: a.toTree(),
+                    b: b.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto a e^{x} + b$": {
+                const a = randint(-8, 9, [0, 1]);
+                const b = randint(-10, 11, [0, a]);
+                const nodeF = add(multiply(a, exp(nodeVarX)), b);
+                const dictNode = {
+                    a: a.toTree(),
+                    b: b.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            case "$x \\mapsto \\frac{a}{x} + b$": {
+                const a = randint(-8, 9, [0, 1]);
+                const b = randint(-10, 11, [0, a]);
+                const nodeF = add(frac(a, nodeVarX), b);
+                const dictNode = {
+                    a: a.toTree(),
+                    b: b.toTree(),
+                };
+                return [nodeF, dictNode];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const dictNodeIds = createDictNodeIds(dictNode);
+    const identifiers = {
+        dictNodeIds,
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+    };
+    return identifiers;
+};
+const getFindLargestPossibleDomainOfLogFQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        typeF: random(arrayedOpts.typeF),
+    };
+    const identifiers = createRandomIdentifiers(opts.typeF);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "$x \\mapsto k(x-a)$",
+        "$x \\mapsto k(x-a)(x-b)$",
+        "$x \\mapsto a \\sqrt{x} + b$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "$x \\mapsto k(x-a)$",
+            "$x \\mapsto k(x-a)(x-b)$",
+            "$x \\mapsto k(x-a)(x-b)(x-c)$",
+            "$x \\mapsto a \\sqrt{x} + b$",
+            "$x \\mapsto a \\ln(x) + b$",
+            "$x \\mapsto a e^{x} + b$",
+            "$x \\mapsto \\frac{a}{x} + b$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const findLargestPossibleDomainOfLogF = {
+    id: "findLargestPossibleDomainOfLogF",
+    connector: "=",
+    label: "Déterminer l'ensemble de définition d'une fonction du type $ln(u)$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindLargestPossibleDomainOfLogFQuestion(opts), nb),
+    options,
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/logarithm/index.d.ts

@@ -4,4 +4,9 @@ export * from "./log10PowerSimplifying.js";
 export * from "./logPowerEquation.js";
 export * from "./log10Simplifying.js";
 export * from "./powerEquation.js";
+export * from "./logLinearCombinationSimplifiying.js";
+export * from "./logEquationLnAXPlusBEqualsK.js";
+export * from "./logInequationIntegerSolutions.js";
+export * from "./logInequationLnAXPlusBInfK.js";
+export * from "./findLargestPossibleDomainOfLogF.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/logarithm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uCAAuC,CAAC;AACtD,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,iCAAiC,CAAC;AAChD,cAAc,sCAAsC,CAAC"}

package/lib/exercises/math/functions/logarithm/index.js

@@ -4,3 +4,8 @@ export * from "./log10PowerSimplifying.js";
 export * from "./logPowerEquation.js";
 export * from "./log10Simplifying.js";
 export * from "./powerEquation.js";
+export * from "./logLinearCombinationSimplifiying.js";
+export * from "./logEquationLnAXPlusBEqualsK.js";
+export * from "./logInequationIntegerSolutions.js";
+export * from "./logInequationLnAXPlusBInfK.js";
+export * from "./findLargestPossibleDomainOfLogF.js";

package/lib/exercises/math/functions/logarithm/logEquationLnAXPlusBEqualsK.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+/**ln(ax+b)=k */
+type Identifiers = {
+    a: number;
+    b: number;
+    k: number;
+};
+export declare const logEquationLnAXPlusBEqualsK: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logEquationLnAXPlusBEqualsK.d.ts.map

package/lib/exercises/math/functions/logarithm/logEquationLnAXPlusBEqualsK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logEquationLnAXPlusBEqualsK.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/logEquationLnAXPlusBEqualsK.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAwBrC,gBAAgB;AAChB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoMF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}