math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/derivation/derivative/trigo/productOfSinAXPlusBCosCXPlusDDerivative.js

@@ -0,0 +1,209 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { cos, CosNode } from "../../../../../tree/nodes/functions/cosNode.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 { multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { NodePrinter } from "../../../../../tree/utilities/nodePrinter.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = multiply(nodeU, nodeV);
+    return `Déterminer la dérivée de la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeAXPlusB, nodeCXPlusD] = [nodeU, nodeV].map((node) => node.child);
+    const [nodeA, nodeC] = [nodeAXPlusB, nodeCXPlusD].map((nodeAffine) => nodeAffine.derivative().simplify({ towardsDistribute: true }));
+    //u = sin(ax+b), v = cos(cx+d)
+    //u' = a cos(ax+b), v' = c(-sin(cx+d))
+    //f' = u'v+uv'
+    return add(multiply(multiply(nodeA, cos(nodeAXPlusB)), cos(nodeCXPlusD)), multiply(sin(nodeAXPlusB), multiply(nodeC, opposite(sin(nodeCXPlusD)))));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = (_identifiers) => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, pour $x$ dans l'ensemble de dérivation de $uv$, on a : 
+
+$$
+(uv)'(x) = u'(x)v(x)+u(x)v'(x)
+$$
+
+Et pour $x$ dans l'ensemble de dérivation de $u \\circ v = x \\mapsto u(v(x))$, on a : 
+
+$$
+(u \\circ v)'(x) = v'(x)u'(v(x))
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map((node) => {
+        const nodeDerivativeUgly = node.derivative();
+        const nodeDerivativePretty = multiply(nodeDerivativeUgly.leftChild.simplify(), nodeDerivativeUgly.rightChild);
+        return nodeDerivativePretty;
+    });
+    return `On doit calculer la dérivée d'un produit.
+  
+Ici, $f(x) = u(x)v(x)$ avec :
+
+$$
+u(x) = ${nodeU.toTex()}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule (dérivées de fonctions composées): 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+${alignTex([
+        [`f'(x)`, `=`, `(uv)'(x)`],
+        [``, `=`, `u'(x)v(x)+u(x)v'(x)`],
+        //déborde de l'écran :
+        // [
+        //   ``,
+        //   `=`,
+        //   add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrime)).toTex(),
+        // ],
+        //remplacé par:
+        ...(() => {
+            const tex2 = multiply(nodeU, nodeVPrime).simplify().toTex();
+            const tex2Refined = (() => {
+                if (tex2.startsWith("-")) {
+                    return tex2.replace("-", "- \\ ");
+                }
+                else {
+                    return `+ \\ ${tex2}`;
+                }
+            })();
+            return [
+                [``, `=`, multiply(nodeUPrime, nodeV).simplify().toTex()],
+                [``, `\\ `, tex2Refined],
+            ];
+        })(),
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer: _answer, ...identifiers }) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, _nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    const [nodeAXPlusB, nodeCXPlusD] = [nodeU, nodeV].map((node) => node.child);
+    const [nodeA, nodeC] = [nodeAXPlusB, nodeCXPlusD].map((nodeAffine) => nodeAffine.derivative().simplify({ towardsDistribute: true }));
+    const maxWidthForTex = 70;
+    const propositions = [];
+    const nodeAnswer = getAnswerNode(identifiers).simplify();
+    addValidProp(propositions, NodePrinter.toTexWithMaxWidth(nodeAnswer, maxWidthForTex));
+    //student: wrong derivative of cos: cos'=sin
+    {
+        class MyCosNodeWrong extends CosNode {
+            derivative(varName) {
+                return multiply(this.child.derivative(varName), sin(this.child));
+            }
+        }
+        const nodeVPrimeWrong = new MyCosNodeWrong(nodeCXPlusD).derivative();
+        const nodeDerivativeWrong = add(multiply(nodeUPrime, nodeV), multiply(nodeU, nodeVPrimeWrong)).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeDerivativeWrong, maxWidthForTex));
+    }
+    //student: wrong derivative of composition: sin(ax+b)' = cos(ax+b), etc.
+    {
+        const nodeUPrimeWrong = cos(nodeAXPlusB);
+        const nodeVPrimeWrong = opposite(sin(nodeCXPlusD));
+        const nodeDerivativeWrong = add(multiply(nodeUPrimeWrong, nodeV), multiply(nodeU, nodeVPrimeWrong)).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeDerivativeWrong, maxWidthForTex));
+    }
+    //student: wrong derivative of composition: sin(ax+b)' = a sin(ax+b), etc.
+    {
+        const nodeUPrimeWrong = multiply(nodeA, nodeU);
+        const nodeVPrimeWrong = multiply(nodeC, nodeV);
+        const nodeDerivativeWrong = add(multiply(nodeUPrimeWrong, nodeV), multiply(nodeU, nodeVPrimeWrong)).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeDerivativeWrong, maxWidthForTex));
+    }
+    //student: makes it as if f(x) = sin(ax+b) + cos(cx+d)
+    {
+        const nodeDerivativeWrong = add(multiply(nodeA, cos(nodeAXPlusB)), multiply(nodeC, opposite(sin(nodeCXPlusD)))).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeDerivativeWrong, maxWidthForTex));
+    }
+    //student: makes it as if f(x) = sin(ax+b) + cos(cx+d) + multiply
+    {
+        const nodeDerivativeWrong = multiply(multiply(nodeA, cos(nodeAXPlusB)), multiply(nodeC, opposite(sin(nodeCXPlusD)))).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeDerivativeWrong, maxWidthForTex));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return NodeComparator.isEqualViaRandomEvaluations(nodeAns, nodeAnswer, 3);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getProductOfSinAXPlusBCosCXPlusDDerivativeQuestion = () => {
+    const [nodeAXPlusB, nodeCXPlusD] = AffineConstructor.differentRandoms(2, undefined, { excludes: [0, 1] }).map((affine) => affine.toTree());
+    const nodeU = sin(nodeAXPlusB);
+    const nodeV = cos(nodeCXPlusD);
+    const identifiers = {
+        nodeIdsU: nodeU.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const productOfSinAXPlusBCosCXPlusDDerivative = {
+    id: "productOfSinAXPlusBCosCXPlusDDerivative",
+    connector: "=",
+    label: "Dérivée de $\\sin(ax+b)\\cos(cx+d)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getProductOfSinAXPlusBCosCXPlusDDerivativeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/trigo/sinAndCosMixedWithSquareDerivative.d.ts

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

package/lib/exercises/math/derivation/derivative/trigo/sinAndCosMixedWithSquareDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sinAndCosMixedWithSquareDerivative.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/sinAndCosMixedWithSquareDerivative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwT7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA0VF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAiBjE,CAAC"}

package/lib/exercises/math/derivation/derivative/trigo/sinAndCosMixedWithSquareDerivative.js

@@ -0,0 +1,359 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeByReplacingNodeAtPath, } from "../../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { cos, CosNode } from "../../../../../tree/nodes/functions/cosNode.js";
+import { FunctionsIds, isFunctionNode, } from "../../../../../tree/nodes/functions/functionNode.js";
+import { sin, SinNode } from "../../../../../tree/nodes/functions/sinNode.js";
+import { NodeIds } from "../../../../../tree/nodes/node.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply, } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../../../tree/nodes/operators/operatorNode.js";
+import { isPowerNode, power, PowerNode, square, } from "../../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { NodePrinter } from "../../../../../tree/utilities/nodePrinter.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.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";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+const wrongifyViaOverriding = (node, funcDerivativeCos, funcDerivativeSin, funcDerivativePower) => {
+    class MyCosNodeWrong extends CosNode {
+        derivative(varName) {
+            return wrongifyViaOverriding(funcDerivativeCos(this, varName), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+        // toTex(): string {
+        //   return `\\text{cøs}\\left(${this.child.toTex()}\\right)`;
+        // }
+        simplify(opts = {}) {
+            return wrongifyViaOverriding(trueNodify(this).simplify(opts), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+    }
+    class MySinNodeWrong extends SinNode {
+        derivative(varName) {
+            return wrongifyViaOverriding(funcDerivativeSin(this, varName), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+        // toTex(): string {
+        //   return `\\text{siin}\\left(${this.child.toTex()}\\right)`;
+        // }
+        simplify(opts = {}) {
+            return wrongifyViaOverriding(trueNodify(this).simplify(opts), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+    }
+    class MyPowerNodeWrong extends PowerNode {
+        derivative(varName) {
+            return wrongifyViaOverriding(funcDerivativePower(this, varName), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+        // toTex(): string {
+        //   return `\\text{siin}\\left(${this.child.toTex()}\\right)`;
+        // }
+        simplify(opts = {}) {
+            return wrongifyViaOverriding(trueNodify(this).simplify(opts), funcDerivativeCos, funcDerivativeSin, funcDerivativePower);
+        }
+    }
+    class NodeConstructorWrong extends NodeConstructor {
+        static fromIdentifiers(identifiers, _log) {
+            switch (identifiers.id) {
+                case NodeIds.cos:
+                    return new MyCosNodeWrong(NodeConstructorWrong.fromIdentifiers(identifiers.child));
+                case NodeIds.sin:
+                    return new MySinNodeWrong(NodeConstructorWrong.fromIdentifiers(identifiers.child));
+                case NodeIds.power:
+                    return new MyPowerNodeWrong(NodeConstructorWrong.fromIdentifiers(identifiers.leftChild), NodeConstructorWrong.fromIdentifiers(identifiers.rightChild));
+                default: {
+                    const node = super.fromIdentifiers(identifiers);
+                    if (isOperatorNode(node)) {
+                        const [nodeLeftChild, nodeRightChild] = [
+                            identifiers.leftChild,
+                            identifiers.rightChild,
+                        ].map((nodeIds) => NodeConstructorWrong.fromIdentifiers(nodeIds));
+                        node.leftChild = nodeLeftChild;
+                        node.rightChild = nodeRightChild;
+                        return node;
+                    }
+                    else if (isFunctionNode(node)) {
+                        const nodeChild = NodeConstructorWrong.fromIdentifiers(identifiers.child);
+                        node.child = nodeChild;
+                        return node;
+                    }
+                    else {
+                        return node;
+                    }
+                }
+            }
+        }
+    }
+    function myNodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected) {
+        return nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, -1, {}, NodeConstructorWrong.fromIdentifiers);
+    }
+    if (isOperatorNode(node)) {
+        switch (node.id) {
+            case OperatorIds.power:
+                return new MyPowerNodeWrong(wrongifyViaOverriding(node.leftChild, funcDerivativeCos, funcDerivativeSin, funcDerivativePower), wrongifyViaOverriding(node.rightChild, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+            default:
+                return myNodeByReplacingNodeAtPath(myNodeByReplacingNodeAtPath(node, { keys: ["leftChild"] }, wrongifyViaOverriding(node.leftChild, funcDerivativeCos, funcDerivativeSin, funcDerivativePower)), { keys: ["rightChild"] }, wrongifyViaOverriding(node.rightChild, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        }
+    }
+    else if (isFunctionNode(node)) {
+        switch (node.id) {
+            case FunctionsIds.cos:
+                return new MyCosNodeWrong(wrongifyViaOverriding(node.child, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+            case FunctionsIds.sin:
+                return new MySinNodeWrong(wrongifyViaOverriding(node.child, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+            default:
+                return myNodeByReplacingNodeAtPath(node, { keys: ["child"] }, wrongifyViaOverriding(node.child, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        }
+    }
+    else {
+        return node;
+    }
+};
+const trueNodify = (node) => {
+    if (isOperatorNode(node)) {
+        return nodeByReplacingNodeAtPath(nodeByReplacingNodeAtPath(node, { keys: ["leftChild"] }, trueNodify(node.leftChild)), { keys: ["rightChild"] }, trueNodify(node.rightChild));
+    }
+    else if (isFunctionNode(node)) {
+        switch (node.id) {
+            case FunctionsIds.cos:
+                return new CosNode(trueNodify(node.child));
+            case FunctionsIds.sin:
+                return new SinNode(trueNodify(node.child));
+            default:
+                return nodeByReplacingNodeAtPath(node, { keys: ["child"] }, trueNodify(node.child));
+        }
+    }
+    else {
+        return node;
+    }
+};
+const getPrettyNodeDerivative = (node) => {
+    const nodeDerivativeUgly = node.derivative();
+    const nodeDerivativeRight = nodeDerivativeUgly.rightChild;
+    const nodeDerivativeRightRight = nodeDerivativeRight.rightChild;
+    const nodeDerivativePretty = multiply(nodeDerivativeRight.leftChild, multiply(nodeDerivativeRightRight.leftChild.simplify(), nodeDerivativeRightRight.rightChild));
+    return nodeDerivativePretty;
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeF = add(nodeU, nodeV).simplify();
+    return `Déterminer la dérivée de la fonction $f$ définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${nodeF.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    //f' = u' + v'
+    return add(nodeUPrime, nodeVPrime);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = (_identifiers) => {
+    return `Si $u$ et $v$ sont deux fonctions dérivables alors, pour $x$ dans l'ensemble de dérivation de $u$ et de $v$, on a : 
+
+$$
+(u+v)'(x) = u'(x)+v'(x)
+$$
+
+Et pour $x$ dans l'ensemble de dérivation de $u \\circ v = x \\mapsto u(v(x))$, on a : 
+
+$$
+(u \\circ v)'(x) = v'(x)u'(v(x))
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeUPrime, nodeVPrime] = [nodeU, nodeV].map(getPrettyNodeDerivative);
+    return `On doit calculer la dérivée d'une somme.
+  
+Ici, $f(x) = u(x) + v(x)$ avec :
+
+$$
+u(x) = ${nodeU.toTex({})}
+$$
+
+$$
+v(x) = ${nodeV.toTex()}
+$$
+
+On calcule (dérivées de fonctions composées): 
+
+$$
+u'(x) = ${nodeUPrime.toTex()}
+$$
+
+$$
+v'(x) = ${nodeVPrime.toTex()}
+$$
+
+Donc :
+
+${alignTex([
+        [`f'(x)`, `=`, `u'(x)+v'(x)`],
+        [``, `=`, getAnswerNode(identifiers).simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer: _answer, ...identifiers }) => {
+    const { nodeIdsU, nodeIdsV } = identifiers;
+    const [nodeU, nodeV] = [nodeIdsU, nodeIdsV].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [_nodeUPrime, _nodeVPrime] = [nodeU, nodeV].map((node) => node.derivative().simplify());
+    const maxWidthForTex = 70;
+    const propositions = [];
+    const nodeAnswer = getAnswerNode(identifiers).simplify();
+    addValidProp(propositions, NodePrinter.toTexWithMaxWidth(nodeAnswer, maxWidthForTex));
+    //student: wrong derivative of cos: cos'=sin
+    {
+        function funcDerivativeCos(node, varName) {
+            const nodeCos = node;
+            return multiply(nodeCos.child.derivative(varName), sin(nodeCos.child));
+        }
+        function funcDerivativeSin(node, varName) {
+            const nodeSin = node;
+            return trueNodify(nodeSin).derivative(varName);
+        }
+        function funcDerivativePower(node, varName) {
+            const nodePower = node;
+            return trueNodify(nodePower).derivative(varName);
+        }
+        const [nodeUWronged, nodeVWronged] = [nodeU, nodeV].map((node) => wrongifyViaOverriding(node, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        const nodeWrong = add(nodeUWronged.derivative(), nodeVWronged.derivative()).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+    }
+    //student: wrong derivative of composition: sin(x²)' = cos(x²), etc.
+    {
+        function funcDerivativeCos(node, _varName) {
+            const nodeCos = node;
+            return opposite(sin(nodeCos.child));
+        }
+        function funcDerivativeSin(node, _varName) {
+            const nodeSin = node;
+            return cos(nodeSin.child);
+        }
+        function funcDerivativePower(node, varName) {
+            const nodePower = node;
+            return trueNodify(nodePower).derivative(varName);
+        }
+        const [nodeUWronged, nodeVWronged] = [nodeU, nodeV].map((node) => wrongifyViaOverriding(node, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        const nodeWrong = add(nodeUWronged.derivative(), nodeVWronged.derivative()).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+    }
+    //student: wrong derivative of composition: sin(x²)' = cos(2x), etc.
+    {
+        function funcDerivativeCos(node, varName) {
+            const nodeCos = node;
+            if (isPowerNode(nodeCos.child)) {
+                const nodePower = nodeCos.child;
+                return opposite(sin(nodePower.derivative(varName)));
+            }
+            else {
+                return trueNodify(nodeCos).derivative(varName);
+            }
+        }
+        function funcDerivativeSin(node, varName) {
+            const nodeSin = node;
+            if (isPowerNode(nodeSin.child)) {
+                const nodePower = nodeSin.child;
+                return cos(nodePower.derivative(varName));
+            }
+            else {
+                return trueNodify(nodeSin).derivative(varName);
+            }
+        }
+        function funcDerivativePower(node, varName) {
+            const nodePower = node;
+            return trueNodify(nodePower).derivative(varName);
+        }
+        const [nodeUWronged, nodeVWronged] = [nodeU, nodeV].map((node) => wrongifyViaOverriding(node, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        const nodeWrong = add(nodeUWronged.derivative(), nodeVWronged.derivative()).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+    }
+    //student: wrong derivative of power: (u^n)' = n u^(n-1)
+    {
+        function funcDerivativeCos(node, varName) {
+            const nodeCos = node;
+            return trueNodify(nodeCos).derivative(varName);
+        }
+        function funcDerivativeSin(node, varName) {
+            const nodeSin = node;
+            return trueNodify(nodeSin).derivative(varName);
+        }
+        function funcDerivativePower(node, _varName) {
+            const nodePower = node;
+            return multiply(nodePower.rightChild, power(nodePower.leftChild, substract(nodePower.rightChild, 1)));
+        }
+        const [nodeUWronged, nodeVWronged] = [nodeU, nodeV].map((node) => wrongifyViaOverriding(node, funcDerivativeCos, funcDerivativeSin, funcDerivativePower));
+        const nodeWrong = add(nodeUWronged.derivative(), nodeVWronged.derivative()).simplify();
+        tryToAddWrongProp(propositions, NodePrinter.toTexWithMaxWidth(nodeWrong, maxWidthForTex));
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return NodeComparator.isEqualViaRandomEvaluations(nodeAns, nodeAnswer, 3);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getSinAndCosMixedWithPowDerivativeQuestion = () => {
+    const nodeVarX = new VariableNode("x");
+    const createRandomFactorNode = () => ((coinFlip() ? +1 : -1) * randint(1, 7)).toTree();
+    const nodeLambda = createRandomFactorNode();
+    const func1 = random([sin, cos]);
+    const node1 = multiply(nodeLambda, square(func1(nodeVarX)));
+    const nodeMu = createRandomFactorNode();
+    const func2 = random([sin, cos]);
+    const node2 = multiply(nodeMu, func2(square(nodeVarX)));
+    const [nodeU, nodeV] = shuffle([node1, node2]);
+    const identifiers = {
+        nodeIdsU: nodeU.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "sin", "cos", "tan"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const sinAndCosMixedWithPowDerivative = {
+    id: "sinAndCosMixedWithPowDerivative",
+    connector: "=",
+    label: "Dérivée de $f(x)= cos^2(x)$ ou $sin^2(x)$ ou $cos(x^2)$ ou $sin(x^2)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSinAndCosMixedWithPowDerivativeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsLambda: NodeIdentifiers;
+    nodeIdsU: NodeIdentifiers;
+    nodeIdsV: NodeIdentifiers;
+    nodeIdsRewriteUsing: NodeIdentifiers;
+};
+export declare const sinCosDerivativeRewriteUsingCos2PlusSin2Equals1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.d.ts.map

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAoH7C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,mBAAmB,EAAE,eAAe,CAAC;CACtC,CAAC;AAkaF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CAAC,WAAW,CAqB/E,CAAC"}