math-exercises 3.0.178 → 3.0.180

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.js

@@ -0,0 +1,388 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { polynomialVEA } from "../../../../exercises/vea/polynomialVEA.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.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, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power, square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.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 getNodeFForTypeF = (typeF) => {
+    const nodeVarX = "x".toTree();
+    switch (typeF) {
+        case "$k$":
+            return randint(-10, 11).toTree();
+        case "$x$":
+            return nodeVarX;
+        case "$x^2$":
+            return square(nodeVarX);
+        case "$x^n \\ (n>=3)$":
+            return power(nodeVarX, randint(3, 6));
+        case "$\\frac{1}{x}$":
+            return frac(1, nodeVarX);
+        case "$\\frac{1}{x^n} \\ (n>=2)$":
+            return frac(1, power(nodeVarX, randint(3, 6)));
+        case "$\\sqrt{x}$":
+            return sqrt(nodeVarX);
+        case "polynôme (degré $1$)":
+            return AffineConstructor.random().toTree();
+        case "polynôme (degré $2$)":
+            return TrinomConstructor.random().toTree();
+        case "polynôme (degré $3$)":
+            return PolynomialConstructor.randomWithOrder(3).toTree();
+        case "$\\frac{ax+b}{cx+d}$": {
+            const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map((affine) => affine.toTree());
+            return frac(nodeNum, nodeDen);
+        }
+        case "$(ax+b)\\sqrt{x}$": {
+            const nodeAffine = AffineConstructor.random().toTree();
+            return multiply(nodeAffine, sqrt(nodeVarX));
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getRandomNodeXAskedForTypeF = (typeF) => {
+    switch (typeF) {
+        case "$\\frac{1}{x}$":
+        case "$\\frac{1}{x^n} \\ (n>=2)$":
+            return randint(-5, 6, [0]).toTree();
+        case "$\\sqrt{x}$":
+        case "$(ax+b)\\sqrt{x}$":
+            return randint(1, 6).toTree();
+        default:
+            return randint(-5, 6).toTree();
+    }
+};
+const getPrettyDerivativeNode = (nodeF) => {
+    const nodeDerivativeRaw = nodeF.derivative().simplify();
+    if (isFractionNode(nodeDerivativeRaw)) {
+        const nodeNumSimplified = nodeDerivativeRaw.leftChild.simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        const nodeDenSimplified = nodeDerivativeRaw.rightChild.simplify();
+        return frac(nodeNumSimplified, nodeDenSimplified);
+    }
+    else {
+        return nodeDerivativeRaw;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soit $f$ une fonction telle que, pour tout $x$ dans l'ensemble de dérivation de $f$ :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+  
+Déterminer l'équation de la tangente à la courbe représentative de $f$ au point d'abscisse $${nodeXAsked.toTex()}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeX = "x".toTree();
+    const nodeT = add(multiply(nodeValueDerivative, substract(nodeX, nodeXAsked)), nodeValueImage);
+    return nodeT;
+};
+const getAnswer = (identifiers) => {
+    return `y = ${getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true, forbidFactorize: true })
+        .toTex()}`;
+};
+const getHint = (identifiers) => {
+    const { typeF } = identifiers;
+    const strHintDerivative = (() => {
+        switch (typeF) {
+            case "$k$":
+                return `Soit $k$ un réel. La dérivée de $x \\mapsto k$ est $x \\mapsto 0$.`;
+            case "$x$":
+                return `La dérivée de $x \\mapsto x$ est $x \\mapsto 1$.`;
+            case "$x^2$":
+                return `La dérivée de $x \\mapsto x^2$ est $x \\mapsto 2x$.`;
+            case "$x^n \\ (n>=3)$":
+                return `Soit $n$ un entier tel que $n \\geq 3$. La dérivée de $x \\mapsto x^n$ est $x \\mapsto nx^{n-1}$.`;
+            case "$\\frac{1}{x}$":
+                return `Soit $n$ un entier. La dérivée de $x \\mapsto \\frac{1}{x}$ est $x \\mapsto -\\frac{1}{x^2}$.`;
+            case "$\\frac{1}{x^n} \\ (n>=2)$":
+                return `Soit $n$ un entier tel que $n \\geq 2$. La dérivée de $x \\mapsto \\frac{1}{x^n}$ est $x \\mapsto \\frac{-n}{x^{n+1}}$.`;
+            case "$\\sqrt{x}$":
+                return `La dérivée de $x \\mapsto \\sqrt{x}$ est $x \\mapsto \\frac{1}{2\\sqrt{x}}$.`;
+            case "polynôme (degré $1$)":
+                return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto ax+b$ est $x \\mapsto a$.`;
+            case "polynôme (degré $2$)":
+                return `Soient $a$, $b$ et $c$ trois réels. La dérivée de $x \\mapsto ax^2+bx+c$ est $x \\mapsto 2ax+b$.`;
+            case "polynôme (degré $3$)":
+                return `Soient $a$, $b$, $c$ et $d$ quatre réels. La dérivée de $x \\mapsto ax^3+bx^2+cx+d$ est $x \\mapsto 3ax^2+2bx+c$.`;
+            case "$\\frac{ax+b}{cx+d}$":
+                return `Soient $a$, $b$, $c$ et $d$ quatre réels. La dérivée de $x \\mapsto \\frac{ax+b}{cx+d}$ est $x \\mapsto \\frac{a(cx+d)-(ax+b)c}{(cx+d)^2}$.`;
+            case "$(ax+b)\\sqrt{x}$":
+                return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto (ax+b)\\sqrt{x}$ est $x \\mapsto a\\sqrt{x}+(ax+b)\\frac{1}{2\\sqrt{x}}$.`;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    return `Si $f$ est une fonction dérivable en $a$, alors l'équation de la tangente à la courbe de $f$ au point d'abscisse $a$ est donné par: 
+  
+$$
+y = f'(a)(x-a)+f(a)
+$$
+
+${strHintDerivative}
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    const nodeT = getAnswerNode(identifiers);
+    return `L'équation de la tangente à la courbe de $f$ au point d'abscisse $a$ est donné par: 
+  
+$$
+y = f'(a)(x-a)+f(a)
+$$
+
+Pour $x$ appartenant à l'ensemble de dérivation de $f$, on calcule :
+
+${alignTex([
+        ...[...new Set([nodeF.derivative().toTex(), nodeDerivative.toTex()])].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+Pour $a=${nodeXAsked.toTex()}$, on calcule :
+
+$$
+f'(${nodeXAsked.toTex()}) = ${nodeValueDerivative.toTex()}
+$$
+
+$$
+f(${nodeXAsked.toTex()}) = ${nodeValueImage.toTex()}
+$$
+
+L'équation de la tangente en $${nodeXAsked.toTex()}$ est donc : 
+
+${alignTex([
+        ["y", "=", nodeT.toTex()],
+        [
+            "",
+            "=",
+            nodeT.simplify({ towardsDistribute: true, forbidFactorize: true }).toTex(),
+        ],
+    ])}
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative().simplify();
+    const nodeValueImage = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    //mandatory
+    const propositionsMandatory = [];
+    addValidProp(propositionsMandatory, answer);
+    //student: y=f'(a)x + f(a)
+    {
+        const nodeX = "x".toTree();
+        const nodeTWrong = add(multiply(nodeValueDerivative, nodeX), nodeValueImage);
+        const texWrong = `y = ${nodeTWrong
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex()}`;
+        tryToAddWrongProp(propositionsMandatory, texWrong);
+    }
+    //filler
+    const propositionsFiller = [];
+    //student: y=f(a)(x-a) + f'(a)
+    //student: y=f'(a)(x-f(a)) + f(a)
+    //student: y=f(a)(x-f'(a)) + f'(a)
+    //etc.
+    {
+        [
+            [nodeXAsked, nodeValueDerivative, nodeValueDerivative],
+            [nodeXAsked, nodeValueImage, nodeValueImage],
+            [nodeXAsked, nodeValueDerivative, nodeValueImage],
+            [nodeXAsked, nodeValueDerivative, nodeXAsked],
+            [nodeXAsked, nodeValueImage, nodeXAsked],
+            [nodeValueImage, nodeValueImage, nodeValueDerivative],
+        ].forEach(([nodeXAskedWrong, nodeValueImageWrong, nodeValueDerivativeWrong]) => {
+            const nodeX = "x".toTree();
+            const nodeTWrong = add(multiply(nodeValueDerivativeWrong, substract(nodeX, nodeXAskedWrong)), nodeValueImageWrong);
+            const texWrong = `y = ${nodeTWrong
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex()}`;
+            tryToAddWrongProp(propositionsFiller, texWrong);
+        });
+    }
+    propWhile(propositionsFiller, n, () => {
+        const typeF = random(arrayedOptsDefault.typeF);
+        const identifiersWrong = createRandomIdentifiers(typeF);
+        if (isIdentifiersQCPassed(identifiersWrong)) {
+            tryToAddWrongProp(propositionsFiller, getAnswer(identifiersWrong));
+        }
+    });
+    return shuffle([
+        ...propositionsMandatory,
+        ...shuffleProps(propositionsFiller.filter((propositionFiller) => !propositionsMandatory
+            .map((proposition) => proposition.statement)
+            .includes(propositionFiller.statement)), n - propositionsMandatory.length),
+    ]);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansRefined = (() => {
+            const arrComponents = ans.split("=");
+            if (arrComponents.length === 1) {
+                return arrComponents[0];
+            }
+            else {
+                return arrComponents[1];
+            }
+        })();
+        const answerRefined = answer.split("=")[1];
+        return polynomialVEA(ansRefined, answerRefined);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (typeF) => {
+    const nodeF = getNodeFForTypeF(typeF);
+    const nodeXAsked = getRandomNodeXAskedForTypeF(typeF);
+    const identifiers = {
+        nodeIdsXAsked: nodeXAsked.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        const { nodeIdsXAsked, nodeIdsF } = identifiers;
+        const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+        const nodeDerivative = getPrettyDerivativeNode(nodeF);
+        let isExploding = false;
+        try {
+            const _nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+            const _nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const getTangentEquationFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(typeF);
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            nodeIdsXAsked: {
+                id: 7,
+                value: 3,
+            },
+            nodeIdsF: {
+                id: 10,
+                name: "x",
+            },
+            typeF: "$x$",
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "$k$",
+        "$x$",
+        "$x^2$",
+        "$x^n \\ (n>=3)$",
+        "$\\frac{1}{x}$",
+        "$\\frac{1}{x^n} \\ (n>=2)$",
+        "$\\sqrt{x}$",
+        "polynôme (degré $1$)",
+        "polynôme (degré $2$)",
+        "polynôme (degré $3$)",
+        "$\\frac{ax+b}{cx+d}$",
+        "$(ax+b)\\sqrt{x}$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "$k$",
+            "$x$",
+            "$x^2$",
+            "$x^n \\ (n>=3)$",
+            "$\\frac{1}{x}$",
+            "$\\frac{1}{x^n} \\ (n>=2)$",
+            "$\\sqrt{x}$",
+            "polynôme (degré $1$)",
+            "polynôme (degré $2$)",
+            "polynôme (degré $3$)",
+            "$\\frac{ax+b}{cx+d}$",
+            "$(ax+b)\\sqrt{x}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const tangentEquationFromFunctionExpression = {
+    id: "tangentEquationFromFunctionExpression",
+    connector: "=",
+    label: "Déterminer l'équation de la tangente en $a$ à partir de l'expression d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTangentEquationFromFunctionExpressionQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/tangent/tangentEquationFromGraph.d.ts

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

package/lib/exercises/math/derivation/tangent/tangentEquationFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tangentEquationFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/tangentEquationFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqB7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwaF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}