math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/derivation/problems/problemProjectileHeightFindAbscissa.js

@@ -0,0 +1,137 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { createNodeFPolynomialFromCoeffs, createNodeFPolynomialFromRoots, getAnswerStuffSolveSecondDegreePolynomial, getArrNodeCoeffOfPolynomialNode, getTexSolveSecondDegreeEquation, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    return `On note $h(x)$ la hauteur d'une balle de tennis en fonction de son abscisse.
+
+On a :
+
+$$
+h(x) = ${nodeF.toTex()}
+$$
+  
+Déterminer pour quelle abscisse elle atteint sa hauteur maximale (donner la valeur arrondie à $2$ décimales).`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    return getAnswerStuffSolveSecondDegreePolynomial(nodeDerivative);
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNodeX } = getAnswerStuff(identifiers);
+    const arrNodeXRounded = arrNodeX.map((node) => round(node.evaluate(), 2).toTree());
+    const [nodeXRounded] = arrNodeXRounded;
+    return nodeXRounded;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `La fonction $h$ est une fonction de la forme $x \\mapsto ax^2+bx+c$ avec $a < 0$. 
+C'est une trajectoire parabolique.
+Le maximum est atteint à l'abscisse $x_M$ telle que $h'(x_M) = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsF } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+    const nodeDerivative = nodeF.derivative();
+    return `$h(x)$ est de la forme $ax^2+bx+c$ avec $a < 0$.
+
+C'est une trajectoire parabolique.
+Le maximum est atteint à l'abscisse $x_M$ telle que $h'(x_M) = 0$.
+
+$h$ est continue et dérivable. On calcule :
+
+$$
+h'(x) = ${nodeDerivative.simplify().toTex()}
+$$
+
+On résout $h'(x)=0$ :
+
+${getTexSolveSecondDegreeEquation(nodeDerivative)}
+
+Le maximum est atteint à l'abscisse $${getAnswer(identifiers)}$.
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifierWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifierWrong));
+    });
+    return shuffle(propositions);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    //roots
+    const span = randint(12, 16) * 2; //distance between roots
+    const a = randint(-10, -1);
+    const b = a + span;
+    const arrNodeX = [a, b].map((v) => v.toTree());
+    //height
+    const nodeHeight = randfloat(1.5, 5, 2);
+    const nodeU = opposite(frac(multiply(4, nodeHeight), power(span, 2)));
+    const nodeF = createNodeFPolynomialFromRoots(nodeU, arrNodeX);
+    //rounding
+    const arrNodeCoeffRounded = getArrNodeCoeffOfPolynomialNode(nodeF).map((node) => round(node.evaluate(), 2).toTree());
+    const nodeFRoundedExpanded = createNodeFPolynomialFromCoeffs(arrNodeCoeffRounded);
+    return {
+        nodeIdsF: nodeFRoundedExpanded.toIdentifiers(),
+    };
+};
+const getProblemProjectileHeightFindAbscissaQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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),
+    };
+};
+export const problemProjectileHeightFindAbscissa = {
+    id: "problemProjectileHeightFindAbscissa",
+    connector: "=",
+    label: "Déterminer pour quelle abscisse une balle de tennis atteint sa hauteur maximale",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getProblemProjectileHeightFindAbscissaQuestion(), nb),
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeEquationSolvingByManipulatingLineY.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeEquationSolvingByManipulatingLineY.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqE7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,eAAe,EAAE,eAAe,EAAE,CAAC;CACpC,CAAC;AA0gBF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAmB5E,CAAC"}

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

@@ -0,0 +1,478 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { blueMain, greenMain, orange, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, getArrNodeCoeffOfPolynomialNode, } from "../../../../math/utils/polynomial/polynomialUtils.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+function getCoordsFrame(nodeF, xMin, xMax) {
+    const stepX = 0.05;
+    const arrX = [...Array(Math.floor((xMax - xMin) / stepX)).keys()].map((i) => xMin + i * stepX);
+    const yForXMin = nodeF.evaluate({ x: xMin });
+    const { yMin, yMax } = arrX.slice(1).reduce((acc, x) => {
+        const { yMin, yMax } = acc;
+        const y = nodeF.evaluate({ x });
+        if (y < yMin) {
+            acc.yMin = y;
+        }
+        else if (y > yMax) {
+            acc.yMax = y;
+        }
+        return acc;
+    }, { yMin: yForXMin, yMax: yForXMin });
+    return {
+        xMin,
+        xMax,
+        yMin,
+        yMax,
+    };
+}
+function getNodeYIntercept(nodeF, nodeXAsked, nodeDerivative = nodeF.derivative()) {
+    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);
+    const [nodeYIntercept] = getArrNodeCoeffOfPolynomialNode(nodeT);
+    return nodeYIntercept;
+}
+const getInstruction = (identifiers) => {
+    const { nodeIdsSlope } = identifiers;
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    return `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant le point $A$,
+on peut faire glisser la droite de coefficient directeur $${nodeSlope.toTex()}$ et d'ordonnée à l'origine $a$.
+
+Résoudre l'équation $f'(x) = ${nodeSlope.toTex()}$ sur l'intervalle visible.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsAbscissa } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSet = new DiscreteSetNode(arrNodeX);
+    return nodeSet;
+};
+const getAnswer = (identifiers) => {
+    return `S=${getAnswerNode(identifiers).toTex()}`;
+};
+const getHint = () => {
+    return `Le nombre dérivé de $f$ en $x$, aussi noté $f'(x)$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $x$.
+  
+Résoudre l'équation $f'(x) = k$, 
+c'est trouver toutes les abscisses $x$ 
+pour lesquelles le coefficient directeur la tangente à la courbe représentative de $f$ vaut $k$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeSlope = NodeConstructor.fromIdentifiers(nodeIdsSlope);
+    return `Le nombre dérivé de $f$ en $x$, aussi noté $f'(x)$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $x$.
+  
+En manipulant le point $A$, on observe que :
+
+${alignTex(arrNodeX.map((nodeX) => {
+        return [`f'(${nodeX.toTex()})`, "=", `${nodeSlope.toTex()}`];
+    }))}
+
+La solution de l'équation est donc :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const slope = nodeSlope.evaluate();
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //solution
+        ...arrX.flatMap((x, i) => {
+            const image = nodeF.evaluate({
+                x,
+            });
+            return [
+                //tangent
+                `t${i}(x) = ${image} + (x-${x}) (${slope})`,
+                `SetColor(t${i}, "${orange}")`,
+                //curve point
+                `B${i} = (${x},${image})`,
+                `SetPointStyle(B${i}, 1)`,
+                //arrow
+                `v${i} = Vector(B${i}, Point({${x},0}))`,
+                `SetColor(v${i}, "${greenMain}")`,
+                //point
+                `C${i} = (${x},0)`,
+                `SetPointStyle(C${i}, 1)`,
+                `SetColor(C${i}, "${greenMain}")`,
+                `SetCaption(C${i}, "$${x.frenchify()}$")`,
+                `ShowLabel(C${i}, true)`,
+            ];
+        }),
+    ];
+    const xMin = Math.min(...arrX) - 2;
+    const xMax = Math.max(...arrX) + 2;
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+    const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const slope = nodeSlope.evaluate();
+    const arrX = arrNodeX.map((node) => node.evaluate());
+    const nodeDerivative = nodeF.derivative();
+    const arrNodeYIntercept = arrNodeX.map((nodeXAsked) => getNodeYIntercept(nodeF, nodeXAsked, nodeDerivative));
+    const xMin = Math.min(...arrX) - 2;
+    const xMax = Math.max(...arrX) + 2;
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const [minSlider, maxSlider] = [-50, 50];
+    const stepSlider = 0.01;
+    const valueSliderInitial = randfloat(yMin, yMax, 1, [
+        ...arrNodeYIntercept.map((nodeY) => nodeY.evaluate()),
+    ]);
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `SetColor(f, "${blueMain}")`,
+        //slider
+        `a = Slider(${minSlider}, ${maxSlider}, ${stepSlider})`,
+        `SetValue(a, ${valueSliderInitial})`,
+        `SetVisibleInView(a, 1, false)`,
+        //moving point
+        `A = (0,a)`,
+        "SetPointStyle(A, 0)",
+        "SetPointSize(A,5)",
+        `ShowLabel(A,true)`,
+        //tangent
+        `t(x) = a + (${slope})x `,
+        `SetColor(t, "${red}")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getPropositions = (n, { answer, ..._identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, _optsIn) => {
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.elements;
+    const parsed = discreteSetParser(ans);
+    if (!parsed) {
+        return false;
+    }
+    const arrAns = parsed.elements;
+    return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+};
+const createRandomIdentifiers = () => {
+    const nbX = randint(2, 4);
+    const arrX = (() => {
+        function createRandomArrX() {
+            const poolX = [...Array(11).keys()].map((i) => i - 5);
+            return randomMany(poolX, nbX).toSorted((v1, v2) => v1 - v2);
+        }
+        let arrX = [];
+        let isValid = false;
+        let counter = -1;
+        while (!isValid && counter < 100) {
+            counter++;
+            const arrXCandidate = createRandomArrX();
+            const isSeparatedNicely = () => zip(arrXCandidate.slice(0, -1), arrXCandidate.slice(1))
+                .map(([x1, x2]) => x2 - x1)
+                .find((elt) => elt === 1) === undefined;
+            isValid = isSeparatedNicely();
+            if (isValid) {
+                arrX = arrXCandidate;
+            }
+        }
+        if (!isValid) {
+            switch (nbX) {
+                case 0:
+                    return [-3];
+                case 1:
+                    return [-2, 3];
+                case 2:
+                    return [-4, 2, 5];
+            }
+        }
+        return arrX;
+    })();
+    const arrNodeX = arrX.map((x) => x.toTree());
+    //f'(x) = a(x-x1)...(x-xn) + k
+    //=> f'(x1) = ... = f'(xn) = k
+    const nodeA = frac(coinFlip() ? -1 : +1, 5 * nbX);
+    const maxSlopeAbs = 1.5;
+    const nodeK = randfloat(-maxSlopeAbs, maxSlopeAbs, 1, [0]).toTree();
+    const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, arrNodeX), nodeK);
+    const nodeC = randint(-3, 3).toTree();
+    const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC);
+    const identifiers = {
+        nodeIdsSlope: nodeK.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsAbscissa: arrNodeX.map((node) => node.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getDerivativeEquationSolvingByManipulatingLineYQuestion = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        const isReadable = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeF = NodeConstructor.fromIdentifiers(nodeIdsF);
+            const arrX = arrNodeX.map((node) => node.evaluate());
+            const xMin = Math.min(...arrX) - 2;
+            const xMax = Math.max(...arrX) + 2;
+            const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+            return frac(yMax - yMin, xMax - xMin).evaluate() <= 0.888;
+        };
+        const isDerivativeOk = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeDerivative = nodeF.derivative().simplify();
+            return arrNodeX.every((nodeX) => nodeDerivative.evaluate({ x: nodeX.evaluate() }) ===
+                nodeSlope.evaluate());
+        };
+        const isYInterceptsOk = (identifiers) => {
+            const { nodeIdsAbscissa, nodeIdsSlope, nodeIdsF } = identifiers;
+            const arrNodeX = nodeIdsAbscissa.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const [nodeSlope, nodeF] = [nodeIdsSlope, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const slope = nodeSlope.evaluate();
+            const nodeDerivative = nodeF.derivative().simplify();
+            const arrNodeYIntercept = arrNodeX.map((nodeX) => getNodeYIntercept(nodeF, nodeX, nodeDerivative));
+            const arrYInterceptSorted = arrNodeYIntercept
+                .map((node) => node.evaluate())
+                .toSorted((y1, y2) => y1 - y2);
+            const isReachableYIntercepts = () => {
+                const arrX = arrNodeX.map((node) => node.evaluate());
+                const xMin = Math.min(...arrX) - 1;
+                const xMax = Math.max(...arrX) + 1;
+                const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+                return arrYInterceptSorted.every((yIntercept) => yMin < yIntercept && yIntercept < yMax);
+            };
+            const isDistinctYIntercepts = () => {
+                return zip(arrYInterceptSorted.slice(0, -1), arrYInterceptSorted.slice(1)).every(([y1, y2]) => y2 - y1 > 0.666 * Math.abs(slope));
+            };
+            return isReachableYIntercepts() && isDistinctYIntercepts();
+        };
+        isValid =
+            isReadable(identifiersCandidate) &&
+                isDerivativeOk(identifiersCandidate) &&
+                isYInterceptsOk(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //copié-collé depuis le dashboard::viewer
+        const identifiersDefault = {
+            nodeIdsSlope: {
+                id: 7,
+                value: -0.2,
+            },
+            nodeIdsF: {
+                id: 3,
+                leftChild: {
+                    id: 0,
+                    leftChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 2025,
+                        },
+                        rightChild: {
+                            id: 5,
+                            leftChild: {
+                                id: 10,
+                                name: "x",
+                            },
+                            rightChild: {
+                                id: 7,
+                                value: 4,
+                            },
+                        },
+                    },
+                    rightChild: {
+                        id: 2,
+                        leftChild: {
+                            id: 7,
+                            value: 60,
+                        },
+                        rightChild: {
+                            id: 0,
+                            leftChild: {
+                                id: 2,
+                                leftChild: {
+                                    id: 7,
+                                    value: -225,
+                                },
+                                rightChild: {
+                                    id: 5,
+                                    leftChild: {
+                                        id: 10,
+                                        name: "x",
+                                    },
+                                    rightChild: {
+                                        id: 7,
+                                        value: 3,
+                                    },
+                                },
+                            },
+                            rightChild: {
+                                id: 2,
+                                leftChild: {
+                                    id: 7,
+                                    value: 9,
+                                },
+                                rightChild: {
+                                    id: 0,
+                                    leftChild: {
+                                        id: 2,
+                                        leftChild: {
+                                            id: 7,
+                                            value: -30,
+                                        },
+                                        rightChild: {
+                                            id: 5,
+                                            leftChild: {
+                                                id: 10,
+                                                name: "x",
+                                            },
+                                            rightChild: {
+                                                id: 7,
+                                                value: 2,
+                                            },
+                                        },
+                                    },
+                                    rightChild: {
+                                        id: 2,
+                                        leftChild: {
+                                            id: 7,
+                                            value: 15,
+                                        },
+                                        rightChild: {
+                                            id: 0,
+                                            leftChild: {
+                                                id: 2,
+                                                leftChild: {
+                                                    id: 7,
+                                                    value: 17,
+                                                },
+                                                rightChild: {
+                                                    id: 10,
+                                                    name: "x",
+                                                },
+                                            },
+                                            rightChild: {
+                                                id: 7,
+                                                value: -30,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                rightChild: {
+                    id: 7,
+                    value: 121500,
+                },
+            },
+            nodeIdsAbscissa: [
+                {
+                    id: 7,
+                    value: -2,
+                },
+                {
+                    id: 7,
+                    value: 2,
+                },
+                {
+                    id: 7,
+                    value: 5,
+                },
+            ],
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        keys: ["S", "equal", "lbrace", "semicolon", "rbrace"],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        identifiers,
+    };
+};
+export const derivativeEquationSolvingByManipulatingLineY = {
+    id: "derivativeEquationSolvingByManipulatingLineY",
+    connector: "=",
+    label: `Résoudre une équation du type "$f'(x) = k$" par la manipulation d'une droite de coefficient directeur fixé`,
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getDerivativeEquationSolvingByManipulatingLineYQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeEquationSolvingByManipulatingLineYAndSlope.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeEquationSolvingByManipulatingLineYAndSlope.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqE7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,eAAe,CAAC;IAC1B,eAAe,EAAE,eAAe,EAAE,CAAC;CACpC,CAAC;AAqiBF,eAAO,MAAM,oDAAoD,EAAE,QAAQ,CAAC,WAAW,CAmBpF,CAAC"}