math-exercises 3.0.178 → 3.0.180

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeEquationSolving1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;CACjC,CAAC;AA6SF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving1.js

@@ -0,0 +1,283 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 } from "../../../../tree/nodes/operators/powerNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+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 { nodeIdsSlope, nodeIdsF } = identifiers;
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Voici l'expression d'une fonction $f$ :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+ 
+Déterminer les abscisses des points où le coefficient directeur de la tangente à la courbe représentative de $f$ vaut $${nodeSlope.toTex()}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsRoots } = identifiers;
+    const arrNodeRoot = nodeIdsRoots.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSolution = new EquationSolutionNode(new DiscreteSetNode(arrNodeRoot));
+    return nodeSolution;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsSlope, typeF } = identifiers;
+    const [nodeSlope] = [nodeIdsSlope].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Si $f$ est une fonction dérivable en $x$, alors la pente de la tangente en $x$ est $f'(x)$.
+
+Il faut donc résoudre l'équation :
+
+$$
+f'(x) = ${nodeSlope.toTex()}
+$$
+
+Rappel :
+
+${(() => {
+        switch (typeF) {
+            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{k}{x}$":
+                return `Soit $n$ un entier. La dérivée de $x \\mapsto \\frac{k}{x}$ est $x \\mapsto -\\frac{k}{x^2}$.`;
+            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 "$k\\sqrt{x}$":
+                return `La dérivée de $x \\mapsto k\\sqrt{x}$ est $x \\mapsto \\frac{k}{2\\sqrt{x}}$.`;
+            case "$ax\\sqrt{x}$":
+                return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto ax\\sqrt{x}$ est $x \\mapsto a\\sqrt{x}+(ax)\\frac{1}{2\\sqrt{x}}$.`;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })()}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSlope, nodeIdsF } = identifiers;
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    return `Si $f$ est une fonction dérivable en $x$, alors la pente de la tangente en $x$ est $f'(x)$.
+
+Il faut donc résoudre l'équation :
+
+$$
+f'(x) = ${nodeSlope.toTex()}
+$$
+
+On calcule :
+
+${alignTex([
+        ...[
+            ...new Set([
+                nodeF
+                    .derivative()
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+                nodeDerivative.toTex(),
+            ]),
+        ].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+On veut donc résoudre l'équation : 
+
+$$
+${nodeDerivative.toTex()} = ${nodeSlope.toTex()}
+$$
+
+On résout :
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = (typeF) => {
+    const [nodeF, nodeSlope, arrNodeRoot] = (() => {
+        const nodeVarX = "x".toTree();
+        switch (typeF) {
+            case "polynôme (degré $2$)": {
+                //P'(x) - s = a(x-x1)
+                //P'(x) = a(x-x1) + s
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const nodeX1 = randint(-5, 6, [0]).toTree();
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, [nodeX1]), nodeS);
+                const nodeC = randint(-3, 3).toTree();
+                const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC).simplify({ towardsDistribute: true, forbidFactorize: true });
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            case "polynôme (degré $3$)": {
+                //P'(x) - s = a(x-x1)(x-x2)
+                //P'(x) = a(x-x1)(x-x2) + s
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const [nodeX1, nodeX2] = randomMany([...Array(11).keys()].map((i) => i - 5), 2).map((v) => v.toTree());
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, [nodeX1, nodeX2]), nodeS);
+                const nodeC = randint(-3, 3).toTree();
+                const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC).simplify({ towardsDistribute: true, forbidFactorize: true });
+                return [nodeF, nodeS, [nodeX1, nodeX2]];
+            }
+            case "$\\frac{k}{x}$": {
+                //P'(x) = s <=> -k/x^2 = s <=> x^2=(-k)/s (=> ks <0)
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeK = multiply(-randint(1, 5, [0]), nodeS).simplify();
+                const nodeF = frac(nodeK, nodeVarX).simplify();
+                const nodeX1 = sqrt(opposite(frac(nodeK, nodeS).simplify())).simplify();
+                const nodeX2 = opposite(nodeX1);
+                return [nodeF, nodeS, [nodeX1, nodeX2]];
+            }
+            // case "$\\frac{ax+b}{cx+d}$": {
+            //   //P'(x) = s <=> (a(cx+d)-c(ax+b))/(cx+d)^2 = s
+            //   //          <=> a(cx+d)-c(ax+b) = s(cx+d)^2
+            //   //
+            //   // const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map(
+            //   //   (affine) => affine.toTree(),
+            //   // );
+            //   // return frac(nodeNum, nodeDen);
+            //   return [nodeF, nodeS];
+            // }
+            case "$k\\sqrt{x}$": {
+                //P'(x) = s <=> k/(2sqrt(x)) = s
+                //          <=> 2sqrt(x) = k/s (=> ks > 0)
+                //           => 4x=k^2/s^2
+                //           =>  x=(1/4)(k^2/s^2)
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeK = multiply(randint(1, 5, [0]), nodeS).simplify();
+                const nodeF = multiply(nodeK, sqrt(nodeVarX)).simplify();
+                const nodeX1 = frac(1, multiply(4, power(frac(nodeK, nodeS), 2))).simplify();
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            case "$ax\\sqrt{x}$": {
+                //P'(x) = s <=> (a)sqrt(x) + ax/(2sqrt(x)) = s
+                //           => 2(a)(sqrt(x)) = s  (=> sa>0)
+                //           => x = (s/2a)^2
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const nodeS = multiply(-randint(1, 5, [0]), nodeA).simplify();
+                const nodeF = multiply(multiply(nodeA, nodeVarX), sqrt(nodeVarX)).simplify();
+                const nodeX1 = power(frac(nodeS, multiply(2, nodeA)), 2).simplify();
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const identifiers = {
+        nodeIdsSlope: nodeSlope.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+        nodeIdsRoots: arrNodeRoot.map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getDerivativeEquationSolving1Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const identifiers = createRandomIdentifiers(typeF);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        answerFormat: "tex",
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace"],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        identifiers,
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "polynôme (degré $2$)",
+        "polynôme (degré $3$)",
+        "$\\frac{k}{x}$",
+        // "$\\frac{ax+b}{cx+d}$",
+        "$k\\sqrt{x}$",
+        "$ax\\sqrt{x}$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "polynôme (degré $2$)",
+            "polynôme (degré $3$)",
+            "$\\frac{k}{x}$",
+            // "$\\frac{ax+b}{cx+d}$",
+            "$k\\sqrt{x}$",
+            "$ax\\sqrt{x}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const derivativeEquationSolving1 = {
+    id: "derivativeEquationSolving1",
+    connector: "=",
+    label: `Résoudre une équation avec la dérivée ($1$)`,
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeEquationSolving1Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsSlope: NodeIdentifiers;
+    nodeIdsF: NodeIdentifiers;
+    typeF: string;
+    nodeIdsRoots: NodeIdentifiers[];
+    indexRootGiven: number;
+};
+type Options = {
+    typeF: string;
+};
+export declare const derivativeEquationSolving3: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=derivativeEquationSolving3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeEquationSolving3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivative/derivativeEquationSolving3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,eAAe,EAAE,CAAC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6TF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/derivation/derivative/derivativeEquationSolving3.js

@@ -0,0 +1,296 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.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 } from "../../../../tree/nodes/operators/powerNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+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 { nodeIdsF, nodeIdsRoots, indexRootGiven } = identifiers;
+    const [nodeF, nodeXGiven] = [nodeIdsF, nodeIdsRoots[indexRootGiven]].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Voici l'expression d'une fonction $f$ :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+ 
+Déterminer les abscisses des points où la tangente est parallèle à la tangente en $${nodeXGiven.toTex()}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsRoots } = identifiers;
+    const arrNodeRoot = nodeIdsRoots.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSolution = new EquationSolutionNode(new DiscreteSetNode(arrNodeRoot));
+    return nodeSolution;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsSlope, typeF } = identifiers;
+    const [nodeSlope] = [nodeIdsSlope].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Si $f$ est une fonction dérivable en $x$, alors la pente de la tangente en $x$ est $f'(x)$.
+
+Il faut donc résoudre l'équation :
+
+$$
+f'(x) = ${nodeSlope.toTex()}
+$$
+
+Rappel :
+
+${(() => {
+        switch (typeF) {
+            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{k}{x}$":
+                return `Soit $n$ un entier. La dérivée de $x \\mapsto \\frac{k}{x}$ est $x \\mapsto -\\frac{k}{x^2}$.`;
+            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 "$k\\sqrt{x}$":
+                return `La dérivée de $x \\mapsto k\\sqrt{x}$ est $x \\mapsto \\frac{k}{2\\sqrt{x}}$.`;
+            case "$ax\\sqrt{x}$":
+                return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto ax\\sqrt{x}$ est $x \\mapsto a\\sqrt{x}+(ax)\\frac{1}{2\\sqrt{x}}$.`;
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })()}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSlope, nodeIdsF, nodeIdsRoots, indexRootGiven } = identifiers;
+    const [nodeSlope, nodeF, nodeXGiven] = [
+        nodeIdsSlope,
+        nodeIdsF,
+        nodeIdsRoots[indexRootGiven],
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXGiven, "x".toTree()).simplify();
+    return `On cherche d'abord la valeur de la pente en $${nodeXGiven.toTex()}$.
+  
+On calcule :
+
+${alignTex([
+        ...[
+            ...new Set([
+                nodeF
+                    .derivative()
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+                nodeDerivative.toTex(),
+            ]),
+        ].map((tex) => [`f'(x)`, "=", tex]),
+    ])}
+
+On a donc : 
+
+$$
+f'(${nodeXGiven.toTex()}) = ${nodeValueDerivative.toTex()}
+$$
+
+Les tangentes qui sont parallèles à la tangente en $${nodeXGiven.toTex()}$ ont toutes une pente qui vaut $${nodeValueDerivative.toTex()}$.
+  
+  
+Si $f$ est une fonction dérivable en $x$, alors la pente de la tangente en $x$ est $f'(x)$.
+
+Il faut donc résoudre l'équation :
+
+${alignTex([
+        [`f'(x)`, "=", nodeSlope.toTex()],
+        [nodeDerivative.toTex(), "=", nodeSlope.toTex()],
+    ])}
+
+On résout :
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { typeF } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers(typeF);
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = (typeF) => {
+    const [nodeF, nodeSlope, arrNodeRoot] = (() => {
+        const nodeVarX = "x".toTree();
+        switch (typeF) {
+            case "polynôme (degré $2$)": {
+                //P'(x) - s = a(x-x1)
+                //P'(x) = a(x-x1) + s
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const nodeX1 = randint(-5, 6, [0]).toTree();
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, [nodeX1]), nodeS);
+                const nodeC = randint(-3, 3).toTree();
+                const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC).simplify({ towardsDistribute: true, forbidFactorize: true });
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            case "polynôme (degré $3$)": {
+                //P'(x) - s = a(x-x1)(x-x2)
+                //P'(x) = a(x-x1)(x-x2) + s
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const [nodeX1, nodeX2] = randomMany([...Array(11).keys()].map((i) => i - 5), 2).map((v) => v.toTree());
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, [nodeX1, nodeX2]), nodeS);
+                const nodeC = randint(-3, 3).toTree();
+                const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC).simplify({ towardsDistribute: true, forbidFactorize: true });
+                return [nodeF, nodeS, [nodeX1, nodeX2]];
+            }
+            case "$\\frac{k}{x}$": {
+                //P'(x) = s <=> -k/x^2 = s <=> x^2=(-k)/s (=> ks <0)
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeK = multiply(-randint(1, 5, [0]), nodeS).simplify();
+                const nodeF = frac(nodeK, nodeVarX).simplify();
+                const nodeX1 = sqrt(opposite(frac(nodeK, nodeS).simplify())).simplify();
+                const nodeX2 = opposite(nodeX1);
+                return [nodeF, nodeS, [nodeX1, nodeX2]];
+            }
+            // case "$\\frac{ax+b}{cx+d}$": {
+            //   //P'(x) = s <=> (a(cx+d)-c(ax+b))/(cx+d)^2 = s
+            //   //          <=> a(cx+d)-c(ax+b) = s(cx+d)^2
+            //   //
+            //   // const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map(
+            //   //   (affine) => affine.toTree(),
+            //   // );
+            //   // return frac(nodeNum, nodeDen);
+            //   return [nodeF, nodeS];
+            // }
+            case "$k\\sqrt{x}$": {
+                //P'(x) = s <=> k/(2sqrt(x)) = s
+                //          <=> 2sqrt(x) = k/s (=> ks > 0)
+                //           => 4x=k^2/s^2
+                //           =>  x=(1/4)(k^2/s^2)
+                const nodeS = randint(-9, 10, [0]).toTree();
+                const nodeK = multiply(randint(1, 5, [0]), nodeS).simplify();
+                const nodeF = multiply(nodeK, sqrt(nodeVarX)).simplify();
+                const nodeX1 = frac(1, multiply(4, power(frac(nodeK, nodeS), 2))).simplify();
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            case "$ax\\sqrt{x}$": {
+                //P'(x) = s <=> (a)sqrt(x) + ax/(2sqrt(x)) = s
+                //           => 2(a)(sqrt(x)) = s  (=> sa>0)
+                //           => x = (s/2a)^2
+                const nodeA = randint(-9, 10, [0]).toTree();
+                const nodeS = multiply(-randint(1, 5, [0]), nodeA).simplify();
+                const nodeF = multiply(multiply(nodeA, nodeVarX), sqrt(nodeVarX)).simplify();
+                const nodeX1 = power(frac(nodeS, multiply(2, nodeA)), 2).simplify();
+                return [nodeF, nodeS, [nodeX1]];
+            }
+            default:
+                throw new Error("Unsupported typeF: " + typeF);
+        }
+    })();
+    const identifiers = {
+        nodeIdsSlope: nodeSlope.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+        nodeIdsRoots: arrNodeRoot.map((node) => node.toIdentifiers()),
+        indexRootGiven: randint(0, arrNodeRoot.length),
+    };
+    return identifiers;
+};
+const getDerivativeEquationSolving3Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    const identifiers = createRandomIdentifiers(typeF);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        answerFormat: "tex",
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace"],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        identifiers,
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "polynôme (degré $2$)",
+        "polynôme (degré $3$)",
+        "$\\frac{k}{x}$",
+        // "$\\frac{ax+b}{cx+d}$",
+        "$k\\sqrt{x}$",
+        "$ax\\sqrt{x}$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "polynôme (degré $2$)",
+            "polynôme (degré $3$)",
+            "$\\frac{k}{x}$",
+            // "$\\frac{ax+b}{cx+d}$",
+            "$k\\sqrt{x}$",
+            "$ax\\sqrt{x}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const derivativeEquationSolving3 = {
+    id: "derivativeEquationSolving3",
+    connector: "=",
+    label: `Résoudre une équation avec la dérivée ($3$)`,
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeEquationSolving3Question(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -32,7 +32,7 @@ const getHint = (identifiers) => {
     return `Si $v$ est une fonction dérivable alors :
 
 $$
-(e^{v(x)})'(x) = v'(x) \\times e^{v(x)}
+(e^{v(x)})' = v'(x) \\times e^{v(x)}
 $$
 
 Ici, on a : 
@@ -51,7 +51,7 @@ const getCorrection = (identifiers) => {
     return `Si $v$ est une fonction dérivable alors :
 
 $$
-(e^{(v(x)})'(x) = v'(x) \\times e^{v(x)}
+(e^{v(x)})' = v'(x) \\times e^{v(x)}
 $$
 
 Ici, on a : 
@@ -67,7 +67,7 @@ $$
 Donc : 
 
 $$
-(e^{${texAffine}})'(x) = ${texDeriv} e^{${texAffine}}
+(e^{${texAffine}})' = ${texDeriv} e^{${texAffine}}
 $$
 
 `;

package/lib/exercises/math/derivation/derivative/exp/expDerivativeProductFExp.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"expDerivativeProductFExp.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeProductFExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AA+DrC,KAAK,WAAW,GAAG;IAEjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAGlB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4TF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB,EAAE,OAAO,CAAC;IAGnC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA4BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBnE,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBzE,CAAC"}