math-exercises 3.0.171 → 3.0.173

package/lib/exercises/math/sequences/geometric/situations/geometricFindRecurrenceFormulaFromSituation.js

@@ -0,0 +1,205 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsWithSuperfluousData, } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { situationsGeometric, } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+import { EqualNode, isEqualNode, } from "../../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const _getNodeFactor = (firstRank, varName = "n") => {
+    const nodeN = varName.toTree();
+    return firstRank === 0 ? nodeN : substract(nodeN, 1);
+};
+const situations = situationsGeometric;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData } = identifiers;
+    const situation = situations[situationIndex];
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+Donner la relation de récurrence pour la suite $(u_n)$.`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRecurrenceFormula.getAnswerNode(initial, reason, firstRank);
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getHint = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRecurrenceFormula.getHint(firstRank);
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //most to least probable mistakes:
+    //student: geometric -> arithmetic: u_{n+1} = u_n + reason
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), add("u_{n}".toTree(), reason)).toTex());
+    }
+    //student: reason -> initial: u_{n+1} = u_n * initial
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), multiply("u_{n}".toTree(), initial)).toTex());
+    }
+    //student: u_{n+1} = u_n * n ^ reason
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), multiply("u_{n}".toTree(), power("n".toTree(), reason))).toTex());
+    }
+    //student: mixes explicit with recurrence: u_{n+1} = initial + u_n * reason
+    {
+        const nodeExplicitFormula = situation.variationFindExplicitFormula.getAnswerNode(initial, reason, firstRank);
+        const nodeWrong1 = nodeBySubstitutingVar(nodeExplicitFormula, "u_{n+1}".toTree(), "u_n".toTree());
+        const nodeWrong2 = nodeBySubstitutingVar(nodeWrong1, "u_{n}".toTree(), "n".toTree());
+        const strWrong2 = nodeWrong2.simplify().toTex();
+        tryToAddWrongProp(propositions, strWrong2);
+    }
+    //student: explicit formula
+    {
+        tryToAddWrongProp(propositions, situation.variationFindExplicitFormula
+            .getAnswerNode(initial, reason, firstRank)
+            .toTex());
+    }
+    //student: explicit formula for u_{n+1}
+    {
+        const nodeFormula = multiply(initial, power(reason, substract(add("n".toTree(), 1), firstRank).simplify())).simplify();
+        const equalNode = new EqualNode("u_{n+1}".toTree(), nodeFormula);
+        tryToAddWrongProp(propositions, equalNode.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }, _optsIn) => {
+    try {
+        if (!ans.includes("=")) {
+            return false;
+        }
+        //TODO faire fonctionner parseAlgebraic("u_n = 3 \\times 2^n") (token _ not implemented)
+        // const nodeAns = parseAlgebraic(ans);
+        function workaroundParser(strSrc) {
+            function workaroundReplacer(strSrc) {
+                const dictFromTo = {
+                    u_n: "x",
+                    "u_{n+1}": "y",
+                };
+                return Object.entries(dictFromTo).reduce((acc, [strFrom, strTo]) => {
+                    return acc.replaceAll(strFrom, strTo);
+                }, strSrc);
+            }
+            const [lhs, rhs] = strSrc.split("=");
+            const [lhsRefined, rhsRefined] = [lhs, rhs].map(workaroundReplacer);
+            const [nodeLhs, nodeRhs] = [lhsRefined, rhsRefined].map((str) => parseAlgebraic(str));
+            return new EqualNode(nodeLhs, nodeRhs);
+        }
+        const nodeAns = workaroundParser(ans);
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        // const nodeAnswer = getAnswerNode(identifiers, opts) as EqualNode;
+        const nodeAnswer = workaroundParser(answer);
+        const isValidLhs = () => {
+            // return (
+            //   substract(nodeAns.leftChild, nodeAnswer.leftChild)
+            //     .simplify()
+            //     .evaluate() === 0
+            // );
+            return [1, 10, 100].every((y) => {
+                return (substract(nodeAns.leftChild, nodeAnswer.leftChild).evaluate({
+                    y,
+                }) === 0);
+            });
+        };
+        const isValidRhs = () => {
+            // return (
+            //   substract(nodeAns.rightChild, nodeAnswer.rightChild)
+            //     .simplify()
+            //     .evaluate() === 0
+            // );
+            return [1, 10, 100].every((x) => {
+                return (substract(nodeAns.rightChild, nodeAnswer.rightChild).evaluate({
+                    x,
+                }) === 0);
+            });
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        return handleVEAError(e);
+    }
+};
+const getGeometricFindRecurrenceFormulaFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const initial = situation.randInitial();
+    const reason = situation.randReason();
+    const superfluousData = opts.isWithSuperfluousData
+        ? situation.randSuperfluousData()
+        : undefined;
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["un", "equal", "n", "unplus1"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optionsStuffFirstTermRankOne = getOptionFirstTermRankOneStuff(false);
+const optionsStuffIsWithSuperfluousData = getOptionIsWithSuperfluousData(false);
+const optsDefault = Object.assign({}, optionsStuffFirstTermRankOne.optsDefaultFirstTermRankOne, optionsStuffIsWithSuperfluousData.optsDefaultIsWithSuperfluousData);
+const options = [
+    optionsStuffFirstTermRankOne.generatorOptionFirstTermRankOne,
+    optionsStuffIsWithSuperfluousData.generatorOptionIsWithSuperfluousData,
+];
+export const geometricFindRecurrenceFormulaFromSituation = {
+    id: "geometricFindRecurrenceFormulaFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution géométrique, exprimer la relation de récurrence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRecurrenceFormulaFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/situations/geometricFindTermFromSituation.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { SituationGeometricSuperfluousData } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationGeometricSuperfluousData;
+    rankAsked: number;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const geometricFindTermFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindTermFromSituation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindTermFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindTermFromSituation.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;AAKhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAazE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzE,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindTermFromSituation.js

@@ -0,0 +1,208 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsWithSuperfluousData, } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { isEquivalentNodes } from "../../../../../math/utils/functions/functionComparison.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { situationsGeometric, } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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";
+const _getNodeFactor = (firstRank, varName = "n") => {
+    const nodeN = varName.toTree();
+    return firstRank === 0 ? nodeN : substract(nodeN, 1);
+};
+const situations = situationsGeometric;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+Que vaut $u_{${rankAsked}}$ ?`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, rankAsked);
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).simplify().toTex();
+};
+const getHint = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getHint(firstRank, rankAsked);
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, rankAsked).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: type-specific mistake
+    {
+        const { situationIndex } = identifiers;
+        const situation = situations[situationIndex];
+        switch (situation.type) {
+            case "factor":
+                {
+                    (() => { })();
+                }
+                break;
+            case "factorPercentage":
+                {
+                    (() => { })();
+                }
+                break;
+            case "evo":
+                {
+                    (() => { })();
+                }
+                break;
+            case "evoPercentage":
+                {
+                    const evoPercentage = round((reason - 1) * 100, 2);
+                    //student: reason = evoPercentage
+                    {
+                        const identifiersWrong = { ...identifiers, reason: evoPercentage };
+                        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+                    }
+                    //student: reason = 100 + evoPercentage
+                    {
+                        const identifiersWrong = {
+                            ...identifiers,
+                            reason: 100 + evoPercentage,
+                        };
+                        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+                    }
+                }
+                break;
+        }
+    }
+    //student: geometric -> arithmetic
+    {
+        const nodeWrong = add(initial, multiply(reason, substract(rankAsked, firstRank))).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    if (coinFlip()) {
+        if (coinFlip()) {
+            //student: rankAsked - 1
+            {
+                const nodeWrong = situation.variationFindRandomTerm
+                    .getAnswerNode(reason, initial, firstRank, rankAsked - 1)
+                    .simplify();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+        else {
+            //student: rankAsked + 1
+            {
+                const nodeWrong = situation.variationFindRandomTerm
+                    .getAnswerNode(reason, initial, firstRank, rankAsked + 1)
+                    .simplify();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+    }
+    //student: swaps(initial, reason)
+    {
+        const nodeWrong = situation.variationFindRandomTerm
+            .getAnswerNode(reason, initial, firstRank, rankAsked)
+            .simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: u_n = (initial ^ reason) * n
+    {
+        const nodeWrong = multiply(power(initial, reason), substract(rankAsked, firstRank)).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: u_n = (initial * reason) ^ n
+    {
+        const nodeWrong = power(multiply(initial, reason), substract(rankAsked, firstRank)).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    if (ans === answer) {
+        return true;
+    }
+    else {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return isEquivalentNodes(nodeAns, nodeAnswer);
+    }
+};
+const getGeometricFindTermFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isWithSuperfluousData } = opts;
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const initial = situation.randInitial();
+    const reason = situation.randReason();
+    const superfluousData = isWithSuperfluousData
+        ? situation.randSuperfluousData()
+        : undefined;
+    const rankAsked = randint(4, 15);
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+        rankAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optionsStuffFirstTermRankOne = getOptionFirstTermRankOneStuff(false);
+const optionsStuffIsWithSuperfluousData = getOptionIsWithSuperfluousData(false);
+const optsDefault = Object.assign({}, optionsStuffFirstTermRankOne.optsDefaultFirstTermRankOne, optionsStuffIsWithSuperfluousData.optsDefaultIsWithSuperfluousData);
+const options = [
+    optionsStuffFirstTermRankOne.generatorOptionFirstTermRankOne,
+    optionsStuffIsWithSuperfluousData.generatorOptionIsWithSuperfluousData,
+];
+export const geometricFindTermFromSituation = {
+    id: "geometricFindTermFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution géométrique, exprimer un terme de rang $n$ demandé",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindTermFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/situations/geometricFindThresholdFromSituation.d.ts

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+import { SituationGeometricSuperfluousData } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationGeometricSuperfluousData;
+    valueThreshold: number;
+    inegSymbol: InegalitySymbols;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const geometricFindThresholdFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindThresholdFromSituation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindThresholdFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindThresholdFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAE9C,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAGzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAqKF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindThresholdFromSituation.js

@@ -0,0 +1,152 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsWithSuperfluousData, } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { InequationSymbol, InequationSymbolConstructor, } from "../../../../../math/inequations/inequation.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { situationsGeometric, } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const situations = situationsGeometric;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData, inegSymbol } = identifiers;
+    const situation = situations[situationIndex];
+    const _inequationSymbol = new InequationSymbol(inegSymbol);
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+situation.variationFindThreshold.getStrQuestion!(
+  initial,
+  reason,
+  firstRank,
+  valueThreshold,
+  inequationSymbol,
+)`;
+};
+const getAnswerNode = (_identifiers, _opts) => {
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, initial, reason, valueThreshold, inegSymbol } =
+    //   identifiers;
+    // const situation = situations[situationIndex];
+    // const inequationSymbol = new InequationSymbol(inegSymbol);
+    // return situation.variationFindThreshold.getAnswerNode(
+    //   initial,
+    //   reason,
+    //   firstRank,
+    //   valueThreshold,
+    //   inequationSymbol,
+    // );
+    return (0).toTree();
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).simplify().toTex();
+};
+const getHint = (_identifiers, _optsIn) => {
+    // const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, valueThreshold, inegSymbol, reason } = identifiers;
+    // const situation = situations[situationIndex];
+    // const inequationSymbol = new InequationSymbol(inegSymbol);
+    // return situation.variationFindThreshold.getHint(
+    //   firstRank,
+    //   valueThreshold,
+    //   inequationSymbol,
+    //   reason,
+    // );
+    return "hint";
+};
+const getCorrection = (_identifiers, _optsIn) => {
+    // const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, initial, reason, valueThreshold, inegSymbol } =
+    //   identifiers;
+    // const situation = situations[situationIndex];
+    // const inequationSymbol = new InequationSymbol(inegSymbol);
+    // return situation.variationFindThreshold.getCorrectionStuff(
+    //   initial,
+    //   reason,
+    //   firstRank,
+    //   valueThreshold,
+    //   inequationSymbol,
+    // ).str as string;
+    return "correction";
+};
+const getPropositions = (n, { answer, ..._identifiers }, _optsIn) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, randint(1, 25).frenchify());
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGeometricFindThresholdFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isWithSuperfluousData } = opts;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const initial = situation.randInitial();
+    const reason = situation.randReason();
+    const superfluousData = isWithSuperfluousData
+        ? situation.randSuperfluousData()
+        : undefined;
+    const valueThreshold = situation.randThreshold(initial, reason, firstRank);
+    const inegSymbol = InequationSymbolConstructor.randomSymbol();
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+        valueThreshold,
+        inegSymbol,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optionsStuffFirstTermRankOne = getOptionFirstTermRankOneStuff(false);
+const optionsStuffIsWithSuperfluousData = getOptionIsWithSuperfluousData(false);
+const optsDefault = Object.assign({}, optionsStuffFirstTermRankOne.optsDefaultFirstTermRankOne, optionsStuffIsWithSuperfluousData.optsDefaultIsWithSuperfluousData);
+const options = [
+    optionsStuffFirstTermRankOne.generatorOptionFirstTermRankOne,
+    optionsStuffIsWithSuperfluousData.generatorOptionIsWithSuperfluousData,
+];
+export const geometricFindThresholdFromSituation = {
+    id: "geometricFindThresholdFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution géométrique, calculer un seuil",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindThresholdFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./geometricFindExplicitFormulaFromSituation.js";
+export * from "./geometricFindRecurrenceFormulaFromSituation.js";
+export * from "./geometricFindTermFromSituation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,gDAAgD,CAAC;AAC/D,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from "./geometricFindExplicitFormulaFromSituation.js";
+export * from "./geometricFindRecurrenceFormulaFromSituation.js";
+export * from "./geometricFindTermFromSituation.js";
+// export * from "./geometricFindRankFromSituation.js";
+// export * from "./geometricFindThresholdFromSituation.js";

package/lib/exercises/math/sequences/geometric/sum/geometricComputeSumWithDots.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+};
+type Options = OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+};
+export declare const geometricComputeSumWithDots: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricComputeSumWithDots.d.ts.map

package/lib/exercises/math/sequences/geometric/sum/geometricComputeSumWithDots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricComputeSumWithDots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/sum/geometricComputeSumWithDots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AA0E3D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA6OF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC;AAiBjE,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBtE,CAAC"}