math-exercises 3.0.177 → 3.0.179

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    A: number[];
+    B: number[];
+    coeffs: number[];
+};
+type Options = {
+    notationType: string;
+};
+export declare const derivativeReadingByManipulatingPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=derivativeReadingByManipulatingPoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeReadingByManipulatingPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeReadingByManipulatingPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA+NF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAkBR,CAAC"}

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

@@ -0,0 +1,219 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, orange } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Integer } from "../../../../math/numbers/integer/integer.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { rationalParser } from "../../../../tree/parsers/rationalParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers, opts) => {
+    const { A } = identifiers;
+    const xA = A[0];
+    const notation = opts?.notationType === "Nombre dérivé de $f$ en $a$"
+        ? `le nombre dérivé de $f$ en $${xA.frenchify()}$`
+        : `$f'(${xA.frenchify()})$`;
+    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.
+
+Déterminer ${notation}.`;
+};
+const getAnswer = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteTree = pente.toTree();
+    const answer = penteTree.toTex();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const [minSlider, maxSlider] = [-6, 6];
+    const stepSlider = 0.5;
+    const valueSliderInitial = randint(minSlider, maxSlider, [xA]);
+    const polynome = new Polynomial(identifiers.coeffs);
+    const commands = [
+        `f(x) = ${polynome.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        //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)`,
+        //curve point
+        `B = (a,f(a))`,
+        "SetPointStyle(B, 1)",
+    ];
+    const xMin = Math.min(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const xMax = Math.max(xA, xB);
+    const yMax = Math.max(yA, yB);
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+    });
+};
+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 { A, B } = identifiers;
+    const xA = A[0];
+    const yA = A[1];
+    const xB = B[0];
+    const yB = B[1];
+    return `Le nombre dérivé de $f$ en $${xA.frenchify()}$, aussi noté $f'(${xA.frenchify()})$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $${xA.frenchify()}$.
+  
+Ici, on doit donc lire le coefficient directeur de la tangente passant par $A(${xA.frenchify()};${yA.frenchify()})$. 
+
+On lit un deuxième point par lequel passe cette tangente : c'est $B(${xB.frenchify()};${yB.frenchify()})$.
+
+Le coefficient directeur est donc : 
+
+$$
+${frac(substract(yB, yA), substract(xB, xA)).toSimplificationTex()}
+$$
+
+C'est donc le nombre dérivé de $f$ en $${xA.frenchify()}$, noté $f'(${xA.frenchify()})$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { A, B } = identifiers;
+    const xA = A[0];
+    const xB = B[0];
+    const yA = A[1];
+    const yB = B[1];
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const origin = pente
+        .opposite()
+        .multiply(new Integer(xA))
+        .add(new Integer(yA));
+    const penteTree = pente.toTree();
+    const originTree = origin.toTree();
+    const penteString = penteTree.toMathString();
+    const originString = originTree.toMathString();
+    const polynome = new Polynomial(identifiers.coeffs);
+    const commands = [
+        `f(x) = ${polynome.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `g(x) = (${penteString}) * x + (${originString})`,
+        `SetColor(g, "${orange}")`,
+        `A = (${xA},${yA})`,
+        "SetFixed(A, true, false)",
+        "SetPointStyle(A, 1)",
+    ];
+    const xMin = Math.min(xA, xB);
+    const yMin = Math.min(yA, yB);
+    const xMax = Math.max(xA, xB);
+    const yMax = Math.max(yA, yB);
+    const ggb = new GeogebraConstructor({
+        commands,
+    });
+    return ggb.getOptions({
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+    });
+};
+const getPropositions = (n, { answer, A, B }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (B[1] - A[1] !== 0)
+        tryToAddWrongProp(propositions, new Rational(B[0] - A[0], B[1] - A[1]).simplify().toTree().toTex());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new NumberNode(randint(-4, 5, [0]));
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = rationalParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDerivativeReadingByManipulatingPointQuestion = (opts) => {
+    const [xA, yA] = [1, 2].map((_el) => randint(-5, 6));
+    const xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    const yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+    const pente = new Rational(yB - yA, xB - xA).simplify();
+    const penteValue = pente.value;
+    const [a, b] = [
+        (3 * randint(-100, 100, [0])) / 100,
+        (2 * randint(-4, 5)) / 100,
+    ];
+    const c = penteValue - a * Math.pow(xA, 2) - b * xA;
+    const d = yA - (a / 3) * Math.pow(xA, 3) - (b / 2) * Math.pow(xA, 2) - xA * c;
+    const identifiers = {
+        A: [xA, yA],
+        B: [xB, yB],
+        coeffs: [d, c, b / 2, a / 3],
+    };
+    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 derivativeReadingByManipulatingPoint = {
+    id: "derivativeReadingByManipulatingPoint",
+    connector: "=",
+    label: "Lire graphiquement un nombre dérivé par la manipulation de l'abscisse du point",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getDerivativeReadingByManipulatingPointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    x: number;
+    k: number;
+    nodeIds: NodeIdentifiers[];
+};
+type Options = {
+    notationType: string;
+};
+export declare const derivativeReadingByManipulatingSecant: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=derivativeReadingByManipulatingSecant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeReadingByManipulatingSecant.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/derivativeReadingByManipulatingSecant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAwTF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAqBR,CAAC"}

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

@@ -0,0 +1,273 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange } 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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const [xMin, xMax] = [-6, 6];
+const getInstruction = (identifiers, opts) => {
+    const { x: xA } = identifiers;
+    const notation = opts?.notationType === "Nombre dérivé de $f$ en $a$"
+        ? `le nombre dérivé de $f$ en $${xA.frenchify()}$`
+        : `$f'(${xA.frenchify()})$`;
+    return `Ci-dessous est tracée la courbe $\\mathcal C_f$ de la fonction $f$.
+  
+En manipulant les points $A$ et $B$,
+on peut construire la sécante à $C_f$ passant par $A$ et $B$.
+
+Déterminer ${notation} (donner une valeur approximative).`;
+};
+const getAnswerNode = (identifiers) => {
+    const { k } = identifiers;
+    return k.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$.
+
+La tangente au point $C$ est la droite que l'on obtient quand $A$ et $B$ sont infiniment proches de $C$, en restant tous deux distincts.
+`;
+};
+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$.
+
+La tangente au point $C$ est la droite que l'on obtient quand $A$ et $B$ sont infiniment proches de $C$, en restant tous deux distincts.
+  
+En manipulant les points $A$ et $B$, on observe que $f'(${x.frenchify()}) \\approx ${k.frenchify()}$.`;
+};
+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, "${greenMain}")`,
+        //moving point
+        `A = (${x - 0.1},f(${x - 0.1}))`,
+        "SetPointStyle(A, 0)",
+        "SetPointSize(A,5)",
+        "ShowLabel(A,true)",
+        `B = (${x + 0.1},f(${x + 0.1}))`,
+        "SetPointStyle(B, 0)",
+        "SetPointSize(B,5)",
+        "ShowLabel(B,true)",
+        //secant
+        `lineAB = Line(A,B)`,
+        `SetColor(lineAB, "${orange}")`,
+        `s = Slope(lineAB)`,
+    ];
+    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 [minSliderA, maxSliderA] = [-6, 6];
+    const stepSliderA = 0.1;
+    const valueSliderInitialA = randint(minSliderA, -1, [x]);
+    const [minSliderB, maxSliderB] = [-6, 6];
+    const stepSliderB = 0.1;
+    const valueSliderInitialB = randint(1, maxSliderB, [x]);
+    const commands = [
+        `f(x) = ${nodeF.toMathString()}`,
+        `SetColor(f, "${blueMain}")`,
+        `SetCaption(f, "$\\mathcal C_f$")`,
+        `ShowLabel(f, true)`,
+        `SetColor(f, "${blueMain}")`,
+        //sliderA
+        `a = Slider(${minSliderA}, ${maxSliderA}, ${stepSliderA})`,
+        `SetValue(a, ${valueSliderInitialA})`,
+        `SetVisibleInView(a, 1, false)`,
+        //moving point
+        `A = (a,f(a))`,
+        "SetPointStyle(A, 0)",
+        "SetPointSize(A,5)",
+        "ShowLabel(A,true)",
+        //sliderB
+        `b = Slider(${minSliderB}, ${maxSliderB}, ${stepSliderB})`,
+        `SetValue(b, ${valueSliderInitialB})`,
+        `SetVisibleInView(b, 1, false)`,
+        //moving point
+        `B = (b,f(b))`,
+        "SetPointStyle(B, 0)",
+        "SetPointSize(B,5)",
+        "ShowLabel(B,true)",
+        //secant
+        `lineAB = Line(A,B)`,
+        `s = Slope(lineAB)`,
+    ];
+    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: Math.max(yMax, 2),
+        }),
+    });
+};
+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 }) => {
+    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 = () => {
+    //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 getDerivativeReadingByManipulatingSecantQuestion = (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,
+    };
+};
+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 derivativeReadingByManipulatingSecant = {
+    id: "derivativeReadingByManipulatingSecant",
+    connector: "=",
+    label: "Lire graphiquement un nombre dérivé par la manipulation d'une sécante",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getDerivativeReadingByManipulatingSecantQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointOfFunctionIdentifiers } from "../../../../math/utils/polynomial/polynomialInterpolationUtils.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type CubicSplineChunkIdentifiers = {
+    nodeIdsFCubic: NodeIdentifiers;
+    nodeIdsXStart: NodeIdentifiers;
+    nodeIdsXEnd: NodeIdentifiers;
+};
+type CubicSplineIds = {
+    chunkIds: CubicSplineChunkIdentifiers[];
+};
+type Identifiers = {
+    pofIds: PointOfFunctionIdentifiers[];
+    cubicSplineIds: CubicSplineIds;
+};
+export declare const placePointsOfDerivativeFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placePointsOfDerivativeFromGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"placePointsOfDerivativeFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/tangent/placePointsOfDerivativeFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EAIL,0BAA0B,EAC3B,MAAM,6DAA6D,CAAC;AAGrE,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6C7C,KAAK,2BAA2B,GAAG;IACjC,aAAa,EAAE,eAAe,CAAC;IAC/B,aAAa,EAAE,eAAe,CAAC;IAC/B,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AAqBF,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,2BAA2B,EAAE,CAAC;CACzC,CAAC;AAwBF,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,0BAA0B,EAAE,CAAC;IACrC,cAAc,EAAE,cAAc,CAAC;CAChC,CAAC;AAyRF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAqBlE,CAAC"}