math-exercises 3.0.157 → 3.0.158

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

@@ -0,0 +1,127 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, } 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        throw Error("QCM not implemented");
+    });
+    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({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    return frac(substract(fah, fa), "h").simplify().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 : 
+  
+$$
+f(x) = ${fx.toTex()}
+$$
+
+Pour un nombre réel $h>0$, donner l'expression algébrique du taux d'accroissement entre $${a.toTex()}$ et $${a.toTex()}+h$.
+`;
+};
+const getHint = () => {
+    return ``;
+};
+const getCorrection = () => {
+    return ``;
+};
+const getKeys = () => {
+    return ["h"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    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 identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        fxIds: fx.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const options = [
+    {
+        id: "functionType",
+        label: "Type de fonction",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Affine", "Polynôme du second degré"],
+        defaultValue: ["Affine", "Polynôme du second degré"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts.functionType?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de fonction.",
+        };
+    return {
+        valid: true,
+        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$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageRateOfChangeAlgebraicExpressionQuestion(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/averageRateOfChangeFromAlgebraic.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageRateOfChangeFromAlgebraic.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/averageRateOfChangeFromAlgebraic.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA+HF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAsBF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBzE,CAAC"}

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

@@ -0,0 +1,161 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds, fxIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fx = reifyAlgebraic(fxIds);
+    const fa = fx.toDetailedEvaluation({ x: a });
+    const fb = fx.toDetailedEvaluation({ x: b });
+    return frac(substract(fb, fa), substract(b, a)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, fxIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fx = reifyAlgebraic(fxIds);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = ${fx.toTex()}
+$$
+
+Calculer le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$.`;
+};
+const getHint = () => {
+    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}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, fxIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fx = reifyAlgebraic(fxIds);
+    const fa = fx.toDetailedEvaluation({ x: a });
+    const faSimp = fa.simplify();
+    const fb = fx.toDetailedEvaluation({ x: b });
+    const fbSimp = fb.simplify();
+    return `On commence par calculer les images de $${a.toTex()}$ et $${b.toTex()}$.
+  
+${alignTex([
+        [`f(${a.toTex()})`, "=", fa.toTex()],
+        ["", "=", faSimp.toTex()],
+    ])}
+
+${alignTex([
+        [`f(${b.toTex()})`, "=", fb.toTex()],
+        ["", "=", fbSimp.toTex()],
+    ])}
+
+Le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$ vaut donc :
+
+${alignTex([
+        ["", `\\frac{f(${b.toTex()})-f(${a.toTex()})}{${substract(b, a).toTex()}}`],
+        ["=", frac(substract(fbSimp, faSimp), substract(b, a).simplify()).toTex()],
+        [
+            "=",
+            frac(substract(fbSimp, faSimp).simplify(), substract(b, a).simplify()).toSimplificationTex(),
+        ],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageRateOfChangeFromAlgebraicQuestion = (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 identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        fxIds: fx.toTree().toIdentifiers(),
+    };
+    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",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Affine", "Polynôme du second degré"],
+        defaultValue: ["Affine", "Polynôme du second degré"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts.functionType?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de fonction.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
+export const averageRateOfChangeFromAlgebraic = {
+    id: "averageRateOfChangeFromAlgebraic",
+    connector: "=",
+    label: "Calculer le taux d'accroissement d'une fonction $f$ entre deux nombres réels $a$ et $b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageRateOfChangeFromAlgebraicQuestion(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/averageRateOfChangeFromImages.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+    faIds: NodeIdentifiers;
+    fbIds: NodeIdentifiers;
+};
+export declare const averageRateOfChangeFromImages: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=averageRateOfChangeFromImages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageRateOfChangeFromImages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/averageRateOfChangeFromImages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AA0GF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAsB/D,CAAC"}

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

@@ -0,0 +1,116 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return frac(substract(fb, fa), substract(b, a)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return `On considère une fonction $f$ définie sur $\\mathbb{R}$, telle que $f(${a.toTex()}) = ${fa.toTex()}$ et $f(${b.toTex()}) = ${fb.toTex()}$. 
+  
+Calculer le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$.
+`;
+};
+const getHint = () => {
+    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}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, bIds, faIds, fbIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const b = reifyAlgebraic(bIds);
+    const fa = reifyAlgebraic(faIds);
+    const fb = reifyAlgebraic(fbIds);
+    return `Le taux d'accroissement de $f$ entre $${a.toTex()}$ et $${b.toTex()}$ vaut : 
+  
+${alignTex([
+        ["", `\\frac{f(${b.toTex()})-f(${a.toTex()})}{${substract(b, a).toTex()}}`],
+        ["=", frac(substract(fb, fa), substract(b, a).simplify()).toTex()],
+        [
+            "=",
+            frac(substract(fb, fa).simplify(), substract(b, a).simplify()).toSimplificationTex(),
+        ],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageRateOfChangeFromImagesQuestion = () => {
+    let a = randint(-10, 10);
+    let b = randint(-10, 10, [a]);
+    if (a > b)
+        [a, b] = [b, a];
+    const fa = randint(-10, 10);
+    const fb = randint(-10, 10);
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        bIds: b.toTree().toIdentifiers(),
+        faIds: fa.toTree().toIdentifiers(),
+        fbIds: fb.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const averageRateOfChangeFromImages = {
+    id: "averageRateOfChangeFromImages",
+    connector: "=",
+    label: "Calculer le taux d'accroissement d'une fonction entre $a$ et $b$, avec $f(a)$ et $f(b)$ données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageRateOfChangeFromImagesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    coeffs: number[];
+    x: number;
+};
+export declare const derivativeNumberCalcul: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=derivativeNumberCalcul.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivativeNumberCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/derivativeNumberCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -0,0 +1,142 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = (identifiers) => {
+    const { x } = identifiers;
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+Calcule donc d'abord $f(${x})$, et $f(${x}+h)$ en fonction de $h$.
+
+Puis, détermine la limite de ce nombre lorsque $h$ se rapproche de $0$. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs, x } = identifiers;
+    const trinom = new Polynomial(coeffs).toTree();
+    const fx = trinom.toDetailedEvaluation({ x: x.toTree() });
+    const fxSimp = fx.simplify();
+    const fxh = trinom.toDetailedEvaluation({ x: add(x, "h") });
+    const fxhSimp = fxh.simplify({
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const answer = getAnswer(identifiers);
+    return `Pour calculer $f'(${x})$, il faut d'abord calculer le taux d'accroissement de $f$ entre $${x}$ et $${x}+h$, pour $h>0$. Ce taux est égal à :
+
+$$
+\\frac{f(${x}+h)-f(${x})}{h}
+$$
+
+On calcule donc $f(${x})$ :
+
+${alignTex([
+        [`f(${x})`, "=", fx.toTex()],
+        ["", "=", fxSimp.toTex()],
+    ])}
+
+Puis $f(${x}+h)$ :
+
+${alignTex([
+        [`f(${x}+h)`, "=", fxh.toTex()],
+        ["", "=", fxhSimp.toTex()],
+    ])}
+
+Le taux d'accroissement vaut donc : 
+
+${alignTex([
+        [
+            frac(substract(`f(${x}+h)`, `f(${x})`), `h`).toTex(),
+            "=",
+            frac(substract(fxhSimp, fxSimp).simplify({ forbidFactorize: true }), "h").toTex(),
+        ],
+        [
+            "",
+            "=",
+            frac(substract(fxhSimp, fxSimp), "h")
+                .simplify({ forbidFactorize: true, forceDistributeFractions: true })
+                .toTex(),
+        ],
+    ])}
+
+Lorsque $h$ tend vers $0$, ce nombre se rapproche donc de $${answer}$. 
+La limite du taux d'accroissement en $0$ est donc $${answer}$. 
+
+Le nombre dérivé $f'(${x})$ vaut donc $${answer}$.
+`;
+};
+const getInstruction = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const instruction = `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+En revenant à la définition du nombre dérivé, calculer $f'(${identifiers.x})$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const trinom = new Polynomial(identifiers.coeffs);
+    const answer = trinom.derivate().calculate(identifiers.x) + "";
+    return answer;
+};
+const getDerivativeNumberCalculQuestion = () => {
+    const x = randint(-9, 10);
+    const trinom = PolynomialConstructor.randomWithOrder(2);
+    const identifiers = { x, coeffs: trinom.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(-20, 20) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const derivativeNumberCalcul = {
+    id: "derivativeNumberCalcul",
+    connector: "=",
+    label: "Calculer un nombre dérivé via la définition",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getDerivativeNumberCalculQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/derivativeNumber/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,oCAAoC,CAAC;AACnD,cAAc,uCAAuC,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./derivativeNumberCalcul.js";
+export * from "./averageRateOfChangeFromImages.js";
+export * from "./averageRateOfChangeFromAlgebraic.js";
+// export * from "./averageRateOfChangeAlgebraicExpression.js";

package/lib/exercises/math/derivation/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

package/lib/exercises/math/derivation/index.js

@@ -1,5 +1,5 @@
 export * from "./derivative/index.js";
-export * from "./derivativeNumberCalcul.js";
+export * from "./derivativeNumber/index.js";
 export * from "./tangent/index.js";
 export * from "./variations/index.js";
 export * from "./convexity/index.js";

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+    nodeIdsAOpB: NodeIdentifiers;
+    expARounded: number;
+    expBRounded: number;
+    precision: number;
+};
+export declare const approxExpAPlusB: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=approxExpAPlusB.d.ts.map

package/lib/exercises/math/functions/exponential/algebraic/approxExpAPlusB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approxExpAPlusB.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/exponential/algebraic/approxExpAPlusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4UF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}