math-exercises 3.0.156 → 3.0.158

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

@@ -1,10 +1,43 @@
 import { shuffleProps, tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
-import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
-import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { frac, FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square, SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHint = () => {
+    return `La fonction $f$ est un quotient. Utilise donc la formule de dérivation d'un quotient : 
+  
+$$
+\\left(\\frac{u}{v}\\right)' = \\frac{u'v - uv'}{v^2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const poly1 = new Polynomial(identifiers.poly1Coeffs);
+    const poly1Tree = poly1.toTree();
+    const poly1Prime = poly1.derivate().toTree();
+    const poly2 = new Polynomial(identifiers.poly2Coeffs);
+    const poly2Tree = poly2.toTree();
+    const poly2Prime = poly2.derivate().toTree();
+    return `La fonction $f$ est un quotient de la forme $\\frac{u}{v}$, avec $u(x) = ${poly1Tree.toTex()}$ et $v(x) = ${poly2Tree.toTex()}$.
+  
+On a donc $u'(x) = ${poly1Prime.toTex()}$ et $v'(x) = ${poly2Prime.toTex()}$.
+
+On utilise donc la formule de la dérivée d'un quotient :
+
+${alignTex([
+        ["f'(x)", "=", `\\frac{u'v - uv'}{v^2}`],
+        [
+            "",
+            "=",
+            frac(substract(multiply(poly1Prime, poly2Tree), multiply(poly1Tree, poly2Prime)), square(poly2Tree)).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const poly1 = new Polynomial(identifiers.poly1Coeffs);
     const poly2 = new Polynomial(identifiers.poly2Coeffs);
@@ -14,7 +47,7 @@ $$
 f(x) = ${new FractionNode(poly1.toTree(), poly2.toTree()).toTex()}
 $$`;
 };
-const getAnwer = (identifiers) => {
+const getAnswer = (identifiers) => {
     const poly1 = new Polynomial(identifiers.poly1Coeffs);
     const poly2 = new Polynomial(identifiers.poly2Coeffs);
     const answerNum = poly1
@@ -49,11 +82,13 @@ const getProductDerivativeQuestion = () => {
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: getAnwer(identifiers),
+        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: ["x", "xsquare", "xcube"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -103,4 +138,5 @@ export const quotientDerivative = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA0FF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"sqrtCompositionDerivation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAuHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}

package/lib/exercises/math/derivation/derivative/sqrt/sqrtCompositionDerivation.js

@@ -2,11 +2,35 @@ import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../..
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
-import { SqrtNode } from "../../../../../tree/nodes/functions/sqrtNode.js";
-import { FractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { sqrt, SqrtNode } from "../../../../../tree/nodes/functions/sqrtNode.js";
+import { frac, FractionNode } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getHint = () => {
+    return `Utilise la formule de dérivation suivante : 
+  
+$$
+\\left(\\sqrt{u}\\right)' = \\frac{u'}{2 \\times \\sqrt{u}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { affineA, affineB } = identifiers;
+    const affine = new Affine(affineA, affineB);
+    return `On utilise la formule de dérivation suivante : 
+  
+$$
+\\left(\\sqrt{u}\\right)' = \\frac{u'}{2 \\times \\sqrt{u}}
+$$
+
+Ici, $u(x) = ${affine.toTree().toTex()}$, donc $u'(x) = ${affineA}$.
+
+Ainsi, 
+
+$$
+f'(x) = ${frac(affineA, multiply(2, sqrt(affine.toTree()))).toSimplificationTex()}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { affineA, affineB } = identifiers;
     const affine = new Affine(affineA, affineB);
@@ -36,6 +60,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -78,4 +104,5 @@ export const sqrtCompositionDerivation = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

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

@@ -0,0 +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"}

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"}