math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/integration/fromExpr/derivativeOfPrimitive.js

@@ -0,0 +1,261 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { NodeInspector } from "../../../../tree/utilities/nodeInspector.js";
+import { random } from "../../../../utils/alea/random.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, nodeIdsVarOfIntegration } = identifiers;
+    const [nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeVarOfIntegration,] = [nodeIdsF, ...nodeIdsBounds, nodeIdsVarOfIntegration].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeFOfVarOfIntegration, nodeFOfIntegralBoundHigh] = [
+        nodeVarOfIntegration,
+        nodeIntegralBoundHigh,
+    ].map((node) => nodeBySubstitutingVar(nodeF, node, new VariableNode("x")));
+    const texPrimitive = `F(${nodeIntegralBoundHigh.toTex()}) = \\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} (${nodeFOfVarOfIntegration.toTex()})d${nodeVarOfIntegration.toTex()}`;
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodeVarOfIntegration,
+        nodeFOfVarOfIntegration,
+        nodeFOfIntegralBoundHigh,
+        texPrimitive,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegralBoundHigh, texPrimitive } = getHydrated(identifiers);
+    const texIntegralBoundHigh = nodeIntegralBoundHigh.toTex();
+    return `Soit la fonction $F$ définie sur $\\mathbb{R}$ par :
+
+Pour tout $${nodeIntegralBoundHigh.toTex()}$ réel,
+  
+$$
+${texPrimitive}
+$$
+
+Donner l'expression de $F'(${texIntegralBoundHigh})$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeFOfIntegralBoundHigh } = getHydrated(identifiers);
+    return nodeFOfIntegralBoundHigh.toTex();
+};
+const getHint = () => {
+    return `Soit $a$ un nombre réel. Soit $G$ une fonction définie sur $\\mathbb{R}$ par :
+
+Pour tout $x$ réel,
+
+${alignTex([
+        ["G(x)", "=", "\\int_{a}^{x}g(t)dt"],
+        ["", "=", "\\int_{a}^{x}g(u)du"],
+    ])}
+
+(les variables d'intégration $t$ et $u$ sont muettes, elles ne sont utilisées que pour effectuer l'intégration)
+
+alors, pour tout $x$ réel,
+
+$$
+G'(x) = g(x)
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeVarOfIntegration, nodeFOfIntegralBoundHigh, nodeFOfVarOfIntegration, } = getHydrated(identifiers);
+    const [texVarOfIntegration, texIntegralBoundHigh] = [
+        nodeVarOfIntegration,
+        nodeIntegralBoundHigh,
+    ].map((node) => node.toTex());
+    return `On a :
+
+Pour tout $${nodeIntegralBoundHigh.toTex()}$ réel,
+
+$$
+F(${nodeIntegralBoundHigh.toTex()}) = \\int_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}} f(${texVarOfIntegration})d${texVarOfIntegration}
+$$
+
+avec 
+
+Pour tout $${nodeVarOfIntegration.toTex()}$ réel,
+
+$$
+f(${texVarOfIntegration}) = ${nodeFOfVarOfIntegration.toTex()}
+$$
+
+donc :
+
+Pour tout $${nodeIntegralBoundHigh.toTex()}$ réel,
+
+${alignTex([
+        [`F'(${texIntegralBoundHigh})`, "=", `f(${texIntegralBoundHigh})`],
+        ["", "=", nodeFOfIntegralBoundHigh.toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeF, nodeFOfVarOfIntegration, nodeIntegralBoundHigh, nodeIntegralBoundLow, } = getHydrated(identifiers);
+    //f(varOfIntegration)
+    {
+        tryToAddWrongProp(propositions, nodeFOfVarOfIntegration.toTex());
+    }
+    //f(integralBoundLow)
+    {
+        const nodeWrong = nodeBySubstitutingVar(nodeF, nodeIntegralBoundLow, new VariableNode("x"));
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //f(nodeIntegralBoundHigh) - f(nodeIntegralBoundLow)
+    {
+        const nodeWrong = substract(nodeBySubstitutingVar(nodeF, nodeIntegralBoundHigh, new VariableNode("x")), nodeBySubstitutingVar(nodeF, nodeIntegralBoundLow, new VariableNode("x")));
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsF, nodeIdsBounds, nodeIdsVarOfIntegration } = identifiers;
+    //var names
+    const [_nodeIntegralBoundLow, nodeIntegralBoundHigh, nodeVarOfIntegration] = [
+        ...nodeIdsBounds,
+        nodeIdsVarOfIntegration,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrKeyVarName = [nodeIntegralBoundHigh, nodeVarOfIntegration].map((nodeVar) => nodeVar.name);
+    //funcs
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const arrKeyFunctionName = (() => {
+        const nodeVarX = new VariableNode("x");
+        return [
+            ["cos", cos(nodeVarX)],
+            ["e", exp(nodeVarX)],
+        ].reduce((acc, [str, nodeFunc]) => {
+            if (NodeInspector.isContainingFunctionNode(nodeF, nodeFunc)) {
+                acc = [...acc, str];
+            }
+            return acc;
+        }, []);
+    })();
+    return [...arrKeyFunctionName, ...shuffle(arrKeyVarName)];
+};
+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 nodeIntegralBoundLow = randint(-10, 11).toTree();
+    const nodeF = (() => {
+        const rand = randint(0, 7);
+        switch (rand) {
+            case 0: {
+                return AffineConstructor.random().toTree();
+            }
+            case 1: {
+                return PolynomialConstructor.randomWithOrder(2).toTree();
+            }
+            case 2: {
+                const nodeVarX = new VariableNode("x");
+                const nodeNugget = exp(nodeVarX);
+                const nodeCarrier = AffineConstructor.random().toTree();
+                const nodeF = nodeBySubstitutingVar(nodeCarrier, nodeNugget, nodeVarX);
+                return nodeF;
+            }
+            case 3: {
+                const nodeVarX = new VariableNode("x");
+                const nodeNugget = AffineConstructor.random().toTree();
+                const nodeCarrier = exp(nodeVarX);
+                const nodeF = nodeBySubstitutingVar(nodeCarrier, nodeNugget, nodeVarX);
+                return nodeF;
+            }
+            case 4: {
+                const nodeVarX = new VariableNode("x");
+                const nodeNugget = cos(nodeVarX);
+                const nodeAffine = AffineConstructor.random().toTree();
+                const nodeF = nodeBySubstitutingVar(nodeAffine, nodeNugget, nodeVarX);
+                return nodeF;
+            }
+            case 5: {
+                const nodeVarX = new VariableNode("x");
+                const nodeNugget = AffineConstructor.random().toTree();
+                const nodeCarrier = cos(nodeVarX);
+                const nodeF = nodeBySubstitutingVar(nodeCarrier, nodeNugget, nodeVarX);
+                return nodeF;
+            }
+            case 6: {
+                const nodeVarX = new VariableNode("x");
+                const nodeNugget = cos(nodeVarX);
+                const nodeCarrier = exp(nodeVarX);
+                const nodeF = nodeBySubstitutingVar(nodeCarrier, nodeNugget, nodeVarX);
+                return nodeF;
+            }
+            default:
+                throw new Error("");
+        }
+    })();
+    const [nodeIntegralBoundHigh, nodeVarOfIntegration] = random([
+        ["t", "u"],
+        ["x", "t"],
+        ["x", "u"],
+    ]).map((letter) => new VariableNode(letter));
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeIntegralBoundLow.toIdentifiers(),
+            nodeIntegralBoundHigh.toIdentifiers(),
+        ],
+        nodeIdsVarOfIntegration: nodeVarOfIntegration.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getDerivativeOfPrimitiveQuestion = () => {
+    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 derivativeOfPrimitive = {
+    id: "derivativeOfPrimitive",
+    connector: "=",
+    label: "Donner la dérivée d'une primitive de $f$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeOfPrimitiveQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+export * from "./derivativeOfPrimitive.js";
+export * from "./byParts/index.js";
+export * from "./meanValue/index.js";
+export * from "./boundIntegralByManualRectanglesMethodFromExpr.js";
+export * from "./boundIntegralByBoundingFunctionWithAffinesFromExpr.js";
+export * from "./integralFromExpr.js";
+export * from "./checkIsPrimitiveFromExpr.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AAErC,cAAc,oDAAoD,CAAC;AACnE,cAAc,yDAAyD,CAAC;AAExE,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/integration/fromExpr/index.js

@@ -0,0 +1,8 @@
+export * from "./derivativeOfPrimitive.js";
+export * from "./byParts/index.js";
+export * from "./meanValue/index.js";
+export * from "./boundIntegralByManualRectanglesMethodFromExpr.js";
+export * from "./boundIntegralByBoundingFunctionWithAffinesFromExpr.js";
+// export * from "./areaBetweenCrossingCurvesFixedPosFromExpr.js";
+export * from "./integralFromExpr.js";
+export * from "./checkIsPrimitiveFromExpr.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"integralFromExpr.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/integralFromExpr.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAe7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClD,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAqWF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA2CF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}

package/lib/exercises/math/integration/fromExpr/integralFromExpr.js

@@ -0,0 +1,359 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode } 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 { LogNode } from "../../../../tree/nodes/functions/logNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.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 { random } from "../../../../utils/alea/random.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, functionType } = identifiers;
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = nodeIdsBounds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodePrimitiveOfF = (() => {
+        const nodeVarX = new VariableNode("x");
+        switch (functionType) {
+            case "$x \\mapsto c$": {
+                const nodeC = nodeF;
+                return multiply(nodeC, nodeVarX);
+            }
+            case "$x \\mapsto ax+b$": {
+                const nodeAffine = nodeF;
+                return createIntegratedPolynomialNode(nodeAffine, (0).toTree()).simplify({
+                    towardsDistribute: true,
+                });
+            }
+            case "$x \\mapsto ax^2+bx+c$": {
+                const nodeTrinom = nodeF;
+                return createIntegratedPolynomialNode(nodeTrinom, (0).toTree()).simplify({
+                    towardsDistribute: true,
+                });
+            }
+            case "$x \\mapsto a e^x$": {
+                return nodeF;
+            }
+            case "$x \\mapsto e^{ax+b}$": {
+                const nodeAffine = nodeF.child;
+                const nodeA = nodeAffine.leftChild
+                    .leftChild;
+                return frac(nodeF, nodeA);
+            }
+            case "$x \\mapsto \\frac{1}{ax+b}$": {
+                const nodeAffine = nodeF.rightChild;
+                const nodeA = nodeAffine.leftChild
+                    .leftChild;
+                return frac(new LogNode(nodeAffine), nodeA);
+            }
+            case "$x \\mapsto \\frac{a}{x^2}$": {
+                const nodeA = nodeF.leftChild;
+                return multiply(nodeA, opposite(frac(1, nodeVarX)));
+            }
+            // case "$x \\mapsto a \\sqrt{x}": {
+            // }
+            case "$x \\mapsto \\frac{a}{\\sqrt{x}}$": {
+                const nodeA = nodeF.leftChild;
+                return multiply(nodeA, multiply(2, sqrt(nodeVarX)));
+            }
+            //v'(x) u'(v(x))
+            case "$x \\mapsto x e^{ax²+c}$": {
+                const nodeRhs = nodeF.rightChild;
+                const nodeA = nodeRhs.child.leftChild.leftChild;
+                return frac(nodeRhs, multiply(2, nodeA));
+            }
+            case "$x \\mapsto \\frac{x}{\\sqrt{ax^2+c}}$": {
+                const nodeTrinom = nodeF.rightChild
+                    .child;
+                const nodeA = nodeTrinom.leftChild
+                    .leftChild;
+                return frac(sqrt(nodeTrinom), nodeA);
+            }
+            default:
+                throw new Error("Unsupported functionType: " + functionType);
+        }
+    })();
+    const nodeIntegral = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeVarX = new VariableNode("x");
+    const nodeIntegralAsSub = substract(nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundLow, nodeVarX));
+    return {
+        nodeF,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        nodePrimitiveOfF,
+        nodeIntegral,
+        nodeIntegralAsSub,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIntegral } = getHydrated(identifiers);
+    return `Calculer :
+
+$$
+${nodeIntegral.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIntegralAsSub } = getHydrated(identifiers);
+    return nodeIntegralAsSub
+        .simplify({
+        towardsDistribute: true,
+        forceAddFractions: true,
+        calculatePowers: true,
+    })
+        .toTex();
+};
+const getHint = () => {
+    return `Détermine une primitive de $f$ puis calcule l'intégrale.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeIntegral, nodeIntegralAsSub, nodePrimitiveOfF, } = getHydrated(identifiers);
+    return `On a :
+
+${alignTex([
+        [
+            nodeIntegral.toTex(),
+            "=",
+            `\\left[ ${nodePrimitiveOfF.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralAsSub
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        try {
+            const identifierWrong = createRandomIdentifiers(identifiers.functionType);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["x", "e", "ln"];
+};
+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 = (functionType) => {
+    const nodeF = (() => {
+        const nodeVarX = new VariableNode("x");
+        switch (functionType) {
+            case "$x \\mapsto c$": {
+                const nodeC = randint(-6, 7).toTree();
+                return nodeC;
+            }
+            case "$x \\mapsto ax+b$": {
+                const nodeAffine = PolynomialConstructor.randomWithOrder(1).toTree();
+                return nodeAffine;
+            }
+            case "$x \\mapsto ax^2+bx+c$": {
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(2).toTree();
+                return nodeTrinom;
+            }
+            case "$x \\mapsto a e^x$": {
+                const nodeA = randint(2, 7).toTree();
+                return multiply(nodeA, exp(nodeVarX));
+            }
+            case "$x \\mapsto e^{ax+b}$": {
+                const nodeAffine = PolynomialConstructor.randomWithOrder(1).toTree();
+                return exp(nodeAffine);
+            }
+            case "$x \\mapsto \\frac{1}{ax+b}$": {
+                const nodeA = randint(2, 7);
+                const nodeB = randint(1, 8);
+                const nodeAffine = add(multiply(nodeA, nodeVarX), nodeB);
+                return frac(1, nodeAffine);
+            }
+            case "$x \\mapsto \\frac{a}{x^2}$": {
+                const nodeA = randint(2, 7).toTree();
+                return frac(nodeA, square(nodeVarX));
+            }
+            case "$x \\mapsto a \\sqrt{x}$": {
+                const nodeA = randint(2, 7).toTree();
+                return multiply(nodeA, sqrt(nodeVarX));
+            }
+            case "$x \\mapsto \\frac{a}{\\sqrt{x}}$": {
+                const nodeA = randint(2, 7).toTree();
+                return frac(nodeA, sqrt(nodeVarX));
+            }
+            //v'(x) u'(v(x))
+            case "$x \\mapsto x e^{ax²+c}$": {
+                const nodeA = randint(2, 7).toTree();
+                const nodeC = randint(1, 7).toTree();
+                return multiply(nodeVarX, exp(add(multiply(nodeA, square(nodeVarX)), nodeC)));
+            }
+            case "$x \\mapsto \\frac{x}{\\sqrt{ax^2+c}}$": {
+                const nodeA = randint(2, 7).toTree();
+                const nodeC = randint(1, 7).toTree();
+                const nodeTrinom = add(multiply(nodeA, square(nodeVarX)), nodeC);
+                return frac(nodeVarX, sqrt(nodeTrinom));
+            }
+            default:
+                throw new Error("Unsupported functionType: " + functionType);
+        }
+    })();
+    const [nodeIntegralBoundLow, nodeIntegralBoundHigh] = [
+        randint(1, 5).toTree(),
+        randint(6, 9).toTree(),
+    ];
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsBounds: [
+            nodeIntegralBoundLow.toIdentifiers(),
+            nodeIntegralBoundHigh.toIdentifiers(),
+        ],
+        functionType,
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (functionType) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(functionType);
+        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 = nodeVarX;
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsBounds: [
+                    nodeIntegralBoundLow.toIdentifiers(),
+                    nodeIntegralBoundHigh.toIdentifiers(),
+                ],
+                functionType: "$x \\mapsto ax+b$",
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getIntegralFromExprQuestion = (optsIn) => {
+    const opts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const functionType = random(opts.functionTypes);
+    const identifiers = createQCPassedIdentifiers(functionType);
+    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 arrayedOptsDefault = {
+    functionTypes: [
+        "$x \\mapsto c$",
+        "$x \\mapsto ax+b$",
+        "$x \\mapsto ax^2+bx+c$",
+    ],
+};
+const options = [
+    {
+        id: "functionTypes",
+        label: "Types de fonctions",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            //easy
+            "$x \\mapsto c$",
+            "$x \\mapsto ax+b$",
+            "$x \\mapsto ax^2+bx+c$",
+            "$x \\mapsto a e^x$",
+            //mind the factor
+            "$x \\mapsto e^{ax+b}$",
+            "$x \\mapsto \\frac{1}{ax+b}$",
+            "$x \\mapsto \\frac{a}{x^2}$",
+            // "$x \\mapsto a \\sqrt{x}$",
+            "$x \\mapsto \\frac{a}{\\sqrt{x}}$",
+            //v'(x) u'(v(x))
+            "$x \\mapsto x e^{ax²+c}$",
+            "$x \\mapsto \\frac{x}{\\sqrt{ax^2+c}}$",
+        ],
+        defaultValue: arrayedOptsDefault.functionTypes,
+    },
+];
+export const integralFromExpr = {
+    id: "integralFromExpr",
+    connector: "=",
+    label: "Calcul d'intégrales de fonctions",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralFromExprQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/integration/fromExpr/meanValue/index.d.ts

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

package/lib/exercises/math/integration/fromExpr/meanValue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/integration/fromExpr/meanValue/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC"}

package/lib/exercises/math/integration/fromExpr/meanValue/index.js

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