math-exercises 3.0.178 → 3.0.179

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

@@ -0,0 +1,346 @@
+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 { add, AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { isMultiplyNode, multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+const simplifyMore = (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 getInstructionNode = (a, b, c, d, e) => {
+    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 multiply(nodeF, nodeExpG);
+};
+const getInstruction = (identifiers) => {
+    const { coeffsF, coeffsG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeH = getInstructionNode(a, b, c, d, e);
+    return `Déterminer la dérivée de la fonction $h$ définie par :
+  
+$$
+h(x) = ${nodeH.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { coeffsF, coeffsG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeDerivative = getInstructionNode(a, b, c, d, e).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$ qui convient, on a : 
+
+$$
+(uv)'(x) = u'(x)v(x)+u(x)v'(x)
+$$
+
+$$
+${(() => {
+        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 } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeInstruction = getInstructionNode(a, b, c, d, e);
+    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 produit.
+  
+Ici, on a : 
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule : 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+$$
+(uv)'(x) = ${add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)).toTex()}
+$$
+
+$$
+h'(x) = ${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { coeffsF, coeffsG } = identifiers;
+    const [c, b, a] = coeffsF;
+    const [e, d] = coeffsG;
+    const nodeInstruction = getInstructionNode(a, b, c, d, e);
+    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'
+    {
+        tryToAddWrongProp(propositions, simplifyMore(multiply(nodeUPrime, nodeVPrime).simplify()).toTex());
+    }
+    //student: u'v
+    {
+        tryToAddWrongProp(propositions, simplifyMore(multiply(nodeUPrime, nodeV).simplify()).toTex());
+    }
+    //student: u'v + uv
+    {
+        tryToAddWrongProp(propositions, simplifyMore(add(multiply(nodeUPrime, nodeV).simplify(), multiply(nodeU, nodeV).simplify()).simplify()).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 multiply(nodeF, new WrongExpNode(nodeG));
+        })();
+        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 [0, 1, 2, 10].every((x) => {
+        return (substract(nodeAns.evaluate({ x }), nodeAnswer.evaluate({ x })).evaluate() === 0);
+    });
+};
+const getExpDerivativeProductFExpQuestion = (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 identifiers = {
+        coeffsF,
+        coeffsG,
+    };
+    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 expDerivativeProductFExp = {
+    id: "expDerivativeProductFExp",
+    connector: "=",
+    label: "Dérivée de $f(x)exp(x)$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpDerivativeProductFExpQuestion({
+        ...(opts ?? optsDefault),
+        typeExpG: "exp(x)",
+    }), nb),
+    options,
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const expDerivativeProductFExpAffine = {
+    id: "expDerivativeProductFExpAffine",
+    connector: "=",
+    label: "Dérivée de $f(x)exp(ax+b)$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpDerivativeProductFExpQuestion({
+        ...(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/exp/expDerivativeQuotientFExp.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffsF: number[];
+    coeffsG: number[];
+    isFOverExpG: boolean;
+};
+type Options = {
+    typeF: string;
+    isRequireFactorizedAnswer: boolean;
+    typeExpG: string;
+};
+export declare const expDerivativeQuotientFExp: Exercise<Identifiers, Options>;
+export declare const expDerivativeQuotientFExpAffine: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=expDerivativeQuotientFExp.d.ts.map

package/lib/exercises/math/derivation/derivative/exp/expDerivativeQuotientFExp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expDerivativeQuotientFExp.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeQuotientFExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAqGrC,KAAK,WAAW,GAAG;IAEjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAGlB,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,WAAW,EAAE,OAAO,CAAC;CACtB,CAAC;AA4XF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB,EAAE,OAAO,CAAC;IAGnC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA4BF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBpE,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB1E,CAAC"}