math-exercises 3.0.56 → 3.0.58

package/lib/exercises/math/conversion/volumeConversion.js

@@ -1,7 +1,10 @@
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -9,19 +12,76 @@ const getVolumeConversion = () => {
     const randomUnitIndex = randint(0, 7);
     const randomUnitInstructionIndex = randint(Math.max(0, randomUnitIndex - 2), Math.min(7, randomUnitIndex + 3), [randomUnitIndex]);
     const randomVolume = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
-    const answer = (randomVolume.multiplyByPowerOfTen(3 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
+    const identifiers = {
+        randomUnitIndex,
+        randomUnitInstructionIndex,
+        randomVolume: randomVolume.value,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getInstruction = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex, randomVolume } = identifiers;
+    return `Compléter : 
+  
+$$
+${randomVolume.frenchify()} \\textrm{${units[randomUnitIndex]}}^3 = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}^3
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex, randomVolume } = identifiers;
+    const answer = new Decimal(randomVolume)
+        .multiplyByPowerOfTen(3 * (randomUnitIndex - randomUnitInstructionIndex))
+        .value.frenchify();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    return `On rappelle que :
+  
+$$
+1 \\ \\textrm{${unit}}^3 = ${space > 0
+        ? Math.pow(10, space * 3)
+        : frac(1, Math.pow(10, -(space * 3))).toTex()} \\ \\textrm{${target}}^3
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomVolume, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0
+        ? Math.pow(10, space * 3).toTree()
+        : frac(1, Math.pow(10, -(space * 3)));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}}^3 = ${coeff.toTex()} \\ \\textrm{${target}}^3
+$$
+
+Il suffit alors de multiplier $${randomVolume.frenchify()}$ par $${coeff.toTex()}$ :
+
+${alignTex([
+        [
+            `${randomVolume.frenchify()} \\textrm{${unit}}^3 `,
+            "=",
+            `${multiply(coeff, randomVolume).toTex()}\\ \\textrm{${target}}^3`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}^3`],
+    ])}
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Compléter : $${randomVolume.value
-            .toString()
-            .replace(".", ",")} \\textrm{${units[randomUnitIndex]}}^3 = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}^3$`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            randomUnitIndex,
-            randomUnitInstructionIndex,
-            randomVolume: randomVolume.value,
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -45,8 +105,6 @@ export const volumeConversion = {
     id: "volumeConversion",
     connector: "=",
     label: "Conversion de volumes",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getVolumeConversion, nb),
     getPropositions,
@@ -54,4 +112,6 @@ export const volumeConversion = {
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convexityQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/convexityQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/derivation/convexity/convexityQuadrinomials.js

@@ -0,0 +1,102 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const questionType = askConvex ? "convexe" : "concave";
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${quadrinomial.toTex()}
+$$
+
+Sur quelle intervalle $f$ est-elle ${questionType} ?`;
+};
+const getAnswer = (identifiers) => {
+    const { askConvex, quadcoeffs } = identifiers;
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
+    let interval;
+    if (askConvex) {
+        interval =
+            quadcoeffs[3] > 0
+                ? new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    }
+    else {
+        interval =
+            quadcoeffs[3] <= 0
+                ? new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex()
+                : new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    }
+    return interval;
+};
+const getConvexityQuadrinomialsQuestion = () => {
+    const quadrinomial = PolynomialConstructor.randomWithOrder(3);
+    const quadcoeffs = quadrinomial.coefficients;
+    const askConvex = coinFlip();
+    const identifiers = { askConvex, quadcoeffs };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["rbracket", "lbracket", "semicolon", "infty", "reals"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, quadcoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
+    const wrongInterval1 = new IntervalNode(inflexionPoint, PlusInfinityNode, ClosureType.OO).toTex();
+    const wrongInterval2 = new IntervalNode(MinusInfinityNode, inflexionPoint, ClosureType.OO).toTex();
+    const wrongInterval3 = new IntervalNode(MinusInfinityNode, PlusInfinityNode, ClosureType.OO).toTex();
+    const wrongInterval4 = new IntervalNode(new NumberNode(randint(-1, 2)), PlusInfinityNode, ClosureType.FO).toTex();
+    tryToAddWrongProp(propositions, wrongInterval1);
+    tryToAddWrongProp(propositions, wrongInterval2);
+    tryToAddWrongProp(propositions, wrongInterval3);
+    tryToAddWrongProp(propositions, wrongInterval4);
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, askConvex, quadcoeffs }) => {
+    try {
+        const parsed = intervalParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const convexityQuadrinomials = {
+    id: "convexityQuadrinomials",
+    label: "Convexité des fonctions polynomiales de degré $3$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConvexityQuadrinomialsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "QCU",
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/convexity/convexityTrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/convexityTrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convexityTrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/convexityTrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0CF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/derivation/convexity/convexityTrinomials.js

@@ -0,0 +1,52 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+const getInstruction = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${trinom.toTex()}
+$$
+
+Sur $\\mathbb{R}$, $f$ est :`;
+};
+const getAnswer = (identifiers) => {
+    const trinom = TrinomConstructor.fromCoeffs(identifiers.coeffs);
+    const isConvex = trinom.a > 0 ? "Convexe" : "Concave";
+    return isConvex;
+};
+const getConvexityTrinomialsQuestion = () => {
+    const trinom = TrinomConstructor.random();
+    const identifiers = { coeffs: trinom.coefficients };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Concave", "raw");
+    tryToAddWrongProp(propositions, "Convexe", "raw");
+    tryToAddWrongProp(propositions, "Ni concave, ni convexe", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+export const convexityTrinomials = {
+    id: "convexityTrinomials",
+    label: "Déterminer la convexité d'un trinôme",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getConvexityTrinomialsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "QCU",
+    getPropositions,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

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

@@ -0,0 +1,4 @@
+export * from "./convexityTrinomials.js";
+export * from "./convexityQuadrinomials.js";
+export * from "./inflexionPointQuadrinomials.js";
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+export * from "./convexityTrinomials.js";
+export * from "./convexityQuadrinomials.js";
+export * from "./inflexionPointQuadrinomials.js";

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.d.ts

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

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflexionPointQuadrinomials.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/convexity/inflexionPointQuadrinomials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAsJF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAkB7D,CAAC"}

package/lib/exercises/math/derivation/convexity/inflexionPointQuadrinomials.js

@@ -0,0 +1,134 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { Trinom } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { equationResolutionTex } from "../../../../tree/nodes/equations/equalNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    return `Soit la fonction $f$ définie par : 
+  
+$$
+f(x) = ${quadrinomial.toTex()}
+$$
+
+Calculer l'abscisse de son point d'inflexion.`;
+};
+const getAnswer = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    return new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree())
+        .simplify()
+        .toTex();
+};
+const getInflexionPointQuadrinomialsQuestion = () => {
+    let quadrinomial;
+    let quadcoeffs;
+    do {
+        quadrinomial = PolynomialConstructor.randomWithOrder(3);
+        quadcoeffs = quadrinomial.coefficients;
+    } while (quadcoeffs[1] === 0 || quadcoeffs[2] === 0);
+    const identifiers = { quadcoeffs };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, quadcoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const firstdderivative = quadrinomial.derivate();
+    const trinomialcoeffs = firstdderivative.coefficients;
+    const trinomial = new Trinom(trinomialcoeffs[2], trinomialcoeffs[1], trinomialcoeffs[0]);
+    const firstroots = trinomial.getRootsNode();
+    const secondderivative = quadrinomial.derivate().derivate();
+    const seconddcoeffs = secondderivative.coefficients;
+    const wrongAnswer1 = new FractionNode(seconddcoeffs[0].toTree(), seconddcoeffs[1].toTree())
+        .simplify()
+        .toTex();
+    const wrongAnswer2 = new FractionNode(seconddcoeffs[1].toTree(), seconddcoeffs[0].toTree())
+        .simplify()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongAnswer1);
+    tryToAddWrongProp(propositions, wrongAnswer2);
+    if (firstroots.length != 0) {
+        for (let i = 0; i < firstroots.length; i++) {
+            tryToAddWrongProp(propositions, firstroots[i].simplify().toTex());
+        }
+    }
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(-10, 10).toString());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, quadcoeffs }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getHint = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    return `Pour trouver l'abscisse du point d'inflexion, on doit résoudre l'équation $f''(x) = 0$.`;
+};
+const getCorrection = ({ quadcoeffs }) => {
+    const quadrinomial = new Polynomial(quadcoeffs);
+    const firstDerivative = quadrinomial.derivate();
+    const secondDerivative = firstDerivative.derivate();
+    const seconddcoeffs = secondDerivative.coefficients;
+    const inflexionPoint = new FractionNode(new MultiplyNode(seconddcoeffs[0].toTree(), new NumberNode(-1)), seconddcoeffs[1].toTree()).simplify();
+    return `Le point d'inflexion est l'abscisse où la dérivée seconde s'annule.
+
+- La dérivée première est :
+
+$$
+f'(x) = ${firstDerivative.toTex()}
+$$
+
+- La dérivée seconde est :
+
+$$
+f''(x) = ${secondDerivative.toTex()}
+$$
+
+- Résolvons $f''(x) = 0$ :
+   
+$$
+${equationResolutionTex(seconddcoeffs[1].toTree(), seconddcoeffs[0].toTree(), (0).toTree(), (0).toTree())}
+$$
+
+L'abscisse du point d'inflexion est donc $${inflexionPoint.toTex()}$.`;
+};
+export const inflexionPointQuadrinomials = {
+    id: "inflexionPointQuadrinomials",
+    label: "Calcul du point d'inflexion",
+    levels: ["TermSpé"],
+    isSingleStep: true,
+    sections: ["Dérivation"],
+    generator: (nb) => getDistinctQuestions(getInflexionPointQuadrinomialsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.d.ts

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

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expDerivativeFour.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeFour.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAgFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeFour.js

@@ -0,0 +1,79 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../../math/polynomials/affine.js";
+import { ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    const exp = new ExpNode(affine2.toTree());
+    const fct = new MultiplyNode(affine1.toTree(), exp);
+    return `Déterminer la dérivée de la fonction $f$ définie par :
+  
+$$
+f(x) = ${fct.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { affine1Coeffs, affine2Coeffs } = identifiers;
+    const affine1 = new Affine(affine1Coeffs[1], affine1Coeffs[0]);
+    const affine2 = new Affine(affine2Coeffs[1], affine2Coeffs[0]);
+    const exp = new ExpNode(affine2.toTree());
+    const deriv = new MultiplyNode(new Affine(affine2.a * affine1.a, affine1.a + affine2.a * affine1.b).toTree(), exp);
+    return deriv.simplify().toTex();
+};
+const getExpDerivativeFourQuestion = () => {
+    const affine1 = AffineConstructor.random();
+    const affine2 = AffineConstructor.random();
+    const identifiers = {
+        affine1Coeffs: affine1.coefficients,
+        affine2Coeffs: affine2.coefficients,
+    };
+    //ae^cx+d  + c(ax+b)e^cx+d = (a+c(ax+b))e^cx+d = (cax + a +cb) e^cx+d
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["x", "epower", "exp"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, new MultiplyNode(AffineConstructor.random().toTree(), new ExpNode(AffineConstructor.random().toTree())).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, affine1Coeffs, affine2Coeffs }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const expDerivativeFour = {
+    id: "expDerivativeFour",
+    connector: "=",
+    label: "Dérivée de $(ax+b)e^{cx+d}$",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Dérivation", "Exponentielle"],
+    generator: (nb) => getDistinctQuestions(getExpDerivativeFourQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+};

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.d.ts

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

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expDerivativeOne.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}

package/lib/exercises/math/derivation/derivative/exp/expDerivativeOne.js

@@ -0,0 +1,85 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine } from "../../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { ExpNode } from "../../../../../tree/nodes/functions/expNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Polynomial([b, a]);
+    const myfunction = new ExpNode(affine.toTree());
+    return `Déterminer la dérivée de la fonction $f$ définie par :
+  
+$$
+f(x) = ${myfunction.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Polynomial([b, a]);
+    const myfunction = new ExpNode(affine.toTree());
+    const derivative = new MultiplyNode(new NumberNode(a), myfunction);
+    const answer = derivative.toTex();
+    return answer;
+};
+const getExpDerivative = () => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10);
+    const identifiers = { a, b };
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: "f'(x)",
+        answer: getAnswer(identifiers),
+        keys: ["x", "epower", "exp"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affine = new Affine(a, b);
+    const myfunction = new ExpNode(affine.toTree());
+    tryToAddWrongProp(propositions, myfunction.toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affine.toTree(), myfunction).toTex());
+    tryToAddWrongProp(propositions, new ExpNode(new NumberNode(a)).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(b), myfunction).toTex());
+    while (propositions.length < n)
+        tryToAddWrongProp(propositions, new MultiplyNode(new NumberNode(randint(-9, 10)), myfunction).toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const expDerivativeOne = {
+    id: "expDerivativeOne",
+    connector: "=",
+    label: "Dérivée de $\\exp(ax + b)$",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getExpDerivative, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+};

package/lib/exercises/math/derivation/derivative/exp/expDerivativeThree.d.ts

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

package/lib/exercises/math/derivation/derivative/exp/expDerivativeThree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expDerivativeThree.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/derivation/derivative/exp/expDerivativeThree.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}