math-exercises 3.0.169 → 3.0.171

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

@@ -1,11 +1,12 @@
 import { Exercise } from "../../../../exercises/exercise.js";
 import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    aIds: NodeIdentifiers;
-    fxIds: NodeIdentifiers;
+    type: number;
+    functionIds: NodeIdentifiers;
+    a: number;
 };
 type Options = {
-    functionType: string[];
+    functionTypes: string[];
 };
 export declare const averageRateOfChangeAlgebraicExpression: Exercise<Identifiers, Options>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"averageRateOfChangeAlgebraicExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/averageRateOfChangeAlgebraicExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAyEF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAuCF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAyBR,CAAC"}
+{"version":3,"file":"averageRateOfChangeAlgebraicExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/averageRateOfChangeAlgebraicExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,eAAe,CAAC;IAC7B,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkSF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AA8BF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAwBR,CAAC"}

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

@@ -1,90 +1,285 @@
-import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { reifyAlgebraic, } 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 { square } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getPropositions = (n, { answer }) => {
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
     addValidProp(propositions, answer);
-    propWhile(propositions, n, () => {
-        throw Error("QCM not implemented");
-    });
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: a.toTree() })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: "h".toTree() })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    let safeA = randint(-10, 10, [0]);
+    let isSafe = false;
+    let counter = 0;
+    while (!isSafe && counter < 100) {
+        counter++;
+        if (counter > 100) {
+            throw new Error("Too many iterations in getPropositions expressFAPlusH");
+        }
+        try {
+            fct.toDetailedEvaluation({ x: safeA.toTree() }).simplify();
+            isSafe = true;
+        }
+        catch (_e) {
+            safeA = randint(-10, 10, [0]);
+        }
+    }
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: add(safeA, "h") })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
-    const { fxIds, aIds } = identifiers;
-    const fx = reifyAlgebraic(fxIds);
-    const a = reifyAlgebraic(aIds);
-    const fa = fx.toDetailedEvaluation({ x: a });
-    const fah = fx.toDetailedEvaluation({ x: add(a, "h") }).simplify({
+const getAnswerNode = (identifiers) => {
+    const { a, functionIds, type } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    const faSimp = fct.toDetailedEvaluation({ x: a.toTree() }).simplify();
+    const fahSimp = fct.toDetailedEvaluation({ x: add(a, "h") }).simplify({
         towardsDistribute: true,
         forbidFactorize: true,
     });
-    return frac(substract(fah, fa), "h").simplify().toTex();
+    const diff = substract(fahSimp, faSimp);
+    const diffSimp = diff.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceAddFractions: true,
+    });
+    const taux = type === 0 || type === 1
+        ? frac(diffSimp, "h")
+        : multiply(diffSimp, frac(1, "h"));
+    //? terrible manipulation pour faire marcher le cas dans ce cas très chiant
+    const tauxSimp = type === 3
+        ? frac(frac(diffSimp.leftChild, "h").simplify({
+            forceDistributeFractions: true,
+        }), diffSimp.rightChild)
+        : taux.simplify({
+            forceDistributeFractions: type === 0 || type === 1,
+        });
+    return tauxSimp;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
 };
 const getInstruction = (identifiers) => {
-    const { fxIds, aIds } = identifiers;
-    const fx = reifyAlgebraic(fxIds);
-    const a = reifyAlgebraic(aIds);
-    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    return `On considère la fonction $f$ définie par : 
   
 $$
-f(x) = ${fx.toTex()}
+f(x) = ${fct.toTex()}
 $$
 
-Pour un nombre réel $h>0$, donner l'expression algébrique du taux d'accroissement entre $${a.toTex()}$ et $${a.toTex()}+h$.
-`;
+Pour $h>0$, exprimer le taux d'accroissement de $f$ entre $${a}$ et $${a}+h$ en fonction de $h$.`;
 };
-const getHint = () => {
-    return ``;
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `Le taux d'accroissement d'une fonction $f$ entre deux nombres réels $a$ et $b$ est égal à : 
+  
+$$
+\\frac{f(b)-f(a)}{b-a}
+$$
+
+Ici, on pose $b=${a}+h$. Le taux d'accroissement vaut donc : 
+
+$$
+\\frac{f(${a}+h)-f(${a})}{h}
+$$
+`;
 };
-const getCorrection = () => {
-    return ``;
+const getCorrection = (identifiers) => {
+    const { a, functionIds, type } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    const fa = fct.toDetailedEvaluation({ x: a.toTree() });
+    const faSimp = fa.simplify();
+    const fah = fct.toDetailedEvaluation({ x: add(a, "h") });
+    const fahSimp = fct.toDetailedEvaluation({ x: add(a, "h") }).simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const diff = substract(fahSimp, faSimp);
+    const diffPreSimp = diff.simplify({
+        // towardsDistribute: true,
+        forbidFactorize: true,
+        forceAddFractions: true,
+    });
+    const diffSimp = diff.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+        forceAddFractions: true,
+    });
+    const taux = type === 0 || type === 1
+        ? frac(diffSimp, "h")
+        : multiply(diffSimp, frac(1, "h"));
+    //? terrible manipulation pour faire marcher le cas dans ce cas très chiant
+    const tauxSimp = type === 3
+        ? frac(frac(diffSimp.leftChild, "h").simplify({
+            forceDistributeFractions: true,
+        }), diffSimp.rightChild)
+        : taux.simplify({
+            forceDistributeFractions: type === 0 || type === 1,
+        });
+    return `Le taux d'accroissement de $f$ entre $${a}$ et $${a}+h$ vaut :
+  
+$$
+\\frac{f(${a}+h)-f(${a})}{h}
+$$
+
+On calcule donc $f(${a})$ : 
+
+${alignTex([
+        [`f(${a})`, "=", type === 2 ? fa.toSimplificationTex() : fa.toTex()],
+        ...(type !== 2 ? [["", "=", faSimp.toTex()]] : []),
+    ])}
+
+Puis $f(${a}+h)$ : 
+
+${alignTex([
+        [`f(${a}+h)`, "=", fah.toTex()],
+        ["", "=", fahSimp.toTex()],
+    ])}
+
+Puis $f(${a}+h)-f(${a})$ :
+
+${alignTex([
+        [`f(${a}+h)-f(${a})`, "=", diff.toTex()],
+        ["", "=", diffPreSimp.toTex()],
+        ...(type !== 0 && type !== 1 ? [["", "=", diffSimp.toTex()]] : []),
+    ])}
+  
+Enfin, on divise par $h$ pour obtenir le taux d'accroissement de $f$ entre $${a}$ et $${a}+h$ : 
+
+${alignTex([
+        [`\\frac{f(${a}+h)-f(${a})}{h}`, "=", taux.toTex()],
+        ["", "=", tauxSimp.toTex()],
+    ])}
+`;
 };
 const getKeys = () => {
     return ["h"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
-        return rationalVEA(ans, answer);
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() ===
+            getAnswerNode(identifiers)
+                .simplify({
+                towardsDistribute: true,
+                forbidFactorize: true,
+            })
+                .toTex());
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
 const getAverageRateOfChangeAlgebraicExpressionQuestion = (opts) => {
-    let a = randint(-10, 10);
-    let b = randint(-10, 10, [a]);
-    if (a > b)
-        [a, b] = [b, a];
-    const types = opts?.functionType ?? ["Affine", "Polynôme du second degré"];
-    const type = random(types);
-    const fx = type === "Affine" ? AffineConstructor.random() : TrinomConstructor.random();
+    const defaultTypes = [
+        "$ax+b$",
+        "$ax^2+bx+c$",
+        "$\\frac{k}{x}$",
+        "$\\frac{k}{x^2}$",
+        "$\\frac{ax+b}{cx+d}$",
+    ];
+    const frenchType = random(opts?.functionTypes ?? defaultTypes);
+    const type = defaultTypes.indexOf(frenchType);
+    let functionIds = undefined;
+    let a = 0;
+    switch (type) {
+        case 0:
+            functionIds = AffineConstructor.random().toTree().toIdentifiers();
+            a = randint(-5, 6, [0]);
+            break;
+        case 1:
+            functionIds = TrinomConstructor.random().toTree().toIdentifiers();
+            a = randint(-5, 6, [0]);
+            break;
+        case 2:
+            a = randint(-5, 6, [0]);
+            functionIds = frac(randint(-10, 10, [0]), "x").toIdentifiers();
+            break;
+        case 3:
+            a = randint(-5, 6, [0]);
+            functionIds = frac(randint(-10, 10, [0]), square("x")).toIdentifiers();
+            break;
+        case 4:
+        default: {
+            const denum = AffineConstructor.random();
+            const num = doWhile(() => AffineConstructor.random(), (aff) => (denum.b === 0 && aff.b === 0) ||
+                round(aff.a / denum.a, 5) === round(aff.b / denum.b, 5));
+            a = randint(-5, 6, [denum.getRoot().value]);
+            functionIds = frac(num.toTree(), denum.toTree()).toIdentifiers();
+            break;
+        }
+    }
     const identifiers = {
-        aIds: a.toTree().toIdentifiers(),
-        fxIds: fx.toTree().toIdentifiers(),
+        type,
+        functionIds,
+        a,
     };
     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 options = [
     {
-        id: "functionType",
-        label: "Type de fonction",
+        id: "functionTypes",
+        label: "Types de fonction",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
-        values: ["Affine", "Polynôme du second degré"],
-        defaultValue: ["Affine", "Polynôme du second degré"],
+        values: [
+            "$ax+b$",
+            "$ax^2+bx+c$",
+            "$\\frac{k}{x}$",
+            "$\\frac{k}{x^2}$",
+            "$\\frac{ax+b}{cx+d}$",
+        ],
+        defaultValue: ["$ax+b$", "$ax^2+bx+c$", "$\\frac{k}{x}$"],
     },
 ];
 const validateOptions = (opts) => {
-    if (!opts.functionType?.length)
+    if (!opts.functionTypes?.length)
         return {
             valid: false,
             message: "Veuillez choisir au moins un type de fonction.",
@@ -94,21 +289,10 @@ const validateOptions = (opts) => {
         message: "",
     };
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    return {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-};
 export const averageRateOfChangeAlgebraicExpression = {
     id: "averageRateOfChangeAlgebraicExpression",
     connector: "=",
-    label: "Donner l'expression algébrique du taux d'accroissement d'une fonction en fonction de $h$",
+    label: "Exprimer en fonction de $h$ le taux d'accroissement d'une fonction",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getAverageRateOfChangeAlgebraicExpressionQuestion(opts), nb),
     qcmTimer: 60,

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"expressFAPlusH.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/expressFAPlusH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,eAAe,CAAC;IAC7B,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+LF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAoCF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBzD,CAAC"}

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

@@ -0,0 +1,225 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: a.toTree() })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: "h".toTree() })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    let safeA = randint(-10, 10, [0]);
+    let isSafe = false;
+    let counter = 0;
+    while (!isSafe && counter < 100) {
+        counter++;
+        if (counter > 100) {
+            throw new Error("Too many iterations in getPropositions expressFAPlusH");
+        }
+        try {
+            fct.toDetailedEvaluation({ x: safeA.toTree() }).simplify();
+            isSafe = true;
+        }
+        catch (_e) {
+            safeA = randint(-10, 10, [0]);
+        }
+    }
+    tryToAddWrongProp(propositions, fct
+        .toDetailedEvaluation({ x: add(safeA, "h") })
+        .simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    })
+        .toTex());
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    return fct
+        .toDetailedEvaluation({ x: add(a, "h") })
+        .simplify({ towardsDistribute: true, forbidFactorize: true })
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    return `On considère la fonction $f$ définie par : 
+  
+$$
+f(x) = ${fct.toTex()}
+$$
+
+Pour $h>0$, exprimer $f(${a}+h)$ en fonction de $h$.`;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `Il suffit de remplacer $x$ par $${a}+h$ dans l'expression algébrique de $f$, puis de simplifier si nécessaire.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, functionIds } = identifiers;
+    const fct = reifyAlgebraic(functionIds);
+    return `On remplace $x$ par $${a}+h$ dans l'expression algébrique de $f$ : 
+  
+${alignTex([
+        [`f(${a}+h)`, "=", fct.toDetailedEvaluation({ x: add(a, "h") }).toTex()],
+        [
+            "",
+            "=",
+            fct
+                .toDetailedEvaluation({ x: add(a, "h") })
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex(),
+        ],
+    ])}`;
+};
+const getKeys = () => {
+    return ["h"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExpressFaPlusHQuestion = (opts) => {
+    const defaultTypes = [
+        "$ax+b$",
+        "$ax^2+bx+c$",
+        "$\\frac{k}{x}$",
+        "$\\frac{k}{x^2}$",
+        "$\\frac{ax+b}{cx+d}$",
+    ];
+    const frenchType = random(opts?.functionTypes ?? defaultTypes);
+    const type = defaultTypes.indexOf(frenchType);
+    let functionIds = undefined;
+    let a = 0;
+    switch (type) {
+        case 0:
+            functionIds = AffineConstructor.random().toTree().toIdentifiers();
+            a = randint(-10, 10, [0]);
+            break;
+        case 1:
+            functionIds = TrinomConstructor.random().toTree().toIdentifiers();
+            a = randint(-10, 10, [0]);
+            break;
+        case 2:
+            a = randint(-10, 10, [0]);
+            functionIds = frac(randint(-10, 10, [0]), "x").toIdentifiers();
+            break;
+        case 3:
+            a = randint(-10, 10, [0]);
+            functionIds = frac(randint(-10, 10, [0]), square("x")).toIdentifiers();
+            break;
+        case 4:
+        default: {
+            const denum = AffineConstructor.random();
+            const num = doWhile(() => AffineConstructor.random(), (aff) => (denum.b === 0 && aff.b === 0) ||
+                round(aff.a / denum.a, 5) === round(aff.b / denum.b, 5));
+            a = randint(-10, 10, [denum.getRoot().value]);
+            functionIds = frac(num.toTree(), denum.toTree()).toIdentifiers();
+            break;
+        }
+    }
+    const identifiers = {
+        type,
+        functionIds,
+        a,
+    };
+    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 options = [
+    {
+        id: "functionTypes",
+        label: "Types de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [
+            "$ax+b$",
+            "$ax^2+bx+c$",
+            "$\\frac{k}{x}$",
+            "$\\frac{k}{x^2}$",
+            "$\\frac{ax+b}{cx+d}$",
+        ],
+        defaultValue: [
+            "$ax+b$",
+            "$ax^2+bx+c$",
+            "$\\frac{k}{x}$",
+            "$\\frac{k}{x^2}$",
+            "$\\frac{ax+b}{cx+d}$",
+        ],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts.functionTypes?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de fonction.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+export const expressFAPlusH = {
+    id: "expressFAPlusH",
+    connector: "=",
+    label: "Exprimer $f(a+h)$ en fonction de $h$ pour $f$ et $a$ donnés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpressFaPlusHQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+    validateOptions,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    type: number;
+    rateIds: NodeIdentifiers;
+    a: number;
+};
+type Options = {
+    functionTypes: string[];
+    questionType: string;
+};
+export declare const findAverageRateLimit: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findAverageRateLimit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findAverageRateLimit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/findAverageRateLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,CAAC;IACzB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+IF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAmBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB/D,CAAC"}