math-exercises 3.0.180 → 3.0.182

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

@@ -4,7 +4,7 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 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 { EqualNode } 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";
@@ -122,34 +122,46 @@ const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
-    const opts = optsIn ?? optsDefault;
+const isAnswerValid = (ans, { answer }) => {
     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)) {
+        const splitted = ans.split("=");
+        const studentAns = splitted[1] ?? ans;
+        const parsed = parseAlgebraic(studentAns);
+        if (!parsed)
             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();
+        return parsed.simplify().toTex() === answer.split("=")[1];
+        //!ROBIN : tout commenté car ne passent pas les tests
+        // 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].every((n) => {
+        //     return (
+        //       substract(
+        //         nodeAnsRhs.evaluate({ n }),
+        //         nodeAnswerRhs.evaluate({ n }),
+        //       ).evaluate() === 0
+        //     );
+        //   });
+        // };
+        // return isValidLhs() && isValidRhs();
     }
     catch (e) {
         handleVEAError(e);

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

@@ -9,10 +9,7 @@ export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.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";
 //# 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,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;AAEzC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,0CAA0C,CAAC;AACzD,cAAc,qDAAqD,CAAC;AAEpE,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,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;AAEzC,cAAc,0CAA0C,CAAC;AAEzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC"}

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

@@ -9,9 +9,9 @@ export * from "./geometricFindTerm.js";
 export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.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";
+// export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
+// export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
+// export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";

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

@@ -121,7 +121,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         const isValidRhs = () => {
             const nodeAnsRhs = nodeAns.rightChild;
             const nodeAnswerRhs = nodeAnswer.rightChild;
-            return [0, 1, 2, 10].every((n) => {
+            return [0, 1, 2, 3].every((n) => {
                 return (substract(nodeAnsRhs.evaluate({ n }), nodeAnswerRhs.evaluate({ n })).evaluate() === 0);
             });
         };

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

@@ -1,4 +1,3 @@
-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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,kDAAkD,CAAC;AACjE,cAAc,qCAAqC,CAAC"}

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

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

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

@@ -1,12 +1,12 @@
 export * from "./arithmetic/index.js";
 export * from "./geometric/index.js";
 export * from "./explicitFormulaUsage.js";
-export * from "./genericSequenceVariations.js";
 export * from "./recurrenceFormulaUsage.js";
 export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
 export * from "./seqArithmGeom/index.js";
+export * from "./limits/index.js";
 export * from "./variations/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}

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

@@ -1,12 +1,11 @@
 export * from "./arithmetic/index.js";
 export * from "./geometric/index.js";
 export * from "./explicitFormulaUsage.js";
-export * from "./genericSequenceVariations.js";
 export * from "./recurrenceFormulaUsage.js";
 export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
 export * from "./seqArithmGeom/index.js";
-// export * from "./limits/index.js";
+export * from "./limits/index.js";
 export * from "./variations/index.js";

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

@@ -1,2 +1,3 @@
-export {};
+export * from "./sequenceLimitReading.js";
+export * from "./readSequenceConvergencyType.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/index.ts"],"names":[],"mappings":""}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC"}

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

@@ -1,2 +1,2 @@
-export {};
-// export * from "./sequenceLimitReading.js";
+export * from "./sequenceLimitReading.js";
+export * from "./readSequenceConvergencyType.js";

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    type: number;
+    formulaIds: NodeIdentifiers;
+};
+export declare const readSequenceConvergencyType: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=readSequenceConvergencyType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readSequenceConvergencyType.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/readSequenceConvergencyType.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AAoRF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

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

@@ -0,0 +1,256 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.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 { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } 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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["Limite finie", "Limite infinie", "Pas de limite"].forEach((prop) => {
+        tryToAddWrongProp(propositions, prop, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return ["Limite finie", "Limite infinie", "Pas de limite"][identifiers.type];
+};
+const getInstruction = () => {
+    return `On considère une suite $u$ représentée graphiquement ci-dessous.
+    
+Conjecturer le comportement de $u$ lorsque $n$ tend vers $+\\infty$ : admet-elle une limite finie, une limite infinie, ou bien semble-t-elle ne pas avoir de limite ?`;
+};
+const getHint = () => {
+    return `Observe les termes de la suite lorsque $n$ devient très grand. 
+    
+Si ces termes semblent se rapprocher autant que l'on veut d'une certaine valeur, alors on peut conjecturer que la suite admet une limite finie.
+    
+Si ces termes semblent devenir aussi grands ou aussi petits que l'on veut, alors on peut conjecturer que la suite admet une limite infinie.
+
+Sinon, on peut conjecturer que la suite n'a pas de limite.`;
+};
+const getLimit = (identifiers) => {
+    const { formulaIds, type } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    switch (type) {
+        case 0:
+        default:
+            return round(formula.toDetailedEvaluation({ n: (10).toTree() }).evaluate(), 0);
+        case 1: {
+            const pos = formula.toDetailedEvaluation({ n: (10).toTree() }).evaluate() > 0;
+            return pos ? "+\\infty" : "-\\infty";
+        }
+        case 2:
+            return null;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { type } = identifiers;
+    const limit = getLimit(identifiers);
+    let corr = `On observe les termes de la suite lorsque $n$ devient très grand : c'est à dire qu'on observe les ordonnées des points qui ont une abscisse très grande.
+  
+`;
+    switch (type) {
+        case 0:
+            corr += `Les termes semblent se rapprocher autant que l'on veut de $${limit}$. On peut donc conjecturer que la suite $u$ a une limite finie : 
+    
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${limit}
+$$`;
+            break;
+        case 1:
+            corr += `Les termes semblent devenir aussi ${limit === "+\\infty" ? "grands" : "petits"} que l'on veut. On peut donc conjecturer que la suite $u$ a une limite infinie : 
+    
+$$
+\\lim_{n \\to +\\infty} u_{n} = ${limit}
+$$`;
+            break;
+        case 2:
+            corr += `Les termes ne semblent pas se rapprocher autant que l'on veut d'une valeur finie, ni devenir aussi grands ou aussi petits que l'on veut. On peut donc conjecturer que la suite $u$ n'a pas de limite.`;
+            break;
+    }
+    return corr;
+};
+const getGGBOptions = (identifiers) => {
+    const { formulaIds } = identifiers;
+    const formula = reifyAlgebraic(formulaIds);
+    console.log(formula.toTex());
+    const points = Array.from({ length: 50 }).map((_, index) => {
+        return new Point(`A_{${index}}`, index, formula.toDetailedEvaluation({ n: index.toTree() }).evaluate());
+    });
+    const yMin = Math.min(Math.min(...points.slice(0, 10).map((p) => p.y.evaluate())) - 2, -2);
+    const yMax = Math.max(Math.max(...points.slice(0, 10).map((p) => p.y.evaluate())) + 2, 2);
+    const ggb = new GeogebraConstructor({
+        commands: points.flatMap((point) => point.toGGBCommand({
+            showLabel: false,
+            isFixed: true,
+            isSelectionnable: false,
+            size: 3,
+        })),
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    return ggb.getOptions({
+        coords: [-1, 15, yMin, yMax],
+    });
+};
+const getReadSequenceConvergencyTypeQuestion = () => {
+    const type = randint(0, 3);
+    //type0 limites finies :
+    //1/n+k , an+b/cn+d, q^n avec q<1, exp(-kx)
+    //type1 limites infinie :
+    //affine, trinom, q^n avec q>1, exp(kx)
+    //
+    //type2 pas de limite:
+    //(-1)^n, trigo, anarchie totale
+    let formulaIds;
+    switch (type) {
+        case 0: {
+            const subtype = randint(0, 4);
+            switch (subtype) {
+                case 0: {
+                    //1/(n+1)+k
+                    const k = randint(-5, 5);
+                    formulaIds = add(frac(1, add("n", 1)), k).toIdentifiers();
+                    break;
+                }
+                case 1: {
+                    //an+b/cn+d
+                    const c = randint(-5, 5, [0]);
+                    const a = c * randint(-5, 5, [0]);
+                    const b = randint(-5, 5, [0]);
+                    const d = doWhile(() => randint(-5, 5, [0]), (x) => c / a === x / b || (Math.floor(-x / c) === -x / c && -x / c > 0));
+                    formulaIds = frac(add(multiply(a, "n"), b), add(multiply(c, "n"), d)).toIdentifiers();
+                    break;
+                }
+                case 2: {
+                    //aq^n q<1
+                    const q = randfloat(0.1, 0.9, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, power(q, "n")).toIdentifiers();
+                    break;
+                }
+                case 3:
+                default: {
+                    //aexp(-kx)
+                    const k = randfloat(0.1, 0.9, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, exp(multiply(-k, "n"))).toIdentifiers();
+                    break;
+                }
+            }
+            break;
+        }
+        case 1: {
+            const subtype = randint(0, 4);
+            switch (subtype) {
+                case 0: {
+                    //affine
+                    const affine = AffineConstructor.random(undefined, undefined, "n").toTree();
+                    formulaIds = affine.toIdentifiers();
+                    break;
+                }
+                case 1: {
+                    //trinom
+                    const trinom = TrinomConstructor.random(undefined, undefined, undefined, "n").toTree();
+                    formulaIds = trinom.toIdentifiers();
+                    break;
+                }
+                case 2: {
+                    //q^n
+                    const q = randfloat(1.1, 1.4, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, power(q, "n")).toIdentifiers();
+                    break;
+                }
+                case 3:
+                default: {
+                    //aexp(kx)
+                    const k = randfloat(1.1, 1.4, 2);
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, exp(multiply(k, "n"))).toIdentifiers();
+                    break;
+                }
+            }
+            break;
+        }
+        case 2:
+        default: {
+            //(-1)^n, trigo, anarchie totale
+            const subtype = randint(0, 2);
+            switch (subtype) {
+                case 0: {
+                    //a(-1)^n
+                    const a = randint(-5, 5, [0]);
+                    formulaIds = multiply(a, power(-1, "n")).toIdentifiers();
+                    break;
+                }
+                case 1:
+                default: {
+                    //trigo acos(bt+c)
+                    const fct = coinFlip() ? cos : sin;
+                    const a = randint(-5, 5, [0]);
+                    const b = randint(-5, 5, [0]);
+                    const c = randint(-5, 5);
+                    formulaIds = multiply(a, fct(add(multiply(b, "n"), c))).toIdentifiers();
+                    break;
+                }
+                // case 2: {
+                //   //anarchie totale
+                //   formulaIds = "n".toIdentifiers();
+                //   break;
+                // }
+            }
+            break;
+        }
+    }
+    const identifiers = {
+        type,
+        formulaIds,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const readSequenceConvergencyType = {
+    id: "readSequenceConvergencyType",
+    label: "Conjecturer graphiquement le type de limite d'une suite",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadSequenceConvergencyTypeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -1,2 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    type: number;
+    formulaIds: NodeIdentifiers;
+};
+export declare const sequenceLimitReading: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=sequenceLimitReading.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sequenceLimitReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/sequenceLimitReading.ts"],"names":[],"mappings":""}
+{"version":3,"file":"sequenceLimitReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/limits/sequenceLimitReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AAsPF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAsBtD,CAAC"}