math-exercises 3.0.178 → 3.0.179

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

@@ -0,0 +1,240 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { blueMain, greenMain, orange, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.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 { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const [xMin, xMax] = [-6, 6];
+const getInstruction = (identifiers) => {
+    const { k } = identifiers;
+    return `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant le curseur ou le point sur l'axe des abscisses,
+on peut faire apparaître la tangente à cette courbe au point d'abscisse de son choix.
+
+Résoudre l'équation $f'(x) = ${k.frenchify()}$.
+
+*On précise qu'ici, il y a une seule solution à cette équation.*`;
+};
+const getAnswerNode = (identifiers) => {
+    const { x } = identifiers;
+    return x.toTree();
+};
+const getAnswer = (identifiers) => {
+    return 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 { x, k } = identifiers;
+    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 curseur, on observe que $f'(${x}) = ${k.frenchify()}$.
+
+La solution de l'équation est donc $x = ${x}$.
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { x, nodeIds } = identifiers;
+    const [nodeC, nodeB, nodeA] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeX = "x".toTree();
+    const nodeF = add(nodeC, add(multiply(nodeB, nodeX), multiply(nodeA, power(nodeX, 2))));
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //tangent
+        `t(x) = f(${x}) + (x-${x}) f'(${x})`,
+        `SetColor(t, "${orange}")`,
+        //curve point
+        `B = (${x},f(${x}))`,
+        "SetPointStyle(B, 1)",
+        //slope label
+        `Lbl = Text("pente = " + f'(${x}), B, true, true, 0, -1)`, //pas réussi à changer le point en virgule
+        //solution
+        //arrow
+        `v = Vector(B, Point({${x},0}))`,
+        `SetColor(v, "${greenMain}")`,
+        //point
+        `C = (${x},0)`,
+        "SetPointStyle(C, 1)",
+        `SetColor(C, "${greenMain}")`,
+        `SetCaption(C, "$${x.frenchify()}$")`,
+        "ShowLabel(C, true)",
+    ];
+    const [yMin, yMax] = [xMin, xMax].map((x) => nodeF.evaluate({ x }));
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin: Math.min(yMin, -2),
+            yMax,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { x, nodeIds } = identifiers;
+    const [nodeC, nodeB, nodeA] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeX = "x".toTree();
+    const nodeF = add(nodeC, add(multiply(nodeB, nodeX), multiply(nodeA, power(nodeX, 2))));
+    const [minSlider, maxSlider] = [-6, 6];
+    const stepSlider = 0.5;
+    const valueSliderInitial = randint(minSlider, maxSlider, [x]);
+    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})`,
+        //moving point
+        `A = (a,0)`,
+        "SetPointStyle(A, 0)",
+        "SetPointSize(A,5)",
+        //tangent
+        `t(x) = f(a) + (x-a) f'(a)`,
+        `SetColor(t, "${red}")`,
+        //curve point
+        `B = (a,f(a))`,
+        "SetPointStyle(B, 1)",
+        //slope label
+        `Lbl = Text("pente = " + f'(a), B, true, true, 0, -1)`, //pas réussi à changer le point en virgule
+    ];
+    const [yMin, yMax] = [xMin, xMax].map((x) => nodeF.evaluate({ x }));
+    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 xWrong = (() => {
+            const num = randint(-10, 11, [0]);
+            const den = 2;
+            return new Rational(num, den).simplify();
+        })().value;
+        tryToAddWrongProp(propositions, xWrong.frenchify());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const createRandomIdentifiers = () => {
+    //x=m*0.5
+    const x = (() => {
+        const num = randint(-10, 11, [0]);
+        const den = 2;
+        return new Rational(num, den).simplify();
+    })();
+    //k=p*0.1
+    const k = (() => {
+        const num = (coinFlip() ? +1 : -1) * randint(5, 41);
+        const den = 10;
+        return new Rational(num, den).simplify();
+    })();
+    //f(x) = ax²+bx+c
+    //f'(x) = 2ax + b = k
+    //a = (k-b)/2x
+    const nodeB = ((coinFlip() ? +1 : -1) * randfloat(0, 1, 2, [0])).toTree();
+    const nodeA = frac(substract(k.toTree(), nodeB), multiply(2, x.toTree()));
+    const nodeC = (0).toTree();
+    const identifiers = {
+        x: x.value,
+        k: k.value,
+        nodeIds: [nodeC, nodeB, nodeA].map((node) => node.simplify().toIdentifiers()),
+    };
+    return identifiers;
+};
+const getDerivativeEquationSolvingByManipulatingPointQuestion = (opts) => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        function isValidFrameWise(identifiers) {
+            const { nodeIds } = identifiers;
+            const [nodeC, nodeB, nodeA] = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeX = "x".toTree();
+            const nodeF = add(nodeC, add(multiply(nodeB, nodeX), multiply(nodeA, power(nodeX, 2))));
+            const arrX = [...Array(xMax - xMin + 1).keys()].map((i) => i + xMin);
+            const arrY = arrX.map((x) => nodeF.evaluate({ x }));
+            const minY = Math.min(...arrY);
+            const maxY = Math.max(...arrY);
+            const spanY = maxY - minY;
+            return spanY < 15;
+        }
+        isValid = isValidFrameWise(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            x: -2.5,
+            k: 1.8,
+            nodeIds: [(0).toTree(), (0.37).toTree(), frac(143, 500)].map((node) => node.toIdentifiers()),
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        identifiers,
+    };
+};
+export const derivativeEquationSolvingByManipulatingPoint = {
+    id: "derivativeEquationSolvingByManipulatingPoint",
+    connector: "=",
+    label: `Résoudre une équation du type "$f'(x) = k$" par la manipulation de l'abscisse du point`,
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getDerivativeEquationSolvingByManipulatingPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeReadingByManipulatingBuildingTangent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeReadingByManipulatingBuildingTangent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAcrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,CAAC;CAChC,CAAC;AAmeF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CACnE,WAAW,EACX,OAAO,CAqBR,CAAC"}

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

@@ -0,0 +1,436 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { createIntegratedPolynomialNode, createNodeFPolynomialFromRoots, } 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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.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 { handleVEAError } from "../../../../utils/errors/handleVEAError.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,
+    };
+}
+const getInstruction = (identifiers, opts) => {
+    const { nodeIdsXAsked } = identifiers;
+    const nodeXAsked = NodeConstructor.fromIdentifiers(nodeIdsXAsked);
+    const notation = opts?.notationType === "Nombre dérivé de $f$ en $a$"
+        ? `le nombre dérivé de $f$ en $${nodeXAsked.toTex()}$`
+        : `$f'(${nodeXAsked.toTex()})$`;
+    return `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant les points $A$ et $B$, construire la tangente à $C_f$ au point d'abscisse $${nodeXAsked.toTex()}$ et
+en déduire ${notation} (valeur approximative).`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = nodeF.derivative();
+    const nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+    return round(nodeValueDerivative.evaluate(), 1).toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Le nombre dérivé de $f$ en $a$, aussi noté $f'(a)$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $a$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsXAsked } = identifiers;
+    const [nodeXAsked] = [nodeIdsXAsked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texXAsked = nodeXAsked.toTex();
+    const texAnswer = getAnswer(identifiers);
+    return `Le nombre dérivé de $f$ en $${texXAsked}$, aussi noté $f'(${texXAsked})$,
+est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $${texXAsked}$.
+Ici, on doit donc lire le coefficient directeur de la tangente passant par le point d'abscisse $${texXAsked}$. 
+
+On lit comme coefficient directeur $${texAnswer}$.
+On a donc :
+
+$$
+f'(${texXAsked}) \\approx ${texAnswer}
+$$`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xAsked = nodeXAsked.evaluate();
+    const nodeDerivative = nodeF.derivative().simplify();
+    const valueFunction = nodeF.evaluate({ x: xAsked });
+    const valueDerivative = nodeDerivative.evaluate({ x: xAsked });
+    const commands = [
+        //function
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //tangent
+        `t(x) = ${valueFunction} + (x-${xAsked}) (${valueDerivative})`,
+        `SetColor(t, "${greenMain}")`,
+    ];
+    const xMin = xAsked - 2;
+    const xMax = xAsked + 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 { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const xAsked = nodeXAsked.evaluate();
+    const xMin = xAsked - 2;
+    const xMax = xAsked + 2;
+    const { yMin, yMax } = getCoordsFrame(nodeF, xMin, xMax);
+    const pointA = new Point("A", xMin + 0.25 * (xMax - xMin), yMin + 0.75 * (yMax - yMin));
+    const pointB = new Point("B", xMin + 0.75 * (xMax - xMin), yMin + 0.25 * (yMax - yMin));
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //line with slope
+        ...pointA.toGGBCommand({
+            isFixed: false,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 5,
+        }),
+        ...pointB.toGGBCommand({
+            isFixed: false,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 5,
+        }),
+        `lineAB = Line(A,B)`,
+        `s = Slope(lineAB)`,
+    ];
+    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 maxSlopeAbs = 1.5;
+        const nodeK = randfloat(-maxSlopeAbs, maxSlopeAbs, 2, [0]).toTree();
+        const texWrong = nodeK.toTex();
+        if (!isAnswerValid(texWrong, { answer, ...identifiers })) {
+            tryToAddWrongProp(propositions, texWrong);
+        }
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((tex) => parseAlgebraic(tex));
+        const [valueAns, valueAnswer] = [nodeAns, nodeAnswer].map((node) => node.evaluate());
+        //+/-5°
+        const [angleAns, angleAnswer] = [valueAns, valueAnswer].map((value) => (Math.atan2(value, 1) * 180.0) / Math.PI);
+        const [angleMin, angleMax] = [-5, +5].map((offset) => angleAnswer + offset);
+        const isValid = angleMin < angleAns && angleAns < angleMax;
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+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, 2, [0]).toTree();
+    const nodeDerivative = add(createNodeFPolynomialFromRoots(nodeA, arrNodeX), nodeK);
+    const nodeC = randint(-3, 3).toTree();
+    const nodeF = createIntegratedPolynomialNode(nodeDerivative, nodeC);
+    const indexAsked = randint(0, arrNodeX.length);
+    const nodeXAsked = arrNodeX[indexAsked];
+    const identifiers = {
+        nodeIdsSlope: nodeK.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        nodeIdsXAsked: nodeXAsked.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getDerivativeReadingByManipulatingBuildingTangentQuestion = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        const isReadable = (identifiers) => {
+            const { nodeIdsXAsked, nodeIdsF } = identifiers;
+            const arrNodeX = [nodeIdsXAsked].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 { nodeIdsXAsked, nodeIdsSlope, nodeIdsF } = identifiers;
+            const arrNodeX = [nodeIdsXAsked].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 isNaNing = (identifiers) => {
+            return getAnswer(identifiers) === "NaN";
+        };
+        isValid =
+            isReadable(identifiersCandidate) &&
+                isDerivativeOk(identifiersCandidate) &&
+                !isNaNing(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,
+                },
+            },
+            nodeIdsXAsked: {
+                id: 7,
+                value: 2,
+            },
+        };
+        identifiers = identifiersDefault;
+    }
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: "a",
+        answer: getAnswer(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        identifiers,
+    };
+};
+const options = [
+    {
+        id: "notationType",
+        label: "",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.instruction,
+        values: ["Nombre dérivé de $f$ en $a$", "$f'(a)$"],
+        defaultValue: "$f'(a)$",
+    },
+];
+export const derivativeReadingByManipulatingBuildingTangent = {
+    id: "derivativeReadingByManipulatingBuildingTangent",
+    connector: "=",
+    label: "Lire graphiquement un nombre dérivé par la manipulation (construction de la tangente)",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeReadingByManipulatingBuildingTangentQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};