math-exercises 3.0.201 → 3.0.203

package/lib/exercises/math/limits/sequences/sequenceGeometricLimit.js

@@ -0,0 +1,110 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeometricSequence, GeometricSequenceConstructor, } from "../../../../math/sequences/geometricSequence.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+const getInstruction = (identifiers) => {
+    const { reason, firstTerm } = identifiers;
+    const sequence = new GeometricSequence(reifyAlgebraic(firstTerm), reifyAlgebraic(reason));
+    return `Déterminer la limite de la suite $u$ définie par : 
+  
+$$
+u_n = ${sequence.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { reason, firstTerm } = identifiers;
+    const sequence = new GeometricSequence(reifyAlgebraic(firstTerm), reifyAlgebraic(reason));
+    const answer = sequence.getLimit();
+    return answer.toTex();
+};
+const getHint = () => {
+    return `Soit $u$ la suite géométrique définie par : 
+  
+$$
+u_n = q^n
+$$
+
+Alors : 
+
+- si $q>1$, la limite de $u_n$ est $+\\infty$ ;
+- si $-1<q<1$, la limite de $u_n$ est $0$.
+- si $q<-1$, $u_n$ n'admet pas de limite.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { reason } = identifiers;
+    const reasonNode = reifyAlgebraic(reason);
+    const reasonEv = reasonNode.evaluate({});
+    const reasonTex = reasonEv > 1
+        ? `Puisque $${reasonNode.toTex()}>1$, on a : 
+  
+$$
+\\lim_{n \\to +\\infty} ${power(reasonNode, "n").toTex()} = +\\infty
+$$
+
+ `
+        : `Puisque $-1<${reasonNode.toTex()}<1$, on a : 
+  
+$$
+\\lim_{n \\to +\\infty} ${power(reasonNode, "n").toTex()} = 0
+$$`;
+    return (reasonTex +
+        `
+  
+On en déduit donc : 
+
+$$
+\\lim_{n \\to +\\infty} u_n = ${getAnswer(identifiers)}
+$$`);
+};
+const getSequenceGeometricLimitQuestion = () => {
+    const sequence = GeometricSequenceConstructor.randomWithLimit();
+    const identifiers = {
+        reason: sequence.reason.toIdentifiers(),
+        firstTerm: sequence.firstTerm.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, reason, firstTerm }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, reifyAlgebraic(reason).toTex());
+    tryToAddWrongProp(propositions, reifyAlgebraic(firstTerm).toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const sequenceGeometricLimit = {
+    id: "sequenceGeometricLimit",
+    connector: "=",
+    label: "Limite d'une suite géométrique",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSequenceGeometricLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/sequences/sequencePolynomLimit.d.ts

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

package/lib/exercises/math/limits/sequences/sequencePolynomLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePolynomLimit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/sequences/sequencePolynomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA2GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/limits/sequences/sequencePolynomLimit.js

@@ -0,0 +1,116 @@
+import { addValidProp, propWhile, 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 { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const poly = new Polynomial(identifiers.coeffs, "n");
+    return `Déterminer la limite de la suite $u$ définie par : 
+  
+$$
+u_n = ${poly.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const to = "+\\infty";
+    const poly = new Polynomial(identifiers.coeffs, "n");
+    const answer = poly.getLimit(to);
+    return answer;
+};
+const getHint = () => {
+    return `Attention ! Ici, on est en présence d'une forme indéterminée du type "$\\infty - \\infty"$. 
+  
+On ne peut pas immédiatemment déterminer la limite de $u_n$.
+
+Pour s'en sortir, il faut d'abord factoriser $u_n$ par son terme de plus haut degré.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const order = coeffs.length - 1;
+    const highCoeff = coeffs[order];
+    const high = power("n", order);
+    const factoNodes = [...coeffs].reverse().map((e, i) => {
+        //coeff / n^(order-i)
+        return frac(e, power("n", i)).simplify();
+    });
+    const facto = operatorComposition(AddNode, factoNodes);
+    return `Ici, on est en présence d'une forme indéterminée du type "$\\infty - \\infty"$. 
+
+Pour déterminer la limite de $u_n$, on factorise par son terme de plus haut degré :
+
+$$
+u_n = ${multiply(high, facto).toTex()}
+$$
+
+On a alors : 
+
+
+- $\\displaystyle \\lim_{n \\to +\\infty} ${high.toTex()} = +\\infty$
+
+- $\\displaystyle  \\lim_{n \\to +\\infty} ${facto.toTex()} = ${highCoeff}$
+
+Par produit des limites, on obtient donc : 
+
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getSequencePolynomLimitQuestion = () => {
+    const order = randint(2, 5);
+    const poly = PolynomialConstructor.randomWithOrder(order, "n");
+    const coeffs = [...poly.coefficients];
+    const signs = coeffs.slice(1).map((e) => (e > 0 ? "+" : "-"));
+    if (signs.every((s) => s === signs[0])) {
+        const index = randint(1, order);
+        coeffs[index] *= -1;
+    }
+    const identifiers = { coeffs: coeffs };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, coeffs[coeffs.length - 1] + "");
+    propWhile(propositions, n, () => {
+        const wrongAnswer = randint(-10, 10) + "";
+        tryToAddWrongProp(propositions, wrongAnswer);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const sequencePolynomLimit = {
+    id: "sequencePolynomLimit",
+    connector: "=",
+    label: "Limite d'une suite polynomiale (avec F.I.)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSequencePolynomLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/sequences/sequencePolynomNoFILimit.d.ts

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

package/lib/exercises/math/limits/sequences/sequencePolynomNoFILimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePolynomNoFILimit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/sequences/sequencePolynomNoFILimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA4FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

package/lib/exercises/math/limits/sequences/sequencePolynomNoFILimit.js

@@ -0,0 +1,95 @@
+import { addValidProp, propWhile, 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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const poly = new Polynomial(identifiers.coeffs, "n");
+    return `Déterminer la limite de la suite $u$ définie par :
+  
+$$
+u_n = ${poly.toTree().toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const to = "+\\infty";
+    const poly = new Polynomial(identifiers.coeffs, "n");
+    const answer = poly.getLimit(to);
+    return answer;
+};
+const getHint = () => {
+    return `Détermine la limite quand $n$ tend vers $+\\infty$ de chaque terme de la somme composant $u_n$. 
+  
+Puis, déduis-en la limite de $u_n$ en "additionnant" les limites obtenues.`;
+};
+const getCorrection = (identifiers) => {
+    const texs = identifiers.coeffs
+        .map((coeff, i) => {
+        if (coeff === 0)
+            return "";
+        if (i === 0)
+            return `$\\displaystyle \\lim_{n \\to +\\infty} ${coeff} = ${coeff}$`;
+        const monom = multiply(coeff, power("n", i)).simplify().toTex();
+        const sign = coeff > 0 ? "+" : "-";
+        return `$\\displaystyle \\lim_{n \\to +\\infty} ${monom} = ${sign}\\infty$`;
+    })
+        .filter(Boolean);
+    return `On détermine la limite de chaque terme de la somme composant $u_n$ : 
+  
+${texs.reverse().join("\n \n")}
+
+Par addition des limites, on obtient donc : 
+
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getSequencePolynomNoFILimitQuestion = () => {
+    const length = randint(2, 5);
+    const poly = PolynomialConstructor.randomWithLengthAndSameSigns(4, length, "n");
+    const identifiers = { coeffs: poly.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, coeffs[coeffs.length - 1] + "");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const sequencePolynomNoFILimit = {
+    id: "sequencePolynomNoFILimit",
+    connector: "=",
+    label: "Limite d'une suite polynomiale (sans F.I.)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSequencePolynomNoFILimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/sequences/sequencePolynomProductLimit.d.ts

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

package/lib/exercises/math/limits/sequences/sequencePolynomProductLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePolynomProductLimit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/sequences/sequencePolynomProductLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAwHF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}

package/lib/exercises/math/limits/sequences/sequencePolynomProductLimit.js

@@ -0,0 +1,111 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Monom } from "../../../../math/polynomials/monom.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { polyNumCoeffs, polyDenumCoeffs } = identifiers;
+    const polyNum = new Polynomial(polyNumCoeffs, "n");
+    const polyDenum = new Polynomial(polyDenumCoeffs, "n");
+    return `Déterminer la limite de la suite $u$ définie par : 
+
+$$
+u_n = (${polyNum.toTree().toTex()})(${polyDenum.toTree().toTex()})
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { polyNumCoeffs, polyDenumCoeffs } = identifiers;
+    const polyNum = new Polynomial(polyNumCoeffs, "n");
+    const polyDenum = new Polynomial(polyDenumCoeffs, "n");
+    const numLeadingCoeff = polyNum.coefficients[polyNum.degree];
+    const denumLeadingCoeff = polyDenum.coefficients[polyDenum.degree];
+    const product = new Monom(polyNum.degree + polyDenum.degree, numLeadingCoeff * denumLeadingCoeff, "n");
+    const to = "+\\infty";
+    const answer = product.getLimit(to);
+    return answer;
+};
+const getHint = () => {
+    return `Détermine la limite quand $n$ tend vers $+\\infty$ de chaque facteur du produit composant $u_n$. 
+  
+Puis, déduis-en la limite de $u_n$ en "multipliant" les limites obtenues.`;
+};
+const getCorrection = (identifiers) => {
+    const { polyNumCoeffs, polyDenumCoeffs } = identifiers;
+    const polyNum = new Polynomial(polyNumCoeffs, "n");
+    const polyDenum = new Polynomial(polyDenumCoeffs, "n");
+    const numLim = polyNum.getLimit("+\\infty");
+    const denumLim = polyDenum.getLimit("+\\infty");
+    return `On détermine la limite de chaque facteur du produit composant $u_n$ : 
+  
+- $\\displaystyle \\lim_{n \\to +\\infty} ${polyNum
+        .toTree()
+        .toTex()} = ${numLim}$
+
+- $\\displaystyle \\lim_{n \\to +\\infty} ${polyDenum
+        .toTree()
+        .toTex()} = ${denumLim}$
+
+Par produit des limites, on obtient donc : 
+
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getSequencePolynomProductLimitQuestion = () => {
+    const polyNum = PolynomialConstructor.randomWithLengthAndSameSigns(3, 2, "n");
+    const polyDenum = PolynomialConstructor.randomWithLengthAndSameSigns(3, 2, "n");
+    const identifiers = {
+        polyDenumCoeffs: polyDenum.coefficients,
+        polyNumCoeffs: polyNum.coefficients,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, polyDenumCoeffs, polyNumCoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const numLeadingCoeff = polyNumCoeffs[polyNumCoeffs.length - 1];
+    const denumLeadingCoeff = polyDenumCoeffs[polyDenumCoeffs.length - 1];
+    const leadingCoeffsRational = new Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, leadingCoeffsRational);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const sequencePolynomProductLimit = {
+    id: "sequencePolynomProductLimit",
+    connector: "=",
+    label: "Limite d'un produit de suites polynomiales (sans F.I.)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSequencePolynomProductLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/limits/sequences/sequenceRationalFracLimit.d.ts

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

package/lib/exercises/math/limits/sequences/sequenceRationalFracLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceRationalFracLimit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/limits/sequences/sequenceRationalFracLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAgIF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/limits/sequences/sequenceRationalFracLimit.js

@@ -0,0 +1,114 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Monom } from "../../../../math/polynomials/monom.js";
+import { Polynomial, PolynomialConstructor, } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { numCoeffs, denumCoeffs } = identifiers;
+    const polyNum = new Polynomial(numCoeffs, "n");
+    const polyDenum = new Polynomial(denumCoeffs, "n");
+    return `Déterminer la limite de la suite $u$ définie par : 
+  
+$$
+u_n = \\dfrac{${polyNum.toTree().toTex()}}{${polyDenum.toTree().toTex()}}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { numCoeffs, denumCoeffs } = identifiers;
+    const polyNum = new Polynomial(numCoeffs, "n");
+    const polyDenum = new Polynomial(denumCoeffs, "n");
+    let answer = "";
+    const to = "+\\infty";
+    const numLeadingCoeff = polyNum.coefficients[polyNum.degree];
+    const denumLeadingCoeff = polyDenum.coefficients[polyDenum.degree];
+    const leadingCoeffsRational = new Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree()
+        .toTex();
+    if (polyDenum.degree === polyNum.degree) {
+        answer = leadingCoeffsRational;
+    }
+    else if (polyDenum.degree > polyNum.degree) {
+        answer = "0";
+    }
+    else {
+        const tempPoly = new Monom(polyNum.degree - polyDenum.degree, numLeadingCoeff * denumLeadingCoeff > 0 ? 1 : -1, "n");
+        answer = tempPoly.getLimit(to);
+    }
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getSequenceRationalFracLimitQuestion = () => {
+    const polyNum = PolynomialConstructor.randomWithLengthAndSameSigns(3, randint(2, 4), "n");
+    const polyDenum = PolynomialConstructor.randomWithLengthAndSameSigns(3, randint(2, 4), "n");
+    const identifiers = {
+        numCoeffs: polyNum.coefficients,
+        denumCoeffs: polyDenum.coefficients,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, numCoeffs, denumCoeffs }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const numLeadingCoeff = numCoeffs[numCoeffs.length - 1];
+    const denumLeadingCoeff = denumCoeffs[denumCoeffs.length - 1];
+    const leadingCoeffsRational = new Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, "+\\infty");
+    tryToAddWrongProp(propositions, "-\\infty");
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, leadingCoeffsRational);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-10, 10) + "");
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { denumCoeffs, numCoeffs }) => {
+    const numDegree = numCoeffs.length - 1;
+    const denumDegree = denumCoeffs.length - 1;
+    const numLeadingCoeff = numCoeffs[numDegree];
+    const denumLeadingCoeff = denumCoeffs[denumDegree];
+    const leadingCoeffsRational = new Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    let answer;
+    if (denumDegree === numDegree) {
+        answer = leadingCoeffsRational;
+    }
+    else if (denumDegree > numDegree) {
+        answer = new NumberNode(0);
+    }
+    else {
+        const tempPoly = new Monom(numDegree - denumDegree, numLeadingCoeff * denumLeadingCoeff > 0 ? 1 : -1);
+        answer = tempPoly.getLimitNode("+\\infty");
+    }
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+export const sequenceRationalFracLimit = {
+    id: "sequenceRationalFracLimit",
+    connector: "=",
+    label: "Limite d'une suite rationnelle",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getSequenceRationalFracLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/primitive/constantPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAOJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAgCF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAMxE,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,EACX,OAAO,CAaR,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CAAC,WAAW,EAAE,OAAO,CAmB/E,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAQpE,CAAC;AAYF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAc5D,CAAC"}
+{"version":3,"file":"constantPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/constantPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EASJ,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAyDF,eAAO,MAAM,oBAAoB,EAAE,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAMxE,CAAC;AAEF,eAAO,MAAM,2CAA2C,EAAE,0BAA0B,CAClF,WAAW,EACX,OAAO,CAeR,CAAC;AACF,eAAO,MAAM,gCAAgC,EAAE,YAAY,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,GAAG,CAAC,WAAW,EAAE,OAAO,CAQpE,CAAC;AAYF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe5D,CAAC"}

package/lib/exercises/math/primitive/constantPrimitive.js

@@ -16,13 +16,34 @@ const getInstruction = (identifiers, opts) => {
     const { c } = identifiers;
     const isAskingParticularPrimitive = opts?.askParticularPrimitive;
     return `${isAskingParticularPrimitive
-        ? "Déterminer une primitive en particulier de la fonction constante $f$ définie par"
+        ? "Donner une des primitives de la fonction constante $f$ définie par"
         : "Déterminer la forme générale des primitives de la fonction constante $f$ définie par"} : 
   
 $$
 f(x) = ${c}
 $$`;
 };
+const getHint = (identifiers) => {
+    const { c } = identifiers;
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${c}$ ?`;
+};
+const getCorrection = (identifiers, opts) => {
+    if (opts?.askParticularPrimitive)
+        return `Une primitive de $f$ est : 
+  
+$$
+F(x) = ${getAnswerNode(identifiers, opts).toTex()}
+$$
+
+En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswerNode(identifiers, opts).toTex()}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 const getAnswer = (identifiers, opts) => {
     return getAnswerNode(identifiers, opts).toTex();
 };
@@ -39,6 +60,8 @@ export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers, opts) =
         keys: opts?.askParticularPrimitive ? ["x"] : ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         options: opts,
     };
     return question;
@@ -82,4 +105,5 @@ export const constantPrimitive = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getConstantPrimitiveQuestionFromIdentifiers,
     options,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/exponentialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAKJ,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwBF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAIlE,CAAC;AAEF,eAAO,MAAM,8CAA8C,EAAE,0BAA0B,CACrF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"exponentialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/exponentialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAKJ,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwBF,eAAO,MAAM,uBAAuB,EAAE,iBAAiB,CAAC,WAAW,CAIlE,CAAC;AAqBF,eAAO,MAAM,8CAA8C,EAAE,0BAA0B,CACrF,WAAW,CAcZ,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,YAAY,CAAC,WAAW,CAgCzE,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,GAAG,CAAC,WAAW,CAY9D,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}