math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/integration/fromExpr/byParts/integralOfAXPlusBTimesExpKXByParts.js

@@ -0,0 +1,234 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { PolynomialConstructor } from "../../../../../math/polynomials/polynomial.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { getArrNodeCoeffOfPolynomialNode } from "../../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.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 { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeP = nodeF.leftChild;
+    const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeP);
+    const [_nodeB, nodeA] = arrNodeCoeff;
+    const nodeIntegralForTex = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeVarX = new VariableNode("x");
+    const nodeF1 = nodeF;
+    const nodeF2 = multiply(nodeA, exp(nodeVarX));
+    const nodeIntegralForResult = substract(substract(nodeBySubstitutingVar(nodeF1, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF1, nodeIntegralBoundLow, nodeVarX)), substract(nodeBySubstitutingVar(nodeF2, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF2, nodeIntegralBoundLow, nodeVarX)));
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        arrNodeCoeff,
+        nodeP,
+        nodeF1,
+        nodeF2,
+        nodeIntegralForTex,
+        nodeIntegralForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegralForTex } = getHydrated(identifiers);
+    return `Calculer :
+
+$$
+${nodeIntegralForTex.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegralForResult } = getHydrated(identifiers);
+    return nodeIntegralForResult
+        .simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeP } = getHydrated(identifiers);
+    return `Déploie une intégration par parties, en remarquant que : 
+
+$$
+uv' = (uv)' - u'v
+$$
+
+avec, pour tout $x$ réel:
+
+$$
+u(x) = ${nodeP.toTex()}
+$$
+
+et 
+
+$$
+v(x) = e^x
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeP, nodeF1, nodeF2, nodeIntegralForTex, nodeIntegralForResult, } = getHydrated(identifiers);
+    const texBoundLow = nodeIntegralBoundLow.toTex();
+    const texBoundHigh = nodeIntegralBoundHigh.toTex();
+    return `On déploie la méthode d'intégration par parties.
+
+Ici, pour tout $x$ réel:
+
+$$
+u(x) = ${nodeP.toTex()}
+$$
+
+et 
+
+$$
+v(x) = e^x
+$$
+
+Il résulte du calcul de $(uv)'$ que : 
+
+$$
+uv' = (uv)' - u'v
+$$
+
+On intègre entre $${texBoundLow}$ et $${texBoundHigh}$ :
+
+${alignTex([
+        [
+            nodeIntegralForTex.toTex(),
+            "=",
+            `\\left[ ${nodeF1.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}} - \\int_{${texBoundLow}}^{${texBoundHigh}} ${nodeF2.toTex()} dx`,
+        ],
+        [
+            "",
+            "=",
+            `\\left[ ${nodeF1.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}} - \\left[ ${nodeF2.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralForResult.simplify({ towardsDistribute: true }).toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeIdsF, nodeIdsBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeP = nodeF.leftChild;
+    const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeP);
+    const [nodeB, nodeA] = arrNodeCoeff;
+    const nodeVarX = new VariableNode("x");
+    //student: \\int (ax+b)e^x = [ ((a/2)x²+bx)e^x ]
+    {
+        const nodeBigF = multiply(add(multiply(frac(nodeA, 2), square(nodeVarX)), multiply(nodeB, nodeVarX)), exp(nodeVarX));
+        const nodeIntegralForResultWrong = substract(nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundLow, nodeVarX));
+        tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+            .simplify({ towardsDistribute: true, calculatePowers: true })
+            .toTex());
+    }
+    //student: sign error: \\int = [] + \\int
+    {
+        const nodeF1 = nodeF;
+        const nodeF2 = multiply(nodeA, exp(nodeVarX));
+        const nodeIntegralForResultWrong = add(substract(nodeBySubstitutingVar(nodeF1, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF1, nodeIntegralBoundLow, nodeVarX)), substract(nodeBySubstitutingVar(nodeF2, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF2, nodeIntegralBoundLow, nodeVarX)));
+        tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+            .simplify({ towardsDistribute: true, calculatePowers: true })
+            .toTex());
+    }
+    //student: \\int (ax+b)e^x = [  (ax+b)e^x ]
+    {
+        const nodeBigF = nodeF;
+        const nodeIntegralForResultWrong = substract(nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundLow, nodeVarX));
+        tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+            .simplify({ towardsDistribute: true, calculatePowers: true })
+            .toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["e", "x"];
+};
+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 = () => {
+    const nodeVarX = new VariableNode("x");
+    const nodeP = PolynomialConstructor.randomWithOrder(1).toTree();
+    const nodeF = multiply(nodeP, exp(nodeVarX));
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        randint(1, 6).toTree(),
+        randint(6, 11).toTree(),
+    ];
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeIntegralBoundLow.toIdentifiers(),
+            nodeIntegralBoundHigh.toIdentifiers(),
+        ],
+    };
+    return identifiers;
+};
+const getIntegralOfAXPlusBTimesExpKXByPartsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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;
+};
+export const integralOfAXPlusBTimesExpKXByParts = {
+    id: "integralOfAXPlusBTimesExpKXByParts",
+    connector: "=",
+    label: "Calcul d'intégrales de fonctions du type $(ax+b)e^x$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfAXPlusBTimesExpKXByPartsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromExpr/byParts/integralOfPolynomialTimesLogXByParts.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsF: NodeIdentifiers;
+    nodeIdsBounds: [NodeIdentifiers, NodeIdentifiers];
+};
+type Options = {
+    orderOfP: string;
+};
+export declare const integralOfPolynomialTimesLogXByParts: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=integralOfPolynomialTimesLogXByParts.d.ts.map

package/lib/exercises/math/integration/fromExpr/byParts/integralOfPolynomialTimesLogXByParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integralOfPolynomialTimesLogXByParts.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/integration/fromExpr/byParts/integralOfPolynomialTimesLogXByParts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0B7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;CACnD,CAAC;AAyYF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAmBR,CAAC"}

package/lib/exercises/math/integration/fromExpr/byParts/integralOfPolynomialTimesLogXByParts.js

@@ -0,0 +1,330 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { PolynomialConstructor } from "../../../../../math/polynomials/polynomial.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromCoeffs, getArrNodeCoeffOfPolynomialNode, } from "../../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { IntegralNode } from "../../../../../tree/nodes/functions/integralNode.js";
+import { LogNode } from "../../../../../tree/nodes/functions/logNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.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 { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeIntegralForTex = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeP = nodeF.leftChild;
+    const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeP);
+    const nodeVarX = new VariableNode("x");
+    //nodeF1 = uv
+    const nodeP1 = createIntegratedPolynomialNode(nodeP, (0).toTree()).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceDistributeFractions: true,
+    });
+    const nodeF1 = multiply(nodeP1, new LogNode(nodeVarX));
+    //nodeF2 = \\int uv'
+    const nodeF2Derivative = multiply(nodeP1, frac(1, nodeVarX));
+    const nodeF2DerivativeAlternative = (() => {
+        const arrNodeCoeff = getArrNodeCoeffOfPolynomialNode(nodeP1);
+        return createNodeFPolynomialFromCoeffs(arrNodeCoeff.slice(1));
+    })();
+    const nodeF2 = createIntegratedPolynomialNode(nodeF2DerivativeAlternative, (0).toTree()).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const nodeIntegralForResult = substract(substract(nodeBySubstitutingVar(nodeF1, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF1, nodeIntegralBoundLow, nodeVarX)), substract(nodeBySubstitutingVar(nodeF2, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF2, nodeIntegralBoundLow, nodeVarX)));
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        arrNodeCoeff,
+        nodeP,
+        nodeP1,
+        nodeF2Derivative,
+        nodeF1,
+        nodeF2,
+        nodeIntegralForTex,
+        nodeIntegralForResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegralForTex } = getHydrated(identifiers);
+    return `Calculer :
+
+$$
+${nodeIntegralForTex.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegralForResult } = getHydrated(identifiers);
+    return nodeIntegralForResult
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        forceAddFractions: true,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeP } = getHydrated(identifiers);
+    return `Déploie une intégration par parties, en remarquant que : 
+
+$$
+u'v = (uv)' - uv'
+$$
+
+avec, pour tout $x$ réel:
+
+$$
+u'(x) = ${nodeP.toTex()}
+$$
+
+et 
+
+$$
+v(x) = \\ln(x)
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeP, nodeF2Derivative, nodeF1, nodeF2, nodeIntegralForTex, nodeIntegralForResult, } = getHydrated(identifiers);
+    const texBoundLow = nodeIntegralBoundLow.toTex();
+    const texBoundHigh = nodeIntegralBoundHigh.toTex();
+    return `On déploie la méthode d'intégration par parties.
+
+Ici, pour tout $x$ réel:
+
+$$
+u'(x) = ${nodeP.toTex()}
+$$
+
+et 
+
+$$
+v(x) = \\ln(x)
+$$
+
+Il résulte du calcul de $(uv)'$ que : 
+
+$$
+u'v = (uv)' - uv'
+$$
+
+On intègre entre $${texBoundLow}$ et $${texBoundHigh}$ :
+
+${alignTex([
+        [
+            nodeIntegralForTex.toTex(),
+            "=",
+            `\\left[ ${nodeF1.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}} - \\int_{${texBoundLow}}^{${texBoundHigh}} ${nodeF2Derivative.toTex()} dx`,
+        ],
+        [
+            "",
+            "=",
+            `\\left[ ${nodeF1.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}} - \\left[ ${nodeF2.toTex()} \\right]_{${texBoundLow}}^{${texBoundHigh}}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralForResult
+                .simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const nodeVarX = new VariableNode("x");
+    const { nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeP1, nodeF, nodeF1, nodeF2, } = getHydrated(identifiers);
+    //student: \\int (ax+b)ln(x) = [ ((a/2)x²+bx)(xln(x)-x) ]
+    {
+        const nodeBigF = multiply(nodeP1, substract(multiply(nodeVarX, new LogNode(nodeVarX)), nodeVarX));
+        const nodeIntegralForResultWrong = substract(nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundLow, nodeVarX));
+        try {
+            tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+                .simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+                forceAddFractions: true,
+            })
+                .toTex());
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    //student: sign error: \\int = [] + \\int
+    {
+        const nodeIntegralForResultWrong = add(substract(nodeBySubstitutingVar(nodeF1, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF1, nodeIntegralBoundLow, nodeVarX)), substract(nodeBySubstitutingVar(nodeF2, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeF2, nodeIntegralBoundLow, nodeVarX)));
+        try {
+            tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+                .simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+                forceAddFractions: true,
+            })
+                .toTex());
+        }
+        catch (_) {
+            (() => { })();
+        }
+    }
+    //student: \\int (ax+b)ln(x) = [  (ax+b)ln(x) ]
+    {
+        const nodeBigF = nodeF;
+        const nodeIntegralForResultWrong = substract(nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodeBigF, nodeIntegralBoundLow, nodeVarX));
+        tryToAddWrongProp(propositions, nodeIntegralForResultWrong
+            .simplify({ towardsDistribute: true, calculatePowers: true })
+            .toTex());
+    }
+    propWhile(propositions, n, () => {
+        try {
+            const identifierWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["ln", "x"];
+};
+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 valueOrderOfP = parseInt(opts.orderOfP);
+    const nodeVarX = new VariableNode("x");
+    const nodeP = PolynomialConstructor.randomWithOrder(valueOrderOfP).toTree();
+    const nodeF = multiply(nodeP, new LogNode(nodeVarX));
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        randint(1, 6).toTree(),
+        randint(6, 11).toTree(),
+    ];
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeIntegralBoundLow.toIdentifiers(),
+            nodeIntegralBoundHigh.toIdentifiers(),
+        ],
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(opts);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = (() => {
+            const nodeVarX = new VariableNode("x");
+            const nodeIntegralBoundLow = (1).toTree();
+            const nodeIntegralBoundHigh = (3).toTree();
+            const nodeF = multiply(square("x"), new LogNode(nodeVarX));
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsBounds: [nodeIntegralBoundLow, nodeIntegralBoundHigh].map((node) => node.toIdentifiers()),
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getIntegralOfPolynomialTimesLogXByPartsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createQCPassedIdentifiers(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 = {
+    orderOfP: "2",
+};
+const options = [
+    {
+        id: "orderOfP",
+        label: "Ordre du polynôme au numérateur",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["1", "2"],
+        defaultValue: optsDefault.orderOfP,
+    },
+];
+export const integralOfPolynomialTimesLogXByParts = {
+    id: "integralOfPolynomialTimesLogXByParts",
+    connector: "=",
+    label: "Calcul d'intégrales de fonctions du type $P(x)ln(x)$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralOfPolynomialTimesLogXByPartsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromExpr/checkIsPrimitiveFromExpr.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsPrimitiveCandidate: NodeIdentifiers;
+    nodeIdsF: NodeIdentifiers;
+    nameOfPrimitive: string;
+    nameOfPrimitiveAsked: string;
+    isPrimitive: boolean;
+};
+type Options = {
+    primitiveTypes: string[];
+};
+export declare const checkIsPrimitiveFromExpr: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=checkIsPrimitiveFromExpr.d.ts.map

package/lib/exercises/math/integration/fromExpr/checkIsPrimitiveFromExpr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkIsPrimitiveFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/checkIsPrimitiveFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,yBAAyB,EAAE,eAAe,CAAC;IAC3C,QAAQ,EAAE,eAAe,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;IACxB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AA0dF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAwCF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBnE,CAAC"}