math-exercises 2.1.25 → 2.1.26-beta.2

package/lib/exercises/limits/limitReading.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitReading = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const colors_1 = require("../../geogebra/colors");
+const geogebraConstructor_1 = require("../../geogebra/geogebraConstructor");
+const randint_1 = require("../../math/utils/random/randint");
+const infiniteNode_1 = require("../../tree/nodes/numbers/infiniteNode");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const limitNode_1 = require("../../tree/nodes/operators/limitNode");
+const substractNode_1 = require("../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const coinFlip_1 = require("../../utils/coinFlip");
+const getLimitReadingQuestion = () => {
+    let to;
+    let from = undefined;
+    const type = (0, randint_1.randint)(1, 3);
+    let fct;
+    let answer = "";
+    let a;
+    switch (type) {
+        case 1: //a + b/(x-c)
+            a = (0, randint_1.randint)(-3, 4);
+            const b = (0, randint_1.randint)(-1, 2, [0]);
+            const c = (0, randint_1.randint)(-5, 6);
+            fct = new addNode_1.AddNode(new numberNode_1.NumberNode(a), new fractionNode_1.FractionNode(new numberNode_1.NumberNode(b), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), new numberNode_1.NumberNode(c)))).toMathString();
+            if ((0, coinFlip_1.coinFlip)()) {
+                // limites en +-inf
+                answer = a + "";
+                to = (0, coinFlip_1.coinFlip)() ? infiniteNode_1.PlusInfinityNode : infiniteNode_1.MinusInfinityNode;
+            }
+            else {
+                // limite en VI
+                to = new numberNode_1.NumberNode(c);
+                if ((0, coinFlip_1.coinFlip)()) {
+                    from = "+";
+                    answer = b > 0 ? infiniteNode_1.PlusInfinityNode.toTex() : infiniteNode_1.MinusInfinityNode.toTex();
+                }
+                else {
+                    from = "-";
+                    answer = b < 0 ? infiniteNode_1.PlusInfinityNode.toTex() : infiniteNode_1.MinusInfinityNode.toTex();
+                }
+            }
+            break;
+        case 2:
+        default:
+            const aPositive = (0, coinFlip_1.coinFlip)();
+            const polyPoints = [];
+            polyPoints.push([-8, (0, randint_1.randint)(-4, 5)]);
+            polyPoints.push([
+                -4,
+                aPositive ? polyPoints[0][1] + 2 : polyPoints[0][1] - 2,
+            ]);
+            polyPoints.push([2, polyPoints[0][1]]);
+            polyPoints.push([6, polyPoints[1][1]]);
+            const pointsString = polyPoints
+                .map((point) => `(${point[0]},${point[1]})`)
+                .join(",");
+            fct = `Polynomial({${pointsString}})`;
+            const isPlusInf = (0, coinFlip_1.coinFlip)();
+            to = isPlusInf ? infiniteNode_1.PlusInfinityNode : infiniteNode_1.MinusInfinityNode;
+            answer = aPositive
+                ? isPlusInf
+                    ? infiniteNode_1.PlusInfinityNode.toTex()
+                    : infiniteNode_1.MinusInfinityNode.toTex()
+                : isPlusInf
+                    ? infiniteNode_1.MinusInfinityNode.toTex()
+                    : infiniteNode_1.PlusInfinityNode.toTex();
+            break;
+    }
+    const commands = [`f(x) = ${fct}`, `SetColor(f, "${(0, colors_1.randomColor)()}")`];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isAxesRatioFixed: false,
+        isGridSimple: true,
+    });
+    const question = {
+        answer,
+        instruction: `Ci-dessous est tracée la courbe représentative d'une fonction $f$. Déterminer la limite: $\\displaystyle ${new limitNode_1.LimitNode(to, new variableNode_1.VariableNode("f(x)"), from).toTex()}$`,
+        keys: ["infty"],
+        commands: ggb.commands,
+        coords: [-10, 10, -10, 10],
+        options: ggb.getOptions(),
+        answerFormat: "tex",
+        identifiers: { type, to: to.toTex(), from, a },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, type, to, from, a }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    if (a !== undefined)
+        (0, exercise_1.tryToAddWrongProp)(propositions, a + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, to);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-5, 6) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return answer === ans;
+};
+exports.limitReading = {
+    id: "limitReading",
+    connector: "=",
+    label: "Conjecturer graphiquement la limite d'une fonction",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getLimitReadingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+};

package/lib/exercises/limits/polynomLimit.d.ts

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

package/lib/exercises/limits/polynomLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/polynomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwCF,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/limits/polynomLimit.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomLimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const coinFlip_1 = require("../../utils/coinFlip");
+const shuffle_1 = require("../../utils/shuffle");
+const getPolynomLimitQuestion = () => {
+    const poly = polynomial_1.PolynomialConstructor.random(4);
+    const to = (0, coinFlip_1.coinFlip)() ? "+\\infty" : "-\\infty";
+    const answer = poly.getLimit(to);
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la limite en $${to}$ de la fonction $f$ définie par : $f(x) = ${poly
+            .toTree()
+            .toTex()}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: { coeffs: poly.coefficients, to },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, coeffs[coeffs.length - 1] + "");
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(-10, 10) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.polynomLimit = {
+    id: "polynomLimit",
+    connector: "=",
+    label: "Limite d'une fonction polynomiale",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPolynomLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/limits/polynomLimitNoFI.d.ts

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

package/lib/exercises/limits/polynomLimitNoFI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomLimitNoFI.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/polynomLimitNoFI.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4CF,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,WAAW,CAatD,CAAC"}

package/lib/exercises/limits/polynomLimitNoFI.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polynomLimitNoFI = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const coinFlip_1 = require("../../utils/coinFlip");
+const shuffle_1 = require("../../utils/shuffle");
+const getSequencePolynomNoFILimitQuestion = () => {
+    const length = (0, randint_1.randint)(2, 5);
+    const to = (0, coinFlip_1.coinFlip)() ? "+\\infty" : "-\\infty";
+    const poly = polynomial_1.PolynomialConstructor.randomNoFI(4, to, length);
+    const answer = poly.getLimit(to);
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la limite en $${to}$ de la fonction $f$ définie par : $f(x) = ${poly
+            .toTree()
+            .toTex()}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: { coeffs: poly.coefficients, to },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, coeffs[coeffs.length - 1] + "");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.polynomLimitNoFI = {
+    id: "polynomLimitNoFI",
+    connector: "=",
+    label: "Limite d'une fonction polynomiale (sans F.I.)",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePolynomNoFILimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/limits/rationalFracForbiddenValueLimit.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    numCoeffs: number[];
+    denumCoeffs: number[];
+    isRight: boolean;
+};
+export declare const rationalFracForbiddenValueLimit: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=rationalFracForbiddenValueLimit.d.ts.map

package/lib/exercises/limits/rationalFracForbiddenValueLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rationalFracForbiddenValueLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/rationalFracForbiddenValueLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAyEF,eAAO,MAAM,+BAA+B,EAAE,YAAY,CAAC,WAAW,CAarE,CAAC"}

package/lib/exercises/limits/rationalFracForbiddenValueLimit.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rationalFracForbiddenValueLimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../math/polynomials/affine");
+const trinom_1 = require("../../math/polynomials/trinom");
+const randint_1 = require("../../math/utils/random/randint");
+const coinFlip_1 = require("../../utils/coinFlip");
+const getSign = (nb) => {
+    return nb >= 0 ? "+" : "-";
+};
+const getSequenceRationalFracLimitQuestion = () => {
+    const polyDenum = new affine_1.Affine(1, (0, randint_1.randint)(-9, 10, [0]));
+    const forbiddenValue = -polyDenum.b;
+    const polyNum = trinom_1.TrinomConstructor.randomFactorized(undefined, { excludes: [forbiddenValue] }, { excludes: [forbiddenValue] });
+    const numLimit = polyNum.calculate(-polyDenum.b);
+    const isRight = (0, coinFlip_1.coinFlip)();
+    const to = isRight ? `${forbiddenValue}` : `${forbiddenValue}`;
+    const from = isRight ? `x>${forbiddenValue}` : `x<${forbiddenValue}`;
+    const answer = isRight
+        ? `${getSign(numLimit)}\\infty`
+        : `${getSign(-numLimit)}\\infty`;
+    const question = {
+        answer,
+        instruction: `Soit $f$ la fonction définie par : $f(x) = \\dfrac{${polyNum
+            .toTree()
+            .toTex()}}{${polyDenum
+            .toTree()
+            .toTex()}}$. Déterminer $\\lim\\limits_{x \\to ${to}, \\ ${from}}f(x).$
+      `,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: {
+            numCoeffs: polyNum.coefficients,
+            denumCoeffs: polyDenum.coefficients,
+            isRight,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, numCoeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, numCoeffs[numCoeffs.length - 1].toString());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, numCoeffs, denumCoeffs, isRight }) => {
+    return ans === answer;
+};
+exports.rationalFracForbiddenValueLimit = {
+    id: "rationalFracForbiddenValueLimit",
+    connector: "=",
+    label: "Limite d'une fraction rationnelle avec valeur interdite",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceRationalFracLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/limits/rationalFracLimit.d.ts

@@ -0,0 +1,9 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    limitTo: "+\\infty" | "-\\infty";
+    numCoeffs: number[];
+    denumCoeffs: number[];
+};
+export declare const rationalFracLimit: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=rationalFracLimit.d.ts.map

package/lib/exercises/limits/rationalFracLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rationalFracLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/rationalFracLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,UAAU,GAAG,UAAU,CAAC;IACjC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAqGF,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,WAAW,CAavD,CAAC"}

package/lib/exercises/limits/rationalFracLimit.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rationalFracLimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../math/numbers/rationals/rational");
+const monom_1 = require("../../math/polynomials/monom");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../utils/coinFlip");
+const shuffle_1 = require("../../utils/shuffle");
+const getSequenceRationalFracLimitQuestion = () => {
+    const polyNum = polynomial_1.PolynomialConstructor.randomWithLength(4, (0, randint_1.randint)(2, 5));
+    const polyDenum = polynomial_1.PolynomialConstructor.randomWithLength(4, (0, randint_1.randint)(2, 5));
+    const numLeadingCoeff = polyNum.coefficients[polyNum.degree];
+    const denumLeadingCoeff = polyDenum.coefficients[polyDenum.degree];
+    const to = (0, coinFlip_1.coinFlip)() ? "+\\infty" : "-\\infty";
+    let answer;
+    let leadingCoeffsRational = new rational_1.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_1.Monom(polyNum.degree - polyDenum.degree, numLeadingCoeff * denumLeadingCoeff > 0 ? 1 : -1);
+        answer = tempPoly.getLimit(to);
+    }
+    const question = {
+        answer,
+        instruction: `Déterminer la limite en $${to}$ de la fonction $f$ définie par : $f(x) = \\dfrac{${polyNum
+            .toTree()
+            .toTex()}}{${polyDenum.toTree().toTex()}}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: {
+            numCoeffs: polyNum.coefficients,
+            denumCoeffs: polyDenum.coefficients,
+            limitTo: to,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, denumCoeffs, numCoeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const numLeadingCoeff = numCoeffs[numCoeffs.length - 1];
+    const denumLeadingCoeff = denumCoeffs[denumCoeffs.length - 1];
+    let leadingCoeffsRational = new rational_1.Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree()
+        .toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, leadingCoeffsRational);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { denumCoeffs, numCoeffs, limitTo }) => {
+    const numDegree = numCoeffs.length - 1;
+    const denumDegree = denumCoeffs.length - 1;
+    const numLeadingCoeff = numCoeffs[numDegree];
+    const denumLeadingCoeff = denumCoeffs[denumDegree];
+    let leadingCoeffsRational = new rational_1.Rational(numLeadingCoeff, denumLeadingCoeff)
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    let answer;
+    if (denumDegree === numDegree) {
+        answer = leadingCoeffsRational;
+    }
+    else if (denumDegree > numDegree) {
+        answer = new numberNode_1.NumberNode(0);
+    }
+    else {
+        const tempPoly = new monom_1.Monom(numDegree - denumDegree, numLeadingCoeff * denumLeadingCoeff > 0 ? 1 : -1);
+        answer = tempPoly.getLimitNode(limitTo);
+    }
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.rationalFracLimit = {
+    id: "rationalFracLimit",
+    connector: "=",
+    label: "Limite d'une fraction rationnelle",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceRationalFracLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/limits/sequenceGeometricLimit.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    reason: string;
+    firstTerm: string;
+};
+export declare const sequenceGeometricLimit: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequenceGeometricLimit.d.ts.map

package/lib/exercises/limits/sequenceGeometricLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceGeometricLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/sequenceGeometricLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6CF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/limits/sequenceGeometricLimit.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequenceGeometricLimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const geometricSequence_1 = require("../../math/sequences/geometricSequence");
+const getSequenceGeometricLimitQuestion = () => {
+    const sequence = geometricSequence_1.GeometricSequenceConstructor.randomWithLimit();
+    const answer = sequence.getLimit();
+    if (!answer)
+        throw Error("received geometric sequence with no limit");
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la limite de la suite $u$ définie par : $u_n = ${sequence
+            .toTree()
+            .toTex()}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: {
+            reason: sequence.reason.toTree().toTex(),
+            firstTerm: sequence.firstTerm.toTree().toTex(),
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, reason, firstTerm }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, reason + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, firstTerm + "");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequenceGeometricLimit = {
+    id: "sequenceGeometricLimit",
+    connector: "=",
+    label: "Limite d'une suite géométrique",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites", "Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceGeometricLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePolynomLimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/sequencePolynomLimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAuCF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/limits/sequencePolynomLimit.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequencePolynomLimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const shuffle_1 = require("../../utils/shuffle");
+const getSequencePolynomLimitQuestion = () => {
+    const poly = polynomial_1.PolynomialConstructor.random(4, "n");
+    const to = "+\\infty";
+    const answer = poly.getLimit(to);
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la limite de la suite $u$ définie par : $u_n = ${poly
+            .toTree()
+            .toTex()}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: { coeffs: poly.coefficients },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, coeffs[coeffs.length - 1] + "");
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(-10, 10) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequencePolynomLimit = {
+    id: "sequencePolynomLimit",
+    connector: "=",
+    label: "Limite d'une suite polynomiale",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites", "Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePolynomLimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePolynomNoFILimit.d.ts","sourceRoot":"","sources":["../../../src/exercises/limits/sequencePolynomNoFILimit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA6CF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/limits/sequencePolynomNoFILimit.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequencePolynomNoFILimit = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const polynomial_1 = require("../../math/polynomials/polynomial");
+const randint_1 = require("../../math/utils/random/randint");
+const shuffle_1 = require("../../utils/shuffle");
+const getSequencePolynomNoFILimitQuestion = () => {
+    const length = (0, randint_1.randint)(2, 5);
+    const poly = polynomial_1.PolynomialConstructor.randomWithLengthAndSameSigns(4, length, "n");
+    const to = "+\\infty";
+    const answer = poly.getLimit(to);
+    const question = {
+        answer: answer,
+        instruction: `Déterminer la limite de la suite $u$ définie par : $u_n = ${poly
+            .toTree()
+            .toTex()}$.`,
+        keys: ["infty"],
+        answerFormat: "tex",
+        identifiers: { coeffs: poly.coefficients },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coeffs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "+\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "-\\infty");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    (0, exercise_1.tryToAddWrongProp)(propositions, coeffs[coeffs.length - 1] + "");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequencePolynomNoFILimit = {
+    id: "sequencePolynomNoFILimit",
+    connector: "=",
+    label: "Limite d'une suite polynomiale (sans F.I.)",
+    levels: ["TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Limites", "Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePolynomNoFILimitQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

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