math-exercises 3.0.178 → 3.0.180

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

@@ -0,0 +1,326 @@
+import { addValidProp, tryToAddWrongProp, propWhile, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { PolynomialConstructor } from "../../../../math/polynomials/polynomial.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power, square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeShuffler } from "../../../../tree/utilities/nodeShuffler.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getNodeFForTypeF = (typeF) => {
+    const nodeVarX = "x".toTree();
+    switch (typeF) {
+        case "$k$":
+            return randint(-10, 11).toTree();
+        case "$x$":
+            return nodeVarX;
+        case "$x^2$":
+            return square(nodeVarX);
+        case "$x^n \\ (n>=3)$":
+            return power(nodeVarX, randint(3, 6));
+        case "$\\frac{1}{x}$":
+            return frac(1, nodeVarX);
+        case "$\\frac{1}{x^n} \\ (n>=2)$":
+            return frac(1, power(nodeVarX, randint(3, 6)));
+        case "$\\sqrt{x}$":
+            return sqrt(nodeVarX);
+        case "polynôme (degré $1$)":
+            return AffineConstructor.random().toTree();
+        case "polynôme (degré $2$)":
+            return TrinomConstructor.random().toTree();
+        case "polynôme (degré $3$)":
+            return PolynomialConstructor.randomWithOrder(3).toTree();
+        case "$\\frac{ax+b}{cx+d}$": {
+            const [nodeNum, nodeDen] = AffineConstructor.differentRandoms(2).map((affine) => affine.toTree());
+            return frac(nodeNum, nodeDen);
+        }
+        case "$(ax+b)\\sqrt{x}$": {
+            const nodeAffine = AffineConstructor.random().toTree();
+            return multiply(nodeAffine, sqrt(nodeVarX));
+        }
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getRandomNodeXAskedForTypeF = (typeF) => {
+    switch (typeF) {
+        case "$\\frac{1}{x}$":
+        case "$\\frac{1}{x^n} \\ (n>=2)$":
+            return randint(-5, 6, [0]).toTree();
+        case "$\\sqrt{x}$":
+        case "$(ax+b)\\sqrt{x}$":
+            return randint(1, 6).toTree();
+        default:
+            return randint(-5, 6).toTree();
+    }
+};
+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 { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soit $f$ une fonction telle que, pour tout $x$ dans l'ensemble de dérivation de $f$ :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+  
+Déterminer $f'(${nodeXAsked.toTex()})$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    return nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { typeF } = identifiers;
+    switch (typeF) {
+        case "$k$":
+            return `Soit $k$ un réel. La dérivée de $x \\mapsto k$ est $x \\mapsto 0$.`;
+        case "$x$":
+            return `La dérivée de $x \\mapsto x$ est $x \\mapsto 1$.`;
+        case "$x^2$":
+            return `La dérivée de $x \\mapsto x^2$ est $x \\mapsto 2x$.`;
+        case "$x^n \\ (n>=3)$":
+            return `Soit $n$ un entier tel que $n \\geq 3$. La dérivée de $x \\mapsto x^n$ est $x \\mapsto nx^{n-1}$.`;
+        case "$\\frac{1}{x}$":
+            return `Soit $n$ un entier. La dérivée de $x \\mapsto \\frac{1}{x}$ est $x \\mapsto -\\frac{1}{x^2}$.`;
+        case "$\\frac{1}{x^n} \\ (n>=2)$":
+            return `Soit $n$ un entier tel que $n \\geq 2$. La dérivée de $x \\mapsto \\frac{1}{x^n}$ est $x \\mapsto \\frac{-n}{x^{n+1}}$.`;
+        case "$\\sqrt{x}$":
+            return `La dérivée de $x \\mapsto \\sqrt{x}$ est $x \\mapsto \\frac{1}{2\\sqrt{x}}$.`;
+        case "polynôme (degré $1$)":
+            return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto ax+b$ est $x \\mapsto a$.`;
+        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{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 "$(ax+b)\\sqrt{x}$":
+            return `Soient $a$ et $b$ deux réels. La dérivée de $x \\mapsto (ax+b)\\sqrt{x}$ est $x \\mapsto a\\sqrt{x}+(ax+b)\\frac{1}{2\\sqrt{x}}$.`;
+        default:
+            throw new Error("Unsupported typeF: " + typeF);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    const nodeValueDerivative = getAnswerNode(identifiers);
+    return `
+Pour $x$ dans l'ensemble de dérivation de $f$, on calcule : 
+
+${alignTex([
+        [`f'(x)`, "=", nodeF.derivative().toTex()],
+        [`f'(x)`, "=", nodeDerivative.toTex()],
+    ])}
+
+Donc :
+
+$$
+f'(${nodeXAsked.toTex()}) =  ${nodeValueDerivative.simplify().toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeIdsXAsked, nodeIdsF } = identifiers;
+    const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeDerivative = getPrettyDerivativeNode(nodeF);
+    function tryToAddWrongPropWithSuccess(propositions, tex, format) {
+        const nbPropsBefore = propositions.length;
+        tryToAddWrongProp(propositions, tex, format);
+        const nbPropsAfter = propositions.length;
+        return nbPropsAfter !== nbPropsBefore;
+    }
+    propWhile(propositions, n, () => {
+        if (!tryToAddWrongPropWithSuccess(propositions, (() => {
+            const nodeFShuffled = NodeShuffler.deepShuffle(nodeF);
+            const identifiersWrong = {
+                ...identifiers,
+                nodeIdsF: nodeFShuffled.toIdentifiers(),
+            };
+            return getAnswer(identifiersWrong);
+        })())) {
+            if (!tryToAddWrongPropWithSuccess(propositions, (() => {
+                const nodeDerivativeShuffled = NodeShuffler.deepShuffle(nodeDerivative);
+                const nodeWrong = nodeBySubstitutingVar(nodeDerivativeShuffled, nodeXAsked, "x".toTree()).simplify();
+                return nodeWrong.simplify().toTex();
+            })())) {
+                try {
+                    tryToAddWrongPropWithSuccess(propositions, (() => {
+                        const typeF = random(arrayedOptsDefault.typeF);
+                        const identifiersWrong = createRandomIdentifiers(typeF);
+                        return getAnswer(identifiersWrong);
+                    })());
+                }
+                catch (_) {
+                    tryToAddWrongProp(propositions, randint(-20, 20).frenchify());
+                }
+            }
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isValid = substract(nodeAns, nodeAnswer).evaluate() === 0;
+        return isValid;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (typeF) => {
+    const nodeF = getNodeFForTypeF(typeF);
+    const nodeXAsked = getRandomNodeXAskedForTypeF(typeF);
+    const identifiers = {
+        nodeIdsXAsked: nodeXAsked.toIdentifiers(),
+        nodeIdsF: nodeF.toIdentifiers(),
+        typeF,
+    };
+    return identifiers;
+};
+const getValueDerivativeFromFunctionExpressionQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? arrayedOptsDefault;
+    const typeF = random(arrayedOptions.typeF);
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers(typeF);
+        const isExploding = (identifiers) => {
+            const { nodeIdsXAsked, nodeIdsF } = identifiers;
+            const [nodeXAsked, nodeF] = [nodeIdsXAsked, nodeIdsF].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            const nodeDerivative = getPrettyDerivativeNode(nodeF);
+            let isExploding = false;
+            try {
+                const _nodeValueFunction = nodeBySubstitutingVar(nodeF, nodeXAsked, "x".toTree()).simplify();
+                const _nodeValueDerivative = nodeBySubstitutingVar(nodeDerivative, nodeXAsked, "x".toTree()).simplify();
+            }
+            catch (_) {
+                isExploding = true;
+            }
+            return isExploding;
+        };
+        isValid = !isExploding(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const identifiersDefault = {
+            nodeIdsXAsked: {
+                id: 7,
+                value: 3,
+            },
+            nodeIdsF: {
+                id: 10,
+                name: "x",
+            },
+            typeF: "$x$",
+        };
+        identifiers = identifiersDefault;
+    }
+    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),
+    };
+};
+const arrayedOptsDefault = {
+    typeF: [
+        "$k$",
+        "$x$",
+        "$x^2$",
+        "$x^n \\ (n>=3)$",
+        "$\\frac{1}{x}$",
+        "$\\frac{1}{x^n} \\ (n>=2)$",
+        "$\\sqrt{x}$",
+        "polynôme (degré $1$)",
+        "polynôme (degré $2$)",
+        "polynôme (degré $3$)",
+        "$\\frac{ax+b}{cx+d}$",
+        "$(ax+b)\\sqrt{x}$",
+    ],
+};
+const options = [
+    {
+        id: "typeF",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "$k$",
+            "$x$",
+            "$x^2$",
+            "$x^n \\ (n>=3)$",
+            "$\\frac{1}{x}$",
+            "$\\frac{1}{x^n} \\ (n>=2)$",
+            "$\\sqrt{x}$",
+            "polynôme (degré $1$)",
+            "polynôme (degré $2$)",
+            "polynôme (degré $3$)",
+            "$\\frac{ax+b}{cx+d}$",
+            "$(ax+b)\\sqrt{x}$",
+        ],
+        defaultValue: arrayedOptsDefault.typeF,
+    },
+];
+export const valueDerivativeFromFunctionExpression = {
+    id: "valueDerivativeFromFunctionExpression",
+    connector: "=",
+    label: "Déterminer $f'(a)$ à partir de l'expression d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getValueDerivativeFromFunctionExpressionQuestion(opts), nb),
+    options,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    isAnswerValid,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivativeNumber/signOfDerivativeNumberFromFunctionCurve.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    x1: number;
+    x2: number;
+    x3: number;
+    xAsked: number;
+};
+type Options = {
+    notationType: string;
+};
+export declare const signOfDerivativeNumberFromFunctionCurve: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=signOfDerivativeNumberFromFunctionCurve.d.ts.map

package/lib/exercises/math/derivation/derivativeNumber/signOfDerivativeNumberFromFunctionCurve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signOfDerivativeNumberFromFunctionCurve.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/signOfDerivativeNumberFromFunctionCurve.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AA0DrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmKF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAeF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAC5D,WAAW,EACX,OAAO,CAwBR,CAAC"}

package/lib/exercises/math/derivation/derivativeNumber/signOfDerivativeNumberFromFunctionCurve.js

@@ -0,0 +1,181 @@
+import { GeneratorOptionType, GeneratorOptionTarget, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, orange, purpleMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getNodeDerivative = (a, x1, x2, x3) => {
+    const nodeX = "x".toTree();
+    const nodeF = multiply(a, multiply(substract(nodeX, x1), multiply(substract(nodeX, x2), substract(nodeX, x3))));
+    const nodeDerivative = nodeF.derivative();
+    return nodeDerivative;
+};
+const getGGBCoords = (a, x1, x2, x3, xAsked) => {
+    const func = (x) => a * (x - x1) * (x - x2) * (x - x3);
+    const xMin = Math.min(x1, x2, x3, xAsked);
+    const xMax = Math.max(x1, x2, x3, xAsked);
+    const [yMin, yMax] = (() => {
+        const root1 = (2 * (x1 + x2 + x3) -
+            Math.sqrt(4 * (x1 + x2 + x3) ** 2 - 12 * (x1 * x2 + x1 * x3 + x2 * x3))) /
+            6;
+        const root2 = (2 * (x1 + x2 + x3) +
+            Math.sqrt(4 * (x1 + x2 + x3) ** 2 - 12 * (x1 * x2 + x1 * x3 + x2 * x3))) /
+            6;
+        const [fx1, fx2, fxAsked] = [func(root1), func(root2), func(xAsked)];
+        const yMin = Math.min(fx1, fx2, fxAsked);
+        const yMax = Math.max(fx1, fx2, fxAsked);
+        return [yMin, yMax];
+    })();
+    return [xMin, xMax, yMin, yMax];
+};
+const getInstruction = (identifiers, optsIn) => {
+    const { xAsked } = identifiers;
+    const opts = optsIn ?? optsDefault;
+    const strOfDerivativeNumber = opts.notationType === "Nombre dérivé de $f$ en $a$"
+        ? `du nombre dérivé de $f$ en $${xAsked}$`
+        : `de $f'(${xAsked})$`;
+    return `On donne la représentation graphique d'une fonction $f$ définie sur $\\mathbb{R}$. 
+    
+Quel est le signe ${strOfDerivativeNumber} ?
+`;
+};
+const getAnswer = (identifiers) => {
+    const { a, xAsked: x, x1, x2, x3 } = identifiers;
+    return getNodeDerivative(a, x1, x2, x3).evaluate({ x }) > 0 ? "+" : "-";
+};
+const getHint = (identifiers) => {
+    const { xAsked } = identifiers;
+    return `Le nombre dérivé de $f$ en $${xAsked}$, aussi noté $f'(${xAsked})$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $${xAsked}$.`;
+};
+const getCorrection = (identifiers, _optsIn) => {
+    const answerFromIdentifiers = getAnswer(identifiers);
+    const { xAsked } = identifiers;
+    return `Le nombre dérivé de $f$ en $${xAsked}$, aussi noté $f'(${xAsked})$, est le coefficient directeur la tangente à la courbe représentative de $f$ au point d'abscisse $${xAsked}$.
+  
+Si on trace la tangente à la courbe représentative de $f$ au point d'abscisse $${xAsked}$, on observe que la pente est ${{ "+": "positive", "-": "négative" }[answerFromIdentifiers]}.
+  
+On a donc $f'(${xAsked}) ${{ "+": ">", "-": "<" }[answerFromIdentifiers]} 0$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { a, x1, x2, x3, xAsked } = identifiers;
+    const answerFromIdentifiers = getAnswer(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function
+            `f(x) = ${a}*(x-${x1})*(x-${x2})*(x-${x3})`,
+            `SetColor(f, "${blueMain}")`,
+            //tangent
+            `t(x) = f(${xAsked}) + f'(${xAsked})(x-${xAsked})`,
+            `SetColor(t, "${{ "+": orange, "-": purpleMain }[answerFromIdentifiers]}")`,
+        ],
+        lockedAxesRatio: false,
+        gridDistance: false,
+        xAxis: {
+            steps: 1,
+        },
+    });
+    const [xMin, xMax, yMin, yMax] = getGGBCoords(a, x1, x2, x3, xAsked);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { a, x1, x2, x3, xAsked } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            //function
+            `f(x) = ${a}*(x-${x1})*(x-${x2})*(x-${x3})`,
+            `SetColor(f, "${blueMain}")`,
+        ],
+        lockedAxesRatio: false,
+        gridDistance: false,
+        xAxis: {
+            steps: 1,
+        },
+    });
+    const [xMin, xMax, yMin, yMax] = getGGBCoords(a, x1, x2, x3, xAsked);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2],
+    });
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["+", "-"].forEach((texProp) => {
+        if (texProp === answerFromIdentifiers) {
+            addValidProp(propositions, texProp);
+        }
+        else {
+            tryToAddWrongProp(propositions, texProp);
+        }
+    });
+    return propositions;
+};
+const getSignOfDerivativeNumberFromFunctionCurveQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const x1 = randint(-9, 10);
+    const x2 = randint(-9, 10, [x1]);
+    const x3 = randint(-9, 10, [x1, x2]);
+    const sorted = [x1, x2, x3].sort((a, b) => a - b);
+    const a = randfloat(-1, 1, 4, [0]);
+    const nodeDerivative = getNodeDerivative(a, x1, x2, x3);
+    const poolXCandidate = [...Array(15).keys()].map((i) => i - 7);
+    const xAsked = shuffle(poolXCandidate).find((x) => abs(nodeDerivative.evaluate({ x })).evaluate() > 0.666);
+    const identifiers = {
+        a,
+        x1: sorted[0],
+        x2: sorted[1],
+        x3: sorted[2],
+        xAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        options: opts,
+    };
+};
+const optsDefault = {
+    notationType: "$f'(a)$",
+};
+const options = [
+    {
+        id: "notationType",
+        label: "",
+        type: GeneratorOptionType.select,
+        target: GeneratorOptionTarget.instruction,
+        values: ["Nombre dérivé de $f$ en $a$", "$f'(a)$"],
+        defaultValue: optsDefault.notationType,
+    },
+];
+export const signOfDerivativeNumberFromFunctionCurve = {
+    id: "signOfDerivativeNumberFromFunctionCurve",
+    label: "Donner le signe de $f'(a)$ à partir de la représentation graphique de $f$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignOfDerivativeNumberFromFunctionCurveQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    getPropositions,
+};

package/lib/exercises/math/derivation/derivativeNumber/valueTableImageAndDerivativeFromFunctionExpression.d.ts

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

package/lib/exercises/math/derivation/derivativeNumber/valueTableImageAndDerivativeFromFunctionExpression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueTableImageAndDerivativeFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/valueTableImageAndDerivativeFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4B7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAoRF,eAAO,MAAM,kDAAkD,EAAE,QAAQ,CAAC,WAAW,CAsBlF,CAAC"}