math-exercises 3.0.177 → 3.0.179

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.js

@@ -0,0 +1,291 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { rank1, value1, rank2, value2 } = identifiers;
+    return `Soit $u$ une suite géométrique telle que $u_{${rank1.frenchify()}} = ${value1.frenchify()}$ et $u_{${rank2.frenchify()}} = ${value2.frenchify()}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getAnswerStuff = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2, precisionInitial, precisionReason } = identifiers;
+    const reason = round(power(frac(value2, value1), frac(1, substract(rank2, rank1))).evaluate(), precisionReason);
+    const valueFirstRank = round(frac(value1, power(reason, rank1 - firstRank)).evaluate(), precisionInitial);
+    const nodeFormula = multiply(valueFirstRank, power(reason, substract("n".toTree(), firstRank).simplify()));
+    const equalNode = new EqualNode("u_n".toTree(), nodeFormula);
+    return {
+        initial: valueFirstRank,
+        reason,
+        answerNode: equalNode,
+    };
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerStuff(identifiers, opts).answerNode.toTex();
+};
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    return `Commence par déterminer la raison $q$ de la suite $u$. 
+  
+Puis, utilise cette raison et un des termes connus de la suite pour déterminer $u_{${firstRank}}$.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const closest = Math.abs(firstRank - rank1) < Math.abs(firstRank - rank2) ? rank1 : rank2;
+    const diff = firstRank - closest;
+    const closestValue = closest === rank1 ? value1 : value2;
+    const { reason, answerNode } = getAnswerStuff(identifiers, opts);
+    return `On commence par déterminer la raison $q$ de la suite $u$.
+
+On a :
+
+${alignTex([
+        [
+            `u_{${rank1}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank1.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+        [
+            `u_{${rank2}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank2.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+    ])}
+
+On forme le quotient :
+
+${alignTex([
+        [
+            `\\frac{u_{${rank2}}}{u_{${rank1}}}`,
+            "=",
+            `q^{${rank2.frenchify()} - ${rank1.frenchify()}}`,
+        ],
+        [
+            `\\frac{${value2.frenchify()}}{${value1.frenchify()}}`,
+            "=",
+            `q^{${(rank2 - rank1).frenchify()}}`,
+        ],
+        [`${reason.frenchify()}`, "=", `q`],
+    ])}
+
+On peut alors déterminer $u_{${firstRank.frenchify()}}$ en utilisant $u_{${closest.frenchify()}}$ et $q$. En effet, on a : 
+
+${alignTex([
+        [
+            `u_{${firstRank.frenchify()}}`,
+            "=",
+            `\\frac{u_{${closest.frenchify()}}}{q^{${(-diff).frenchify()}}}`,
+        ],
+        ["", "=", frac(closestValue, power(reason, -diff)).toTex()],
+        ["", "=", multiply(closestValue, power(reason, diff)).evaluate().frPretty(1)],
+    ])}
+
+On a donc : 
+
+${(() => {
+        const texFormulaAbstract = firstRank === 0 ? "u_0 \\times q^{n}" : "u_1 \\times q^{n-1}";
+        return alignTex([
+            ["u_n", "=", texFormulaAbstract],
+            ["", "=", answerNode.rightChild.toTex()],
+        ]);
+    })()}
+
+`;
+};
+const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiersCurated(opts);
+        const texWrong = getAnswer(identifiersWrong, opts);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        const nodeAnswer = getAnswerStuff(identifiers, opts).answerNode;
+        if (!ans.includes("=")) {
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            return [0, 1, 2, 10].every((n) => {
+                return (substract(nodeAnsRhs.evaluate({ n }), nodeAnswerRhs.evaluate({ n })).evaluate() === 0);
+            });
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiersRaw = (opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const isDivergent = coinFlip();
+    const isReasonNegative = coinFlip();
+    const signReason = isReasonNegative ? -1 : +1;
+    function createGeometricDivergent() {
+        const precisionInitial = 1;
+        const initial = randfloat(1, 10, precisionInitial, [1]);
+        const precisionReason = 0;
+        const reason = signReason * randint(2, 10);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    function createGeometricConvergent() {
+        const poolReasonStuff = [
+            {
+                q: 0.5,
+                precision: 1,
+                invQ: 2,
+            },
+            {
+                q: 0.25,
+                precision: 2,
+                invQ: 4,
+            },
+            {
+                q: 0.2,
+                precision: 1,
+                invQ: 5,
+            },
+            {
+                q: 0.1,
+                precision: 1,
+                invQ: 10,
+            },
+            {
+                q: 0.05,
+                precision: 2,
+                invQ: 20,
+            },
+        ];
+        const { q, invQ, precision: precisionReason } = random(poolReasonStuff);
+        const reason = signReason * q;
+        const precisionInitial = 0;
+        const initial = round(randint(10, 100) * Math.pow(invQ, 8), precisionInitial);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    const [initial, precisionInitial, reason, precisionReason] = (() => {
+        if (isDivergent) {
+            return createGeometricDivergent();
+        }
+        else {
+            return createGeometricConvergent();
+        }
+    })();
+    const rank1 = randint(firstRank + 1, 5);
+    const rank2 = rank1 + randint(1, 5);
+    function valueForRank(initial, reason, rank) {
+        return initial * Math.pow(reason, rank);
+    }
+    const [value1, value2] = [rank1, rank2].map((rank) => round(valueForRank(initial, reason, rank), 6));
+    const identifiers = {
+        rank1,
+        value1,
+        rank2,
+        value2,
+        precisionInitial,
+        precisionReason,
+    };
+    return identifiers;
+};
+const createRandomIdentifiersCurated = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiersRaw(opts);
+        const answer = getAnswer(identifiersCandidate, opts);
+        isValid = !answer.includes("NaN");
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //2.5 * 2^n
+        const identifiersDefault = {
+            rank1: 2,
+            value1: 10,
+            rank2: 5,
+            value2: 40,
+            precisionInitial: 1,
+            precisionReason: 0,
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getGeometricFindExplicitFormulaFromTwoConsecutiveTermsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiersCurated(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindExplicitFormulaFromTwoConsecutiveTerms = {
+    id: "geometricFindExplicitFormulaFromTwoConsecutiveTerms",
+    connector: "=",
+    label: "Connaissant deux termes consécutifs d'une suite géométrique, en donner une formule générale",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindExplicitFormulaFromTwoConsecutiveTermsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFromTwoTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAoB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAkWF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFromTwoTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAoB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAsWF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAC7D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoTerms.js

@@ -136,10 +136,12 @@ const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
 const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;
     try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        const nodeAnswer = getAnswerStuff(identifiers, opts).answerNode;
         if (!ans.includes("=")) {
-            return false;
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
         }
-        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
         // const nodeAns = parseAlgebraic(ans);
         const nodeAns = (() => {
             const [lhs, rhs] = ans.split("=");
@@ -150,7 +152,6 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         if (!isEqualNode(nodeAns)) {
             return false;
         }
-        const nodeAnswer = getAnswerStuff(identifiers, opts).answerNode;
         const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
         const isValidRhs = () => {
             const nodeAnsRhs = nodeAns.rightChild;

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoConsecutiveTerms.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+    rankAsked: number;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricFindRandomTermFromTwoConsecutiveTerms: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindRandomTermFromTwoConsecutiveTerms.d.ts.map

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoConsecutiveTerms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindRandomTermFromTwoConsecutiveTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoConsecutiveTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAe3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6RF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,8CAA8C,EAAE,QAAQ,CACnE,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoConsecutiveTerms.js

@@ -0,0 +1,249 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { rank1, value1, rank2, value2, rankAsked } = identifiers;
+    return `Soit $u$ une suite géométrique telle que $u_{${rank1.frenchify()}} = ${value1.frenchify()}$ et $u_{${rank2.frenchify()}} = ${value2.frenchify()}$. 
+  
+Que vaut $u_{${rankAsked}}$ ?`;
+};
+const getAnswerStuff = (identifiers, _opts) => {
+    const { rank1, value1, rank2, value2, precisionInitial, precisionReason, rankAsked, } = identifiers;
+    const reason = round(power(frac(value2, value1), frac(1, substract(rank2, rank1))).evaluate(), precisionReason);
+    const valueAsked = round(frac(value1, power(reason, rank1 - rankAsked)).evaluate(), precisionInitial);
+    return {
+        reason,
+        answerNode: valueAsked.toTree(),
+    };
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerStuff(identifiers, opts).answerNode.toTex();
+};
+const getHint = (identifiers, _optsIn) => {
+    const { rankAsked } = identifiers;
+    return `Commence par déterminer la raison $q$ de la suite $u$. 
+  
+Puis, utilise cette raison et un des termes connus de la suite pour déterminer $u_{${rankAsked}}$.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2, rankAsked } = identifiers;
+    const diff = rankAsked - rank1;
+    const { reason, answerNode } = getAnswerStuff(identifiers, opts);
+    return `On commence par déterminer la raison $q$ de la suite $u$.
+
+On a :
+
+${alignTex([
+        [
+            `u_{${rank1}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank1.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+        [
+            `u_{${rank2}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank2.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+    ])}
+
+On forme le quotient :
+
+${alignTex([
+        [
+            `\\frac{u_{${rank2}}}{u_{${rank1}}}`,
+            "=",
+            `q^{${rank2.frenchify()} - ${rank1.frenchify()}}`,
+        ],
+        [
+            `\\frac{${value2.frenchify()}}{${value1.frenchify()}}`,
+            "=",
+            `q^{${(rank2 - rank1).frenchify()}}`,
+        ],
+        [`${reason.frenchify()}`, "=", `q`],
+    ])}
+
+On peut alors déterminer $u_{${rankAsked.frenchify()}}$ en utilisant $u_{${rank1.frenchify()}}$ et $q$. En effet, on a : 
+
+${alignTex([
+        [
+            `u_{${rankAsked.frenchify()}}`,
+            "=",
+            `\\frac{u_{${rank1.frenchify()}}}{q^{${(-diff).frenchify()}}}`,
+        ],
+        ["", "=", frac(value1, power(reason, -diff)).toTex()],
+        ["", "=", answerNode.toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiersCurated(opts);
+        const texWrong = getAnswer(identifiersWrong, opts);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiersRaw = (opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const isDivergent = coinFlip();
+    const isReasonNegative = coinFlip();
+    const signReason = isReasonNegative ? -1 : +1;
+    function createGeometricDivergent() {
+        const precisionInitial = 1;
+        const initial = randfloat(1, 10, precisionInitial, [1]);
+        const precisionReason = 0;
+        const reason = signReason * randint(2, 10);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    function createGeometricConvergent() {
+        const poolReasonStuff = [
+            {
+                q: 0.5,
+                precision: 1,
+                invQ: 2,
+            },
+            {
+                q: 0.25,
+                precision: 2,
+                invQ: 4,
+            },
+            {
+                q: 0.2,
+                precision: 1,
+                invQ: 5,
+            },
+            {
+                q: 0.1,
+                precision: 1,
+                invQ: 10,
+            },
+            {
+                q: 0.05,
+                precision: 2,
+                invQ: 20,
+            },
+        ];
+        const { q, invQ, precision: precisionReason } = random(poolReasonStuff);
+        const reason = signReason * q;
+        const precisionInitial = 0;
+        const initial = round(randint(10, 100) * Math.pow(invQ, 8), precisionInitial);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    const [initial, precisionInitial, reason, precisionReason] = (() => {
+        if (isDivergent) {
+            return createGeometricDivergent();
+        }
+        else {
+            return createGeometricConvergent();
+        }
+    })();
+    const rank1 = randint(firstRank + 1, 5);
+    const rank2 = rank1 + 1;
+    const rankAsked = randint(2, 9, [rank1, rank2]);
+    function valueForRank(initial, reason, rank) {
+        return initial * Math.pow(reason, rank);
+    }
+    const [value1, value2] = [rank1, rank2].map((rank) => round(valueForRank(initial, reason, rank), 4));
+    const identifiers = {
+        rank1,
+        value1,
+        rank2,
+        value2,
+        precisionInitial,
+        precisionReason,
+        rankAsked,
+    };
+    return identifiers;
+};
+const createRandomIdentifiersCurated = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiersRaw(opts);
+        const answer = getAnswer(identifiersCandidate, opts);
+        isValid = !answer.includes("NaN");
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //2.5 * 2^n
+        const identifiersDefault = {
+            rank1: 2,
+            value1: 10,
+            rank2: 5,
+            value2: 40,
+            precisionInitial: 1,
+            precisionReason: 0,
+            rankAsked: 9,
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getGeometricFindRandomTermFromTwoConsecutiveTermsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiersCurated(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindRandomTermFromTwoConsecutiveTerms = {
+    id: "geometricFindRandomTermFromTwoConsecutiveTerms",
+    connector: "=",
+    label: "Connaissant deux termes consécutifs d'une suite géométrique, en donner une formule générale",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRandomTermFromTwoConsecutiveTermsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoTerms.js

@@ -177,7 +177,7 @@ const createRandomIdentifiersRaw = (opts) => {
         }
     })();
     const rank1 = randint(firstRank + 1, 5);
-    const rank2 = rank1 + randint(1, 5);
+    const rank2 = rank1 + randint(2, 5);
     const rankAsked = randint(2, 9, [rank1, rank2]);
     function valueForRank(initial, reason, rank) {
         return initial * Math.pow(reason, rank);
@@ -246,7 +246,7 @@ const options = [generatorOptionFirstTermRankOne];
 export const geometricFindRandomTermFromTwoTerms = {
     id: "geometricFindRandomTermFromTwoTerms",
     connector: "=",
-    label: "Connaissant deux termes d'une suite géométrique, en donner une formule générale",
+    label: "Connaissant deux termes d'une suite géométrique, en calculer un troisième",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRandomTermFromTwoTermsQuestion(opts), nb),
     options,

package/lib/exercises/math/sequences/geometric/index.d.ts

@@ -2,13 +2,14 @@ export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
 export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
-export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
-export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";
+export * from "./geometricFindRandomTermFromTwoTerms.js";
+export * from "./sum/index.js";
+export * from "./situations/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,0BAA0B,CAAC;AAIzC,cAAc,0CAA0C,CAAC;AAGzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/sequences/geometric/index.js

@@ -2,12 +2,16 @@ export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
 export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
-export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
-export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";
+// export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
+// export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
+export * from "./geometricFindRandomTermFromTwoTerms.js";
+// export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
+export * from "./sum/index.js";
+export * from "./situations/index.js";

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAiBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AA8OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAiBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AAiPF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}