math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/functions/integral/integralTrinomialOverX2.js

@@ -0,0 +1,280 @@
+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 { 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 { zip } from "../../../../utils/arrays/arrayZip.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 nodeVarX = new VariableNode("x");
+    const arrNodeTerm = zip([frac(1, square(nodeVarX)), frac(1, nodeVarX), 1], arrNodeCoeff).map(([nodeFunction, nodeCoeff]) => multiply(nodeCoeff, nodeFunction));
+    const nodeFRewritten = arrNodeTerm.toReversed().reduce((acc, node, i) => {
+        if (i === 0) {
+            return node;
+        }
+        else {
+            return add(acc, node);
+        }
+    }, (0).toTree());
+    //int(1/x²) = -1/x
+    //int(1/x) = ln(x)
+    //int(1) = x
+    const arrNodePrimitive = zip([frac(-1, nodeVarX), new LogNode(nodeVarX), nodeVarX], arrNodeCoeff).map(([nodeFunction, nodeCoeff]) => multiply(nodeCoeff, nodeFunction));
+    const nodePrimitiveOfF = arrNodePrimitive
+        .toReversed()
+        .reduce((acc, nodeCoeff, i) => {
+        if (i === 0) {
+            return nodeCoeff;
+        }
+        else {
+            return add(acc, nodeCoeff);
+        }
+    }, (0).toTree());
+    const nodeIntegral = new IntegralNode(nodeF, nodeIntegralBoundLow, nodeIntegralBoundHigh, "x");
+    const nodeIntegralAsSub = substract(nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundHigh, nodeVarX), nodeBySubstitutingVar(nodePrimitiveOfF, nodeIntegralBoundLow, nodeVarX));
+    return {
+        nodeF,
+        nodeFRewritten,
+        nodeIntegralBoundLow,
+        nodeIntegralBoundHigh,
+        arrNodeTerm,
+        arrNodePrimitive,
+        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,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeF, nodeFRewritten } = getHydrated(identifiers);
+    return `On peut réécrire la fonction dans l'intégrale pour faire apparaître des fonctions connues :
+
+$$
+${nodeF.toTex()}
+$$
+
+$$
+=
+$$
+
+$$
+${nodeFRewritten.toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIntegralBoundHigh, nodeIntegralBoundLow, nodeF, nodeFRewritten, nodeIntegral, nodeIntegralAsSub, nodePrimitiveOfF, arrNodeTerm, arrNodePrimitive, } = getHydrated(identifiers);
+    return `On a :
+
+Pour tout $x$ réel,
+
+$$
+${nodeF.toTex()}
+$$
+
+$$
+=
+$$
+
+$$
+${nodeFRewritten.toTex()}
+$$
+
+${zip(arrNodeTerm, arrNodePrimitive)
+        .toReversed()
+        .map(([nodeTerm, nodePrimitive]) => `Une primitive de $x \\mapsto ${nodeTerm.toTex()}$ est $x \\mapsto ${nodePrimitive.toTex()}$.`).join(`
+  
+`)}
+
+On a donc :
+
+${alignTex([
+        [
+            nodeIntegral.toTex(),
+            "=",
+            `\\left[ ${nodePrimitiveOfF.toTex()} \\right]_{${nodeIntegralBoundLow.toTex()}}^{${nodeIntegralBoundHigh.toTex()}}`,
+        ],
+        [
+            "",
+            "=",
+            nodeIntegralAsSub
+                .simplify({
+                towardsDistribute: true,
+                forceAddFractions: true,
+            })
+                .toTex(),
+        ],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        try {
+            const identifierWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+        }
+        catch (_) {
+            (() => { })();
+        }
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return ["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 = (opts) => {
+    const valueOrderOfP = parseInt(opts.orderOfP);
+    const nodeP = PolynomialConstructor.randomWithOrder(valueOrderOfP).toTree();
+    const nodeF = frac(nodeP, square(new VariableNode("x")));
+    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 = frac(add(add(multiply((2).toTree(), square(nodeVarX)), nodeVarX), randint(1, 5).toTree()), square(nodeVarX));
+            return {
+                nodeIdsF: nodeF.toIdentifiers(),
+                nodeIdsBounds: [nodeIntegralBoundLow, nodeIntegralBoundHigh].map((node) => node.toIdentifiers()),
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getIntegralTrinomialOverX2Question = (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 integralTrinomialOverX2 = {
+    id: "integralTrinomialOverX2",
+    connector: "=",
+    label: "Calcul d'intégrales de fonctions du type $\\frac{P(x)}{x^2}$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntegralTrinomialOverX2Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"findLargestPossibleDomainOfLogF.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/findLargestPossibleDomainOfLogF.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAkC7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC7C,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA4rBF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1E,CAAC"}