math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,450 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { getArrNodeCoeffOfPolynomialNode } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { cos, isCosNode } from "../../../../tree/nodes/functions/cosNode.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 { sin } from "../../../../tree/nodes/functions/sinNode.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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsF, nodeIdsPrimitiveCandidate, nameOfPrimitive, nameOfPrimitiveAsked, isPrimitive, } = identifiers;
+    const [nodeF, nodePrimitiveCandidate] = [
+        nodeIdsF,
+        nodeIdsPrimitiveCandidate,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivativeOfPrimitiveCandidate = nodePrimitiveCandidate
+        .derivative()
+        .simplify({ towardsDistribute: true, calculatePowers: true });
+    // const isPrimitive = NodeComparator.isEqualViaSub(
+    //   nodeDerivativeOfPrimitiveCandidate,
+    //   nodeF,
+    // );
+    const nameOfFAsked = nameOfPrimitiveAsked === "f" ? "g" : "f";
+    return {
+        nodeF,
+        nodePrimitiveCandidate,
+        nodeDerivativeOfPrimitiveCandidate,
+        isPrimitive,
+        nameOfPrimitive,
+        nameOfPrimitiveAsked,
+        nameOfFAsked,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeF, nodePrimitiveCandidate, nameOfPrimitive, nameOfPrimitiveAsked, nameOfFAsked, } = getHydrated(identifiers);
+    return `Soient $f$ et $g$ deux fonctions définies par : 
+
+Pour tout $x$ réel positif :
+
+$$
+f(x) = ${nameOfPrimitive === "f" ? nodePrimitiveCandidate.toTex() : nodeF.toTex()}
+$$
+
+$$
+g(x) = ${nameOfPrimitive === "g" ? nodePrimitiveCandidate.toTex() : nodeF.toTex()}
+$$
+
+La fonction $${nameOfPrimitiveAsked}$ est-elle une primitive de la fonction $${nameOfFAsked}$ ?
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { isPrimitive, nameOfPrimitive, nameOfPrimitiveAsked } = getHydrated(identifiers);
+    return isPrimitive && nameOfPrimitive === nameOfPrimitiveAsked
+        ? "Oui"
+        : "Non";
+};
+const getHint = (identifiers) => {
+    const { nameOfPrimitiveAsked } = identifiers;
+    const nameOfFAsked = nameOfPrimitiveAsked === "f" ? "g" : "f";
+    return `Calcule la dérivée de la fonction $${nameOfPrimitiveAsked}$ et compare la avec $${nameOfFAsked}$. 
+Si elles sont égales alors $${nameOfPrimitiveAsked}$ est une primitive de $${nameOfFAsked}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { isPrimitive, nameOfPrimitive, nameOfPrimitiveAsked, nodeF, nodeDerivativeOfPrimitiveCandidate, nameOfFAsked, } = getHydrated(identifiers);
+    return `${(() => {
+        if (isPrimitive) {
+            if (nameOfPrimitive === nameOfPrimitiveAsked) {
+                return `On a : 
+
+Pour tout $x$ réel positif :
+
+${alignTex([
+                    [`${nameOfPrimitive}'(x)`, "=", nodeDerivativeOfPrimitiveCandidate.toTex()],
+                    ["", "=", `${nameOfFAsked}(x)`],
+                ])}
+
+Donc $${nameOfPrimitiveAsked}$ est bien une primitive de $${nameOfFAsked}$.
+
+`;
+            }
+            else {
+                return `On a : 
+
+Pour tout $x$ réel positif :
+
+${alignTex([
+                    [`${nameOfPrimitive}'(x)`, "=", nodeDerivativeOfPrimitiveCandidate.toTex()],
+                    ["", "=", `${nameOfPrimitiveAsked}(x)`],
+                ])}
+
+Donc $${nameOfFAsked}$ est une primitive de $${nameOfPrimitiveAsked}$.
+
+Mais, il est demandé si $${nameOfPrimitiveAsked}$ est une primitive de $${nameOfFAsked}$.
+
+Or, pour tout réel positif :
+
+${alignTex([
+                    [
+                        `${nameOfPrimitiveAsked}'(x)`,
+                        "=",
+                        nodeF
+                            .derivative()
+                            .simplify({ towardsDistribute: true, calculatePowers: true })
+                            .toTex(),
+                    ],
+                    ["", "\\neq", `${nameOfFAsked}(x)`],
+                ])}
+
+Donc $${nameOfPrimitiveAsked}$ n'est pas une primitive de $${nameOfFAsked}$.
+
+`;
+            }
+        }
+        else {
+            if (nameOfPrimitive === nameOfPrimitiveAsked) {
+                return `Pour tout réel $x$ positif : 
+        
+${alignTex([
+                    [
+                        `${nameOfPrimitiveAsked}'(x)`,
+                        "=",
+                        nodeDerivativeOfPrimitiveCandidate.toTex(),
+                    ],
+                    ["", "\\neq", `${nameOfFAsked}(x)`],
+                ])}
+
+Donc $${nameOfPrimitiveAsked}$ n'est pas une primitive de $${nameOfFAsked}$.
+
+`;
+            }
+            else {
+                return `Pour tout réel $x$ positif : 
+        
+${alignTex([
+                    [
+                        `${nameOfPrimitiveAsked}'(x)`,
+                        "=",
+                        nodeF
+                            .derivative()
+                            .simplify({ towardsDistribute: true, calculatePowers: true })
+                            .toTex(),
+                    ],
+                    ["", "\\neq", `${nameOfFAsked}(x)`],
+                ])}
+
+Donc $${nameOfPrimitiveAsked}$ n'est pas une primitive de $${nameOfFAsked}$.
+
+`;
+            }
+        }
+    })()}`;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = (primitiveType) => {
+    const nodePrimitiveCandidate = (() => {
+        const nodeVarX = new VariableNode("x");
+        switch (primitiveType) {
+            case "$x \\mapsto ax^2+bx+c$": {
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(2).toTree();
+                return nodeTrinom;
+            }
+            case "$x \\mapsto ax^3+bx^2+cx+d$": {
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(3).toTree();
+                return nodeTrinom;
+            }
+            case "$x \\mapsto e^{ax+b}$": {
+                const nodeAffine = AffineConstructor.random({
+                    min: 2,
+                    max: 6,
+                }).toTree();
+                return exp(nodeAffine);
+            }
+            case "$x \\mapsto e^{ax^2+bx+c}$": {
+                const nodeAffine = PolynomialConstructor.randomWithOrder(2).toTree();
+                return exp(nodeAffine);
+            }
+            case "$x \\mapsto \\ln(ax+b)$": {
+                const nodeAffine = AffineConstructor.random({
+                    min: 2,
+                    max: 6,
+                }).toTree();
+                return new LogNode(nodeAffine);
+            }
+            case "$x \\mapsto \\ln(ax^2+bx+c)$": {
+                const nodeAffine = PolynomialConstructor.randomWithOrder(2).toTree();
+                return new LogNode(nodeAffine);
+            }
+            case "$x \\mapsto (ax+b)e^{x}$": {
+                const nodeAffine = AffineConstructor.random({
+                    min: 2,
+                    max: 6,
+                }).toTree();
+                return multiply(nodeAffine, exp(nodeVarX));
+            }
+            case "$x \\mapsto (ax^2+bx+c)e^{x}$": {
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(2).toTree();
+                return multiply(nodeTrinom, exp(nodeVarX));
+            }
+            case "$x \\mapsto (ax+b)\\ln(x)$": {
+                const nodeAffine = AffineConstructor.random({
+                    min: 2,
+                    max: 6,
+                }).toTree();
+                return multiply(nodeAffine, new LogNode(nodeVarX));
+            }
+            case "$x \\mapsto (ax^2+bx+c)\\ln(x)$": {
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(2).toTree();
+                return multiply(nodeTrinom, new LogNode(nodeVarX));
+            }
+            case "$x \\mapsto \\cos(ax+b)$": {
+                const funcTrig = coinFlip() ? cos : sin;
+                const nodeAffine = AffineConstructor.random({
+                    min: 2,
+                    max: 6,
+                }).toTree();
+                return funcTrig(nodeAffine);
+            }
+            case "$x \\mapsto \\cos(ax^2+bx+c)$": {
+                const funcTrig = coinFlip() ? cos : sin;
+                const nodeTrinom = PolynomialConstructor.randomWithOrder(2).toTree();
+                return funcTrig(nodeTrinom);
+            }
+            default:
+                throw new Error("Unsupported primitiveType: " + primitiveType);
+        }
+    })();
+    const isPrimitive = coinFlip();
+    const nodeF = (() => {
+        if (isPrimitive) {
+            return nodePrimitiveCandidate.derivative().simplify({
+                towardsDistribute: true,
+                calculatePowers: true,
+                forceAddFractions: true,
+            });
+        }
+        else {
+            const nodeVarX = new VariableNode("x");
+            switch (primitiveType) {
+                case "$x \\mapsto ax^2+bx+c$": {
+                    const [_nodeC, nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodePrimitiveCandidate);
+                    return add(multiply(nodeA, nodeVarX), nodeB);
+                }
+                case "$x \\mapsto ax^3+bx^2+cx+d$": {
+                    const [_nodeD, nodeC, nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodePrimitiveCandidate);
+                    return add(multiply(nodeA, square(nodeVarX)), add(multiply(nodeB, nodeVarX), nodeC));
+                }
+                case "$x \\mapsto e^{ax+b}$": {
+                    return nodePrimitiveCandidate;
+                }
+                case "$x \\mapsto e^{ax^2+bx+c}$": {
+                    return nodePrimitiveCandidate;
+                }
+                case "$x \\mapsto \\ln(ax+b)$": {
+                    const nodeAffine = nodePrimitiveCandidate.child;
+                    return frac(1, nodeAffine);
+                }
+                case "$x \\mapsto \\ln(ax^2+bx+c)$": {
+                    const nodeTrinom = nodePrimitiveCandidate.child;
+                    return frac(1, nodeTrinom);
+                }
+                case "$x \\mapsto (ax+b)e^{x}$": {
+                    const nodeAffine = nodePrimitiveCandidate.leftChild;
+                    const [_nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeAffine);
+                    return multiply(nodeA, exp(nodeVarX));
+                }
+                case "$x \\mapsto (ax^2+bx+c)e^{x}$": {
+                    const nodeTrinom = nodePrimitiveCandidate.leftChild;
+                    const [_nodeC, nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeTrinom);
+                    return multiply(add(multiply(multiply(2, nodeA), nodeVarX), nodeB), exp(nodeVarX));
+                }
+                case "$x \\mapsto (ax+b)\\ln(x)$": {
+                    const nodeAffine = nodePrimitiveCandidate.leftChild;
+                    const [_nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeAffine);
+                    return frac(nodeA, nodeVarX);
+                }
+                case "$x \\mapsto (ax^2+bx+c)\\ln(x)$": {
+                    const nodeTrinom = nodePrimitiveCandidate.leftChild;
+                    const [_nodeC, nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeTrinom);
+                    return add(multiply(2, nodeA), frac(nodeB, nodeVarX));
+                }
+                case "$x \\mapsto \\cos(ax+b)$": {
+                    const nodeAffine = nodePrimitiveCandidate.child;
+                    const [_nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeAffine);
+                    if (isCosNode(nodePrimitiveCandidate)) {
+                        return multiply(nodeA, sin(nodeAffine));
+                    }
+                    else {
+                        return multiply(nodeA, opposite(cos(nodeAffine)));
+                    }
+                }
+                case "$x \\mapsto \\cos(ax^2+bx+c)$": {
+                    const nodeTrinom = nodePrimitiveCandidate.child;
+                    const [_nodeC, nodeB, nodeA] = getArrNodeCoeffOfPolynomialNode(nodeTrinom);
+                    if (isCosNode(nodePrimitiveCandidate)) {
+                        return multiply(add(multiply(nodeA, nodeVarX), nodeB), sin(nodeTrinom));
+                    }
+                    else {
+                        return multiply(add(multiply(nodeA, nodeVarX), nodeB), opposite(cos(nodeTrinom)));
+                    }
+                }
+                default:
+                    throw new Error("Unsupported primitiveType: " + primitiveType);
+            }
+        }
+    })();
+    const nameOfPrimitive = random(["f", "g"]);
+    const nameOfPrimitiveAsked = random(["f", "g"]);
+    const identifiers = {
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsPrimitiveCandidate: nodePrimitiveCandidate.toIdentifiers(),
+        nameOfPrimitive,
+        nameOfPrimitiveAsked,
+        isPrimitive,
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            getAnswer(identifiers);
+            getCorrection(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = (primitiveType) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        let identifiersCandidate;
+        try {
+            identifiersCandidate = createRandomIdentifiers(primitiveType);
+            isValid = isIdentifiersQCPassed(identifiersCandidate);
+        }
+        catch (_) {
+            isValid = false;
+        }
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = (() => {
+            const nodeVarX = new VariableNode("x");
+            const nodePrimitiveCandidate = add(nodeVarX, randint(1, 6));
+            const isPrimitive = coinFlip();
+            const nodeF = isPrimitive ? (1).toTree() : (0).toTree();
+            const nameOfPrimitive = random(["f", "g"]);
+            const nameOfPrimitiveAsked = random(["f", "g"]);
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsPrimitiveCandidate: nodePrimitiveCandidate.toIdentifiers(),
+                nameOfPrimitive,
+                nameOfPrimitiveAsked,
+                isPrimitive,
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getCheckIsPrimitiveFromExprQuestion = (optsIn) => {
+    const opts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const primitiveType = random(opts.primitiveTypes);
+    const identifiers = createQCPassedIdentifiers(primitiveType);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    primitiveTypes: ["$x \\mapsto ax^2+bx+c$", "$x \\mapsto ax^3+bx^2+cx+d$"],
+};
+const options = [
+    {
+        id: "primitiveTypes",
+        label: "Types de primitives",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "$x \\mapsto ax^2+bx+c$",
+            "$x \\mapsto ax^3+bx^2+cx+d$",
+            "$x \\mapsto e^{ax+b}$",
+            "$x \\mapsto e^{ax^2+bx+c}$",
+            "$x \\mapsto \\ln(ax+b)$",
+            "$x \\mapsto \\ln(ax^2+bx+c)$",
+            "$x \\mapsto (ax+b)e^{x}$",
+            "$x \\mapsto (ax^2+bx+c)e^{x}$",
+            "$x \\mapsto (ax+b)\\ln(x)$",
+            "$x \\mapsto (ax^2+bx+c)\\ln(x)$",
+            "$x \\mapsto \\cos(ax+b)$",
+            "$x \\mapsto \\cos(ax^2+bx+c)$",
+        ],
+        defaultValue: arrayedOptsDefault.primitiveTypes,
+    },
+];
+export const checkIsPrimitiveFromExpr = {
+    id: "checkIsPrimitiveFromExpr",
+    connector: "=",
+    label: "Vérifier si une fonction donnée est une primitive d'une fonction donnée",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckIsPrimitiveFromExprQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeOfPrimitive.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/fromExpr/derivativeOfPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAClD,uBAAuB,EAAE,eAAe,CAAC;CAC1C,CAAC;AA6SF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}