math-exercises 3.0.178 → 3.0.180

package/lib/exercises/math/derivation/derivative/exp/expDerivativeQuotientFExp.js

@@ -0,0 +1,435 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { exp, ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { PiNode } from "../../../../../tree/nodes/numbers/piNode.js";
+import { add, AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac, FractionNode, isFractionNode, } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { isMultiplyNode, multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const simplifyMoreProduct = (node) => {
+    if (isMultiplyNode(node)) {
+        const nodeLeft = node.leftChild;
+        const nodeRight = node.rightChild;
+        try {
+            return multiply(nodeLeft.simplify({ forbidFactorize: true, towardsDistribute: true }), nodeRight.simplify({ forbidFactorize: true, towardsDistribute: true }));
+        }
+        catch (_) {
+            return node;
+        }
+    }
+    else {
+        return node;
+    }
+};
+const simplifyMore = (node) => {
+    if (isFractionNode(node)) {
+        const nodeLeft = node.leftChild;
+        const nodeRight = node.rightChild;
+        try {
+            return frac(simplifyMoreProduct(nodeLeft), nodeRight.simplify());
+        }
+        catch (_) {
+            return node;
+        }
+    }
+    else if (isMultiplyNode(node)) {
+        return simplifyMoreProduct(node);
+    }
+    else {
+        return node;
+    }
+};
+const getPrettyFractionNode = (nodeFraction) => {
+    try {
+        const nodeNum = nodeFraction.leftChild.simplify({
+            towardsDistribute: true,
+        });
+        const nodeDen = nodeFraction.rightChild;
+        return frac(nodeNum, nodeDen);
+    }
+    catch (_e) {
+        return nodeFraction;
+    }
+};
+const getInstructionNode = (a, b, c, d, e, isFOverExpG) => {
+    const nodeF = (() => {
+        if (a !== undefined) {
+            return TrinomConstructor.fromCoeffs([c, b, a]).toTree().simplify();
+        }
+        else if (b !== undefined) {
+            return AffineConstructor.fromCoeffs([c, b]).toTree().simplify();
+        }
+        else {
+            return c.toTree();
+        }
+    })();
+    const nodeG = (() => {
+        if (d !== undefined) {
+            return AffineConstructor.fromCoeffs([e, d]).toTree().simplify();
+        }
+        else {
+            return e.toTree();
+        }
+    })();
+    const nodeExpG = exp(nodeG);
+    return isFOverExpG ? frac(nodeF, nodeExpG) : frac(nodeExpG, nodeF);
+};
+const getInstruction = (identifiers) => {
+    const { coeffsF, coeffsG, isFOverExpG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeH = getInstructionNode(a, b, c, d, e, isFOverExpG);
+    return `Déterminer la dérivée de la fonction $h$ définie par :
+  
+$$
+h(x) = ${nodeH.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { coeffsF, coeffsG, isFOverExpG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeDerivative = getInstructionNode(a, b, c, d, e, isFOverExpG).derivative();
+    return nodeDerivative;
+};
+const getAnswer = (identifiers) => {
+    return simplifyMore(getAnswerNode(identifiers).simplify()).toTex();
+};
+const getHint = (_identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { typeExpG } = opts;
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, pour $x$ tel que $v(x)\\neq0$, on a : 
+
+$$
+(\\frac{u}{v})'(x) = \\frac{u'(x)v(x)-u(x)v'(x)}{{v(x)}^2}
+$$
+
+$$
+${(() => {
+        switch (typeExpG) {
+            case "exp(x)":
+                return `\\exp'(x) = \\exp(x)`;
+            case "exp(ax+b)":
+                return `(y \\mapsto \\exp(ay+b))'(x) = a \\times \\exp(ax+b)`;
+            default:
+                throw new Error("Unsupported typeExpG: " + typeExpG);
+        }
+    })()}
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffsF, coeffsG, isFOverExpG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeInstruction = getInstructionNode(a, b, c, d, e, isFOverExpG);
+    const [nodeU, nodeV] = [
+        nodeInstruction.leftChild,
+        nodeInstruction.rightChild,
+    ];
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    return `On doit calculer la dérivée d'un quotient.
+    
+Ici, on a : 
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule : 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+$$
+(\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)), power(nodeV, 2)).toTex()}
+$$
+
+${(() => {
+        try {
+            return `$$
+(\\frac{u}{v})'(x) = ${frac(substract(multiply(nodeUPrime, nodeV).simplify({ towardsDistribute: true }), multiply(nodeU, nodeVPrime).simplify({ towardsDistribute: true })), power(nodeV, 2)).toTex()}
+$$`;
+        }
+        catch (_e) {
+            return "";
+        }
+    })()}
+
+$$
+h'(x) = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { coeffsF, coeffsG, isFOverExpG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeInstruction = getInstructionNode(a, b, c, d, e, isFOverExpG);
+    const [nodeU, nodeV] = [
+        nodeInstruction.leftChild,
+        nodeInstruction.rightChild,
+    ];
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    //student: no derivation
+    {
+        tryToAddWrongProp(propositions, nodeInstruction.simplify().toTex());
+    }
+    //student: (u/v)' = u'/v'
+    {
+        tryToAddWrongProp(propositions, simplifyMore(frac(nodeUPrime, nodeVPrime).simplify()).toTex());
+    }
+    //student: (u/v)' = (u'v+uv')/v²
+    {
+        class WrongFractionNode extends FractionNode {
+            derivative(varName) {
+                const numNode = add(multiply(this.leftChild.derivative(varName), this.rightChild), multiply(this.leftChild, this.rightChild.derivative(varName)));
+                const denNode = power(this.rightChild, 2);
+                return frac(numNode, denNode);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            return new WrongFractionNode(nodeU, nodeV);
+        })();
+        const nodeRaw = wrongInstructionNode.derivative();
+        let nodeWrong;
+        if (isFractionNode(nodeRaw)) {
+            nodeWrong = getPrettyFractionNode(nodeRaw);
+        }
+        else {
+            nodeWrong = nodeRaw;
+        }
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: (u/v)' = -u'/v²
+    {
+        class WrongFractionNode extends FractionNode {
+            derivative(varName) {
+                const numNode = multiply(-1, this.leftChild).derivative(varName);
+                const denNode = power(this.rightChild, 2);
+                return frac(numNode, denNode);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            return new WrongFractionNode(nodeU, nodeV);
+        })();
+        const nodeRaw = wrongInstructionNode.derivative();
+        let nodeWrong;
+        if (isFractionNode(nodeRaw)) {
+            nodeWrong = getPrettyFractionNode(nodeRaw);
+        }
+        else {
+            nodeWrong = nodeRaw;
+        }
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: exp(x)' = x.exp(x)
+    {
+        class MyAddNode extends AddNode {
+            simplify(opts, log) {
+                if (this.leftChild.evaluate() === 0 ||
+                    this.rightChild.evaluate() === 0) {
+                    return (0).toTree();
+                }
+                else {
+                    return super.simplify(opts, log);
+                }
+            }
+        }
+        class MyMultiplyNode extends MultiplyNode {
+            derivative(varName) {
+                return new MyAddNode(new MyMultiplyNode(this.leftChild.derivative(varName).simplify(), this.rightChild), new MyMultiplyNode(this.leftChild, this.rightChild.derivative(varName).simplify())).simplify();
+            }
+            simplify(opts, log) {
+                if (this.leftChild.evaluate() === 0 ||
+                    this.rightChild.evaluate() === 0) {
+                    return (0).toTree();
+                }
+                else {
+                    return super.simplify(opts, log);
+                }
+            }
+        }
+        class WrongExpNode extends ExpNode {
+            derivative(varName = "x") {
+                const derivateSuper = new MyMultiplyNode(this.child.derivative(varName), exp(this.child));
+                return new MyMultiplyNode(varName.toTree(), derivateSuper);
+            }
+        }
+        const wrongInstructionNode = (() => {
+            const nodeF = (() => {
+                if (a !== undefined) {
+                    return TrinomConstructor.fromCoeffs([c, b, a]).toTree().simplify();
+                }
+                else if (b !== undefined) {
+                    return AffineConstructor.fromCoeffs([c, b]).toTree().simplify();
+                }
+                else {
+                    return c.toTree();
+                }
+            })();
+            const nodeG = (() => {
+                if (d !== undefined) {
+                    return AffineConstructor.fromCoeffs([e, d]).toTree().simplify();
+                }
+                else {
+                    return e.toTree();
+                }
+            })();
+            return isFOverExpG
+                ? frac(nodeF, new WrongExpNode(nodeG))
+                : frac(new WrongExpNode(nodeG), nodeF);
+        })();
+        const nodeDerivativeWrong = wrongInstructionNode.derivative();
+        tryToAddWrongProp(propositions, simplifyMore(nodeDerivativeWrong.simplify()).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isRequireFactorizedAnswer } = opts;
+    const nodeAns = parseAlgebraic(ans);
+    if (isRequireFactorizedAnswer) {
+        const nodeAnsFactorized = simplifyMore(nodeAns.simplify());
+        if (nodeAns.toTex() !== nodeAnsFactorized.toTex()) {
+            return false;
+        }
+    }
+    const nodeAnswer = parseAlgebraic(answer);
+    return [
+        PiNode.evaluate(),
+        2 * PiNode.evaluate(),
+        3 * PiNode.evaluate(),
+    ].every((x) => {
+        return (substract(nodeAns.evaluate({ x }), nodeAnswer.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getExpDerivativeQuotientFExpQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { typeF, typeExpG } = opts;
+    const coeffsF = (() => {
+        switch (typeF) {
+            case "affine":
+                return AffineConstructor.random().coefficients;
+            case "second degré":
+                return TrinomConstructor.random().coefficients;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const coeffsG = (() => {
+        switch (typeExpG) {
+            case "exp(x)":
+                return [0, 1];
+            case "exp(ax+b)":
+                return [randint(-9, 10), randint(-9, 10, [0])];
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const isFOverExpG = coinFlip();
+    const identifiers = {
+        coeffsF,
+        coeffsG,
+        isFOverExpG,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: "h'(x)",
+        answer: getAnswer(identifiers, opts),
+        keys: ["x", "epower"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    typeF: "affine",
+    isRequireFactorizedAnswer: false,
+    //"internal" option
+    typeExpG: "exp(x)",
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Fonction $f$",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.generation,
+        values: ["affine", "second degré"],
+        defaultValue: optsDefault.typeF,
+    },
+    {
+        id: "isRequireFactorizedAnswer",
+        label: "Réponse factorisée attendue ?",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: optsDefault.isRequireFactorizedAnswer,
+    },
+];
+export const expDerivativeQuotientFExp = {
+    id: "expDerivativeQuotientFExp",
+    connector: "=",
+    label: "Dérivée de $\\frac{f(x)}{\\exp(x)}$ ou de $\\frac{\\exp(x)}{f(x)}$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpDerivativeQuotientFExpQuestion({
+        ...(opts ?? optsDefault),
+        typeExpG: "exp(x)",
+    }), nb),
+    options,
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const expDerivativeQuotientFExpAffine = {
+    id: "expDerivativeQuotientFExpAffine",
+    connector: "=",
+    label: "Dérivée de $\\frac{f(x)}{\\exp(ax+b)}$ ou de $\\frac{\\exp(ax+b)}{f(x)}$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpDerivativeQuotientFExpQuestion({
+        ...(opts ?? optsDefault),
+        typeExpG: "exp(ax+b)",
+    }), nb),
+    options,
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.d.ts

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

package/lib/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/valueDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgF7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0QF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgDF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}