math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/integration/integralOfPiecewiseFunctionByUsingComputedIntegrals.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsBoundsABC: NodeIdentifiers[];
+    nodeIdsIntegralAB: NodeIdentifiers;
+    nodeIdsIntegralBC: NodeIdentifiers;
+    nodeIdsVariableOfIntegration: NodeIdentifiers;
+};
+type Options = {
+    texIneqABC: string;
+};
+export declare const integralOfPiecewiseFunctionByUsingComputedIntegrals: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=integralOfPiecewiseFunctionByUsingComputedIntegrals.d.ts.map

package/lib/exercises/math/integration/integralOfPiecewiseFunctionByUsingComputedIntegrals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integralOfPiecewiseFunctionByUsingComputedIntegrals.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/integration/integralOfPiecewiseFunctionByUsingComputedIntegrals.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,iBAAiB,EAAE,eAAe,CAAC;IACnC,iBAAiB,EAAE,eAAe,CAAC;IACnC,4BAA4B,EAAE,eAAe,CAAC;CAC/C,CAAC;AAyQF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAiBF,eAAO,MAAM,mDAAmD,EAAE,QAAQ,CACxE,WAAW,EACX,OAAO,CAqBR,CAAC"}

package/lib/exercises/math/integration/integralOfPiecewiseFunctionByUsingComputedIntegrals.js

@@ -0,0 +1,222 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { IntegralNode } from "../../../tree/nodes/functions/integralNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { zip } from "../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsBoundsABC, nodeIdsIntegralAB, nodeIdsIntegralBC, nodeIdsVariableOfIntegration, } = identifiers;
+    const [nodeBoundA, nodeBoundB, nodeBoundC, nodeIntegralABForResult, nodeIntegralBCForResult, nodeVariableOfIntegration,] = [
+        ...nodeIdsBoundsABC,
+        nodeIdsIntegralAB,
+        nodeIdsIntegralBC,
+        nodeIdsVariableOfIntegration,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeIntegralACForResult = add(nodeIntegralABForResult, nodeIntegralBCForResult);
+    const nameVarOfIntegration = nodeVariableOfIntegration.toTex();
+    const nodeF = new VariableNode(`f(${nameVarOfIntegration})`);
+    const [nodeIntegralABForTex, nodeIntegralBCForTex, nodeIntegralACForTex] = [
+        [nodeBoundA, nodeBoundB],
+        [nodeBoundB, nodeBoundC],
+        [nodeBoundA, nodeBoundC],
+    ].map(([nodeBoundLow, nodeBoundHigh]) => new IntegralNode(nodeF, nodeBoundLow, nodeBoundHigh, nameVarOfIntegration));
+    return {
+        nodeBoundA,
+        nodeBoundB,
+        nodeBoundC,
+        nodeIntegralABForTex,
+        nodeIntegralBCForTex,
+        nodeIntegralACForTex,
+        nodeIntegralABForResult,
+        nodeIntegralBCForResult,
+        nodeIntegralACForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegralABForTex, nodeIntegralABForResult, nodeIntegralBCForTex, nodeIntegralBCForResult, nodeIntegralACForTex, } = getHydrated(identifiers);
+    return `Soit $f$ une fonction intégrable sur $\\mathbb{R}$.
+
+On donne :
+  
+${alignTex(zip([nodeIntegralABForTex, nodeIntegralBCForTex], [nodeIntegralABForResult, nodeIntegralBCForResult]).map(([nodeIntegralForTex, nodeIntegralForResult]) => [
+        nodeIntegralForTex.toTex(),
+        "=",
+        nodeIntegralForResult.toTex(),
+    ]))}
+
+Calculer :
+
+$$
+${nodeIntegralACForTex.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegralACForResult } = getHydrated(identifiers);
+    return nodeIntegralACForResult.simplify({ towardsDistribute: true }).toTex();
+};
+const getHint = () => {
+    return `Soit $g$ une fonction intégrable sur $\\mathbb{R}$.
+Soient $a$, $b$ et $c$ trois réels.
+
+D'après la relation de Chasles, on a :
+
+$$
+\\int_{a}^{c} g = \\int_{a}^{b} g + \\int_{b}^{c} g
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralABForTex, nodeIntegralBCForTex, nodeIntegralACForTex, nodeIntegralACForResult, } = getHydrated(identifiers);
+    return `D'après la relation de Chasles, on a :
+
+${alignTex([
+        [
+            nodeIntegralACForTex.toTex(),
+            "=",
+            `${nodeIntegralABForTex.toTex()} + ${nodeIntegralBCForTex.toTex()}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralACForResult.toTex({
+                forceNoSimplification: true,
+                explicitNumberWriting: true,
+            }),
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralACForResult.simplify({ towardsDistribute: true }).toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeIntegralABForResult, nodeIntegralBCForResult } = getHydrated(identifiers);
+    //student: +-\\int_{a}^{b} +-\\int_{b}^{c}
+    [
+        [-1, +1],
+        [+1, -1],
+        [-1, -1],
+    ].forEach(([valueFactorAB, valueFactorBC]) => {
+        const nodeACWrong = add(multiply(valueFactorAB, nodeIntegralABForResult), multiply(valueFactorBC, nodeIntegralBCForResult));
+        tryToAddWrongProp(propositions, nodeACWrong.simplify({ towardsDistribute: true }).toTex());
+    });
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const [nodeA, nodeB, nodeC] = (() => {
+        const generateValue = (function* () {
+            const arrValue = [...Array(30).keys()].map((i) => i - 15);
+            yield* shuffle(arrValue);
+        })();
+        const [node1, node2, node3] = [...Array(3).keys()]
+            .map(() => generateValue.next().value)
+            .toSorted((v1, v2) => v1 - v2)
+            .map((v) => v.toTree());
+        switch (opts.texIneqABC) {
+            case "a<b<c":
+                return [node1, node2, node3];
+            case "a<c<b":
+                return [node1, node3, node2];
+            case "b<a<c":
+                return [node2, node1, node3];
+            default:
+                throw new Error("Unsupported opts.texIneqABC: " + opts.texIneqABC);
+        }
+    })();
+    const nodeIntegralAB = randint(-10, 11, [0]).toTree();
+    const nodeIntegralBC = randint(-10, 11, [0]).toTree();
+    const nodeVariableOfIntegration = random([
+        "x",
+        "t",
+        "u",
+    ]).toTree();
+    const identifiers = {
+        nodeIdsBoundsABC: [nodeA, nodeB, nodeC].map((node) => node.toIdentifiers()),
+        nodeIdsIntegralAB: nodeIntegralAB.toIdentifiers(),
+        nodeIdsIntegralBC: nodeIntegralBC.toIdentifiers(),
+        nodeIdsVariableOfIntegration: nodeVariableOfIntegration.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getIntegralOfPiecewiseFunctionByUsingComputedIntegralsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    texIneqABC: "a<b<c",
+};
+const options = [
+    {
+        id: "texIneqABC",
+        label: "ordre croissant des bornes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["a<b<c", "a<c<b", "b<a<c"],
+        defaultValue: optsDefault.texIneqABC,
+    },
+];
+export const integralOfPiecewiseFunctionByUsingComputedIntegrals = {
+    id: "integralOfPiecewiseFunctionByUsingComputedIntegrals",
+    connector: "=",
+    label: "Relation de Chasles : Calculer $\\int_a^c f$ à partir de $\\int_a^b f$ et $\\int_b^c f$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfPiecewiseFunctionByUsingComputedIntegralsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/frac1XTimesALogXPlusBLimit.d.ts

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

package/lib/exercises/math/limits/frac1XTimesALogXPlusBLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frac1XTimesALogXPlusBLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/frac1XTimesALogXPlusBLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

package/lib/exercises/math/limits/frac1XTimesALogXPlusBLimit.js

@@ -0,0 +1,121 @@
+import { addValidProp, 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 { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+const getHydrated = (identifiers) => {
+    const { a, b } = identifiers;
+    const nodeVarX = new VariableNode("x");
+    const nodeF = frac(add(multiply(a, new LogNode(nodeVarX)), b), nodeVarX);
+    const nodeFPart1 = frac(multiply(a, new LogNode(nodeVarX)), nodeVarX);
+    const nodeFPart2 = frac(b, nodeVarX);
+    return {
+        nodeF,
+        nodeFPart1,
+        nodeFPart2,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeF } = getHydrated(identifiers);
+    return `Déterminer la limite en $+\\infty$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$`;
+};
+const getAnswer = () => {
+    return (0).frenchify();
+};
+const getHint = (_identifiers) => {
+    return `Utilise la propriété suivante :
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} \\frac{\\ln(x)}{x} = 0
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeF, nodeFPart1, nodeFPart2 } = getHydrated(identifiers);
+    return `On pose :
+
+$$
+l_1 = \\displaystyle \\lim_{x \\to +\\infty} ${nodeFPart1.toTex()} = 0
+$$
+
+$$
+l_2 = \\displaystyle \\lim_{x \\to +\\infty} ${nodeFPart2.toTex()} = 0
+$$
+
+On utilise la linéarité de la limite : 
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeF.toTex()} = l_1 + l_2 = 0
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b } = identifiers;
+    //student: +\\infty
+    tryToAddWrongProp(propositions, (a > 0 ? PlusInfinityNode : MinusInfinityNode).toTex());
+    tryToAddWrongProp(propositions, a.frenchify());
+    tryToAddWrongProp(propositions, b.frenchify());
+    tryToAddWrongProp(propositions, exp(frac(opposite(b).simplify(), a).simplify()).toTex());
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["lnBrackets", "infty", "epower"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+        NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+};
+const createRandomIdentifiers = () => {
+    const a = randint(-100, 101, [0]);
+    const b = randint(-10, 11, [0, a]);
+    const identifiers = { a, b };
+    return identifiers;
+};
+const getFrac1XTimesALogXPlusBLimitQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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;
+};
+export const frac1XTimesALogXPlusBLimit = {
+    id: "frac1XTimesALogXPlusBLimit",
+    connector: "\\iff",
+    label: "Limite de $\\frac{a \\ln(x) + b}{x}$ en $+\\infty$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getFrac1XTimesALogXPlusBLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/index.d.ts

@@ -8,4 +8,7 @@ export * from "./sequencePolynomNoFILimit.js";
 export * from "./sequencePolynomProductLimit.js";
 export * from "./sequenceRationalFracLimit.js";
 export * from "./limitReading.js";
+export * from "./frac1XTimesALogXPlusBLimit.js";
+export * from "./kLogXPlusTrinomLimit.js";
+export * from "./logOfPolynomialLimit.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/limits/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC"}

package/lib/exercises/math/limits/index.js

@@ -8,3 +8,6 @@ export * from "./sequencePolynomNoFILimit.js";
 export * from "./sequencePolynomProductLimit.js";
 export * from "./sequenceRationalFracLimit.js";
 export * from "./limitReading.js";
+export * from "./frac1XTimesALogXPlusBLimit.js";
+export * from "./kLogXPlusTrinomLimit.js";
+export * from "./logOfPolynomialLimit.js";

package/lib/exercises/math/limits/kLogXPlusTrinomLimit.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    k: number;
+    nodeIdsCoeffP: NodeIdentifiers[];
+};
+type Options = {
+    isIndeterminateForm: boolean;
+};
+export declare const kLogXPlusTrinomLimit: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=kLogXPlusTrinomLimit.d.ts.map

package/lib/exercises/math/limits/kLogXPlusTrinomLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kLogXPlusTrinomLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/kLogXPlusTrinomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAiPF,KAAK,OAAO,GAAG;IACb,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAgBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe/D,CAAC"}

package/lib/exercises/math/limits/kLogXPlusTrinomLimit.js

@@ -0,0 +1,224 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { createNodeFPolynomialFromCoeffs } from "../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { LogNode } from "../../../tree/nodes/functions/logNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../tree/nodes/numbers/infiniteNode.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { k, nodeIdsCoeffP } = identifiers;
+    const nodeVarX = new VariableNode("x");
+    const [nodeC, nodeB, nodeA] = nodeIdsCoeffP.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeKlogX = multiply(k, new LogNode(nodeVarX));
+    const nodeP = createNodeFPolynomialFromCoeffs([nodeC, nodeB, nodeA]);
+    const nodeF = add(nodeKlogX, nodeP);
+    const nodeFRewritten1 = multiply(nodeVarX, frac(nodeF, nodeVarX));
+    const nodeFOverXPart1 = frac(multiply(k, new LogNode(nodeVarX)), nodeVarX);
+    const nodeFOverXPart2 = frac(nodeP, nodeVarX);
+    const nodeFRewritten2 = multiply(nodeVarX, add(nodeFOverXPart1, nodeFOverXPart2));
+    const nodeLimitKLogX = k > 0 ? PlusInfinityNode : MinusInfinityNode;
+    const nodeLimitP = nodeA.evaluate() > 0 ? PlusInfinityNode : MinusInfinityNode;
+    const isFI = nodeA.evaluate() * k < 0;
+    return {
+        k,
+        nodeA,
+        nodeB,
+        nodeC,
+        nodeF,
+        nodeKlogX,
+        nodeLimitKLogX,
+        nodeP,
+        nodeLimitP,
+        nodeFRewritten1,
+        nodeFRewritten2,
+        nodeFOverXPart1,
+        nodeFOverXPart2,
+        isFI,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeF } = getHydrated(identifiers);
+    return `Déterminer la limite en $+\\infty$ de la fonction $f$ définie par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeLimitP } = getHydrated(identifiers);
+    return nodeLimitP.toTex();
+};
+const getHint = () => {
+    return `Est-ce une forme indéterminée ?
+  
+Si c'est une forme indéterminée, mets $x$ en facteur et utilise la propriété suivante :
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} \\frac{\\ln(x)}{x} = 0
+$$
+
+Tu pourras alors déterminer la limite en $+\\infty$.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeF, nodeFRewritten1, nodeFRewritten2, nodeFOverXPart1, nodeFOverXPart2, nodeKlogX, nodeLimitKLogX, nodeP, nodeLimitP, isFI, } = getHydrated(identifiers);
+    if (isFI) {
+        return `On a une forme indéterminée, en effet : 
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeKlogX.toTex()} = ${nodeLimitKLogX.toTex()}
+$$
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeP.toTex()} = ${nodeLimitP.toTex()}
+$$
+    
+Pour tout $x$ réel positif :
+
+${alignTex([
+            ["f(x)", "=", nodeF.toTex()],
+            ["", "=", nodeFRewritten1.toTex()],
+            ["", "=", nodeFRewritten2.toTex()],
+        ])}
+
+Or :
+
+$$
+l_1 = \\displaystyle \\lim_{x \\to +\\infty} ${nodeFOverXPart1.toTex()} = 0
+$$
+
+$$
+l_2 = \\displaystyle \\lim_{x \\to +\\infty} ${nodeFOverXPart2.toTex()} = ${nodeLimitP.toTex()}
+$$
+
+$$
+l_3 = \\displaystyle \\lim_{x \\to +\\infty} x = +\\infty
+$$
+
+Par multiplication des limites : 
+
+${alignTex([
+            [
+                `\\displaystyle \\lim_{x \\to +\\infty} ${nodeF.toTex()}`,
+                "=",
+                `l_3 \\times l_2 `,
+            ],
+            ["", "=", nodeLimitP.toTex()],
+        ])}
+
+`;
+    }
+    else {
+        return `Ce n'est pas une forme indéterminée, en effet :
+    
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeKlogX.toTex()} = ${nodeLimitKLogX.toTex()}
+$$
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeP.toTex()} = ${nodeLimitP.toTex()}
+$$
+
+Par linéarité de la limite : 
+
+$$
+\\displaystyle \\lim_{x \\to +\\infty} ${nodeF.toTex()} = ${nodeLimitP.toTex()}
+$$
+    
+`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { k, nodeA, nodeB, nodeC } = getHydrated(identifiers);
+    //student: +\\infty
+    tryToAddWrongProp(propositions, (nodeA.evaluate() > 0 ? MinusInfinityNode : PlusInfinityNode).toTex());
+    tryToAddWrongProp(propositions, k.frenchify());
+    tryToAddWrongProp(propositions, nodeC.toTex());
+    if (propositions.length < n) {
+        tryToAddWrongProp(propositions, nodeB.toTex());
+    }
+    if (propositions.length < n) {
+        tryToAddWrongProp(propositions, nodeA.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["lnBrackets", "infty", "epower"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+        NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+};
+const createRandomIdentifiers = (opts) => {
+    const k = randint(-100, 101, [0]);
+    const a = opts.isIndeterminateForm
+        ? k < 0
+            ? randint(1, 11, [0])
+            : randint(-10, 0, [0])
+        : k < 0
+            ? randint(-10, 0, [0])
+            : randint(1, 11, [0]);
+    const b = randint(-10, 11, [0, a]);
+    const c = randint(-10, 11, [0, a, b]);
+    const identifiers = {
+        k,
+        nodeIdsCoeffP: [c, b, a].map((v) => v.toTree().toIdentifiers()),
+    };
+    return identifiers;
+};
+const getKLogXPlusTrinomLimitQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    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 optsDefault = {
+    isIndeterminateForm: true,
+};
+const options = [
+    {
+        id: "isIndeterminateForm",
+        label: "Forme indéterminée ?",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: optsDefault.isIndeterminateForm,
+    },
+];
+export const kLogXPlusTrinomLimit = {
+    id: "kLogXPlusTrinomLimit",
+    connector: "\\iff",
+    label: "Limite de $k \\ln(x) + P(x)$ en $+\\infty$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getKLogXPlusTrinomLimitQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/logOfPolynomialLimit.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsLimitAbscissa: NodeIdentifiers;
+    nodeIdsP: NodeIdentifiers;
+    isPossible: boolean;
+};
+export declare const logOfPolynomialLimit: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=logOfPolynomialLimit.d.ts.map

package/lib/exercises/math/limits/logOfPolynomialLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logOfPolynomialLimit.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/limits/logOfPolynomialLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,eAAe,CAAC;IACtC,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AA+KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}