math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/probaStat/stats2var/averagePoint.js

@@ -3,7 +3,10 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { frenchify } from "../../../../math/utils/latex/frenchify.js";
 import { distinctRandTupleInt } from "../../../../math/utils/random/randTupleInt.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { pointParser } from "../../../../tree/parsers/pointParser.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
 import { average } from "../../../../utils/average.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
@@ -13,9 +16,9 @@ const getInstruction = ({ xValues, yValues }) => {
         ["$x$", ...xValues.map((el) => dollarize(el))],
         ["$y$", ...yValues.map((el) => dollarize(el))],
     ]);
-    return `On considère la liste de points suivante : ${tab}
+    return `On considère la liste de points de coordonnées $(x;y)$ suivante : ${tab}
   
-Déterminer les coordonnées du point moyen $G$.
+Déterminer les coordonnées du point moyen $G$ de ce nuage de points.
   `;
 };
 const getAnswer = (identifiers) => {
@@ -25,6 +28,32 @@ const getAnswer = (identifiers) => {
     const answer = `\\left(${xG};${yG}\\right)`;
     return answer;
 };
+const getHint = () => {
+    return `Le point moyen $G$ d'un nuage de points est le point de coordonnées $(x;y)$ où $x$ est la moyenne des abscisses des points du nuage, et $y$ est la moyenne des ordonnées des points du nuage. `;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const n = xValues.length;
+    const xG = frenchify(average(xValues) + "");
+    const yG = frenchify(average(yValues) + "");
+    return `On calcule la moyenne des abscisses : 
+  
+$$
+${frac(operatorComposition(AddNode, xValues.map((x) => x.toTree())), n).toTex()} = ${xG}
+$$
+
+Puis on calcule la moyenne des ordonnées : 
+
+$$
+${frac(operatorComposition(AddNode, yValues.map((x) => x.toTree())), n).toTex()} = ${yG}
+$$
+
+Le point moyen $G$ de ce nuage de points a donc pour coordonnées : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getAveragePointQuestion = () => {
     const points = distinctRandTupleInt(4, 2, { from: -9, to: 10 });
     const sortedPoints = points.sort((a, b) => a[0] - b[0]);
@@ -48,6 +77,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstRowIsHeader: false,
             },
         },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -84,4 +115,5 @@ export const averagePoint = {
     subject: "Mathématiques",
     getInstruction,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdFromGraph.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsReason: NodeIdentifiers;
+    firstRank: number;
+    nodeIdsValueThreshold: NodeIdentifiers;
+    inegSymbol: InegalitySymbols;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricFindThresholdFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindThresholdFromGraph.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindThresholdFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/geometricFindThresholdFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAO3D,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAM9C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA6B7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,eAAe,CAAC;IACvC,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA+QF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB1E,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdFromGraph.js

@@ -0,0 +1,255 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { greenMain, orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { InequationSymbol, } from "../../../../../math/inequations/inequation.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 { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.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 { random } from "../../../../../utils/alea/random.js";
+const getArrPoint = (nodeInitial, nodeReason, firstRank) => {
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return arrPoint;
+};
+const nbPoints = 10;
+const getInstruction = (identifiers) => {
+    const { nodeIdsValueThreshold, inegSymbol } = identifiers;
+    const nodeValueThreshold = NodeConstructor.fromIdentifiers(nodeIdsValueThreshold);
+    return `Dans le repère ci-dessous, on a placé les points représentant les $${nbPoints}$ premiers termes d'une suite géométrique $u$.
+
+Quel est le rang $N$, tel que pour tout $n \\geq N$, on a :
+
+$$
+u_{n} ${inegSymbol} ${nodeValueThreshold.toTex()}
+$$
+
+`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsInitial, nodeIdsReason, nodeIdsValueThreshold, firstRank, inegSymbol, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = getArrPoint(nodeInitial, nodeReason, firstRank);
+    const pointValid = arrPoint.find((point) => {
+        const inequationNode = new InequationNode([point.y, nodeValueThreshold], inegSymbol);
+        return inequationNode.isVerified();
+    });
+    return { pointValid };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).pointValid.x.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsValueThreshold } = identifiers;
+    const nodeValueThreshold = NodeConstructor.fromIdentifiers(nodeIdsValueThreshold);
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+Trace mentalement la droite d'équation $y=${nodeValueThreshold.toTex()}$ pour déterminer le rang demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsValueThreshold, inegSymbol } = identifiers;
+    const nodeValueThreshold = NodeConstructor.fromIdentifiers(nodeIdsValueThreshold);
+    const answer = getAnswer(identifiers);
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+On cherche le rang du premier terme ${(() => {
+        switch (inegSymbol) {
+            case "\\ge":
+                return `au-dessus`;
+            case ">":
+                return `strictement au-dessus`;
+            case "\\le":
+                return `en dessous`;
+            case "<":
+                return `strictement en dessous`;
+        }
+    })()} de la droite d'équation $y=${nodeValueThreshold.toTex()}$.
+
+Le rang recherché est $${answer}$.
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIdsInitial, nodeIdsReason, nodeIdsValueThreshold, firstRank } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = getArrPoint(nodeInitial, nodeReason, firstRank);
+    const values = arrPoint.map((point) => point.y.evaluate());
+    const valueThreshold = nodeValueThreshold.evaluate();
+    const { pointValid } = getAnswerStuff(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `l = Line((0,${valueThreshold}), (1, ${valueThreshold}))`,
+            `SetColor(l, "${orange}")`,
+            ...arrPoint.flatMap((point) => point.toGGBCommand({ color: `#000000`, showLabel: false })),
+            `v2 = Vector(${pointValid.toMathString()},(${pointValid.x.toMathString()},0))`,
+            `SetColor(v2, "${greenMain}")`,
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, nbPoints, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { nodeIdsInitial, nodeIdsReason, firstRank } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = getArrPoint(nodeInitial, nodeReason, firstRank);
+    const values = arrPoint.map((point) => point.y.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...arrPoint.flatMap((point) => point.toGGBCommand({ color: `#000000`, showLabel: false })),
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, nbPoints, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const indexThreshold = randint(3, 10);
+        tryToAddWrongProp(propositions, indexThreshold.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getGeometricFindThresholdFromGraphQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { isDivergent: _isDivergent, nodeInitialAbs, nodeReasonAbs, nodeValueThresholdAbs, inegSymbolAbs, } = (() => {
+        const isDivergent = coinFlip();
+        const { nodeInitialAbs, nodeReasonAbs } = (() => {
+            if (isDivergent) {
+                return {
+                    nodeInitialAbs: randfloat(1.3, 2, 2).toTree(),
+                    nodeReasonAbs: randfloat(1.15, 1.2, 3).toTree(),
+                };
+            }
+            else {
+                return {
+                    nodeInitialAbs: randfloat(7, 10, 2).toTree(),
+                    nodeReasonAbs: randfloat(0.77, 0.85, 3).toTree(),
+                };
+            }
+        })();
+        const arrPointAbs = getArrPoint(nodeInitialAbs, nodeReasonAbs, firstRank);
+        const { nodeValueThresholdAbs, inegSymbolAbs } = (() => {
+            const isValueThresholdEqualToTerm = coinFlip();
+            const nodeValueThresholdAbs = (() => {
+                const indexThresholdLow = randint(3, 8);
+                const progress = randfloat(0.3, 0.7, 1);
+                const [v1, v2] = [indexThresholdLow, indexThresholdLow + 1].map((index) => arrPointAbs[index].y.evaluate());
+                return round(v1 + (v2 - v1) * progress, 2).toTree();
+            })();
+            const inegSymbolAbs = (() => {
+                if (isDivergent) {
+                    return isValueThresholdEqualToTerm ? "\\ge" : random(["\\ge", ">"]);
+                }
+                else {
+                    return isValueThresholdEqualToTerm ? "\\le" : random(["\\le", "<"]);
+                }
+            })();
+            return { nodeValueThresholdAbs, inegSymbolAbs };
+        })();
+        return {
+            isDivergent,
+            nodeInitialAbs,
+            nodeReasonAbs,
+            nodeValueThresholdAbs,
+            inegSymbolAbs,
+        };
+    })();
+    const { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol } = (() => {
+        const signInitial = coinFlip() ? +1 : -1;
+        const nodeInitial = multiply(signInitial, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+        const nodeReason = nodeReasonAbs; //reason is always positive
+        const nodeValueThreshold = multiply(signInitial, nodeValueThresholdAbs).simplify({
+            towardsDistribute: true,
+        });
+        const inegSymbol = signInitial === +1
+            ? inegSymbolAbs
+            : new InequationSymbol(inegSymbolAbs).reversed();
+        return { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol };
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+        nodeIdsValueThreshold: nodeValueThreshold.toIdentifiers(),
+        inegSymbol: inegSymbol,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {});
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindThresholdFromGraph = {
+    id: "geometricFindThresholdFromGraph",
+    label: "À partir d'un nuage de point d'une suite géométrique, déterminer un seuil",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindThresholdFromGraphQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    isAnswerValid,
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdUsingCalculator.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsReason: NodeIdentifiers;
+    firstRank: number;
+    nodeIdsValueThreshold: NodeIdentifiers;
+    inegSymbol: InegalitySymbols;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricFindThresholdUsingCalculator: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindThresholdUsingCalculator.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdUsingCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindThresholdUsingCalculator.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/geometricFindThresholdUsingCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAI3D,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAM9C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA8B7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,qBAAqB,EAAE,eAAe,CAAC;IACvC,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA4QF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAsBR,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/geometricFindThresholdUsingCalculator.js

@@ -0,0 +1,242 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, 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 { Point } from "../../../../../math/geometry/point.js";
+import { InequationSymbol, } from "../../../../../math/inequations/inequation.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 { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.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 { random } from "../../../../../utils/alea/random.js";
+import { mdTable } from "../../../../../utils/markdown/mdTable.js";
+const getArrPoint = (nodeInitial, nodeReason, firstRank) => {
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return arrPoint;
+};
+const nbPoints = 15;
+const getInstruction = (identifiers) => {
+    const { nodeIdsValueThreshold, inegSymbol, firstRank, nodeIdsInitial, nodeIdsReason, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Soit une suite géométrique $u$ de premier terme $u_{${firstRank}}=${nodeInitial.toTex()}$ et de raison $${nodeReason.toTex()}$.
+
+À l'aide de la calculatrice, déterminer le rang $N$, tel que pour tout $n \\geq N$, on a :
+
+$$
+u_{n} ${inegSymbol} ${nodeValueThreshold.toTex()}
+$$
+
+`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsInitial, nodeIdsReason, nodeIdsValueThreshold, firstRank, inegSymbol, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrPoint = getArrPoint(nodeInitial, nodeReason, firstRank);
+    const [pointValid, indexPointValid] = arrPoint
+        .map((point, i) => [point, i])
+        .find(([point, _i]) => {
+        const inequationNode = new InequationNode([point.y, nodeValueThreshold], inegSymbol);
+        return inequationNode.isVerified();
+    });
+    return { arrPoint, pointValid, indexPointValid };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).pointValid.x.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsValueThreshold, nodeIdsInitial, nodeIdsReason, inegSymbol, firstRank, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Avec la calculatrice, à partir du menu, sélectionne le mode correspondant aux suites.
+Entre les paramètres de la suite : $u_{${firstRank}}=${nodeInitial.toTex()}$ et raison: $${nodeReason.toTex()}$.
+Demande d'afficher le tableau de valeurs.
+Cherche alors le rang du premier terme ${(() => {
+        switch (inegSymbol) {
+            case "\\ge":
+                return `supérieur ou égal`;
+            case ">":
+                return `supérieur`;
+            case "\\le":
+                return `inférieur ou égal`;
+            case "<":
+                return `inférieur`;
+        }
+    })()} à $${nodeValueThreshold.toTex()}$.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsValueThreshold, nodeIdsInitial, nodeIdsReason, inegSymbol, firstRank, } = identifiers;
+    const [nodeInitial, nodeReason, nodeValueThreshold] = [
+        nodeIdsInitial,
+        nodeIdsReason,
+        nodeIdsValueThreshold,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const { arrPoint, pointValid, indexPointValid } = getAnswerStuff(identifiers);
+    function highlighted(str) {
+        return `{ \\color{green} ${str} }`;
+    }
+    return `On cherche le rang du premier terme ${(() => {
+        switch (inegSymbol) {
+            case "\\ge":
+                return `supérieur ou égal`;
+            case ">":
+                return `supérieur`;
+            case "\\le":
+                return `inférieur ou égal`;
+            case "<":
+                return `inférieur`;
+        }
+    })()} à $${nodeValueThreshold.toTex()}$.
+
+Avec la calculatrice, à partir du menu, on sélectionne le mode correspondant aux suites.
+On entre les paramètres de la suite : $u_{${firstRank}}=${nodeInitial.toTex()}$ et raison: $${nodeReason.toTex()}$.
+On demande d'afficher le tableau de valeurs.
+On obtient alors : 
+
+${mdTable([
+        ["n", "u_{n}"],
+        ...arrPoint.map((point, i) => i === indexPointValid
+            ? [point.x.toTex(), round(point.y.evaluate(), 2).frenchify()].map((tex) => highlighted(tex))
+            : [point.x.toTex(), round(point.y.evaluate(), 2).frenchify()]),
+    ], true)}
+
+Le rang recherché est $${pointValid.x.toTex()}$.
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const indexThreshold = randint(7, 15);
+        tryToAddWrongProp(propositions, indexThreshold.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getGeometricFindThresholdUsingCalculatorQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { isDivergent: _isDivergent, nodeInitialAbs, nodeReasonAbs, nodeValueThresholdAbs, inegSymbolAbs, } = (() => {
+        const isDivergent = coinFlip();
+        const { nodeInitialAbs, nodeReasonAbs } = (() => {
+            if (isDivergent) {
+                return {
+                    nodeInitialAbs: randfloat(1, 10, 1).toTree(),
+                    nodeReasonAbs: randfloat(2, 3, 1).toTree(),
+                };
+            }
+            else {
+                return {
+                    nodeInitialAbs: randfloat(1000, 2000, 0).toTree(),
+                    nodeReasonAbs: randfloat(0.5, 0.85, 1).toTree(),
+                };
+            }
+        })();
+        const arrPointAbs = getArrPoint(nodeInitialAbs, nodeReasonAbs, firstRank);
+        const { nodeValueThresholdAbs, inegSymbolAbs } = (() => {
+            const isValueThresholdEqualToTerm = coinFlip();
+            const nodeValueThresholdAbs = (() => {
+                const indexThresholdLow = randint(8, 14);
+                const progress = randfloat(0.3, 0.7, 1);
+                const [v1, v2] = [indexThresholdLow, indexThresholdLow + 1].map((index) => arrPointAbs[index].y.evaluate());
+                return round(v1 + (v2 - v1) * progress, 2).toTree();
+            })();
+            const inegSymbolAbs = (() => {
+                if (isDivergent) {
+                    return isValueThresholdEqualToTerm ? "\\ge" : random(["\\ge", ">"]);
+                }
+                else {
+                    return isValueThresholdEqualToTerm ? "\\le" : random(["\\le", "<"]);
+                }
+            })();
+            return { nodeValueThresholdAbs, inegSymbolAbs };
+        })();
+        return {
+            isDivergent,
+            nodeInitialAbs,
+            nodeReasonAbs,
+            nodeValueThresholdAbs,
+            inegSymbolAbs,
+        };
+    })();
+    const { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol } = (() => {
+        const signInitial = coinFlip() ? +1 : -1;
+        const nodeInitial = multiply(signInitial, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+        const nodeReason = nodeReasonAbs; //reason is always positive
+        const nodeValueThreshold = multiply(signInitial, nodeValueThresholdAbs).simplify({
+            towardsDistribute: true,
+        });
+        const inegSymbol = signInitial === +1
+            ? inegSymbolAbs
+            : new InequationSymbol(inegSymbolAbs).reversed();
+        return { nodeInitial, nodeReason, nodeValueThreshold, inegSymbol };
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+        nodeIdsValueThreshold: nodeValueThreshold.toIdentifiers(),
+        inegSymbol: inegSymbol,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {});
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindThresholdUsingCalculator = {
+    id: "geometricFindThresholdUsingCalculator",
+    label: "Déterminer un seuil d'une suite géométrique en utilisant la calculatrice",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindThresholdUsingCalculatorQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    isAnswerValid,
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/sequences/geometric/graph/geometricPlaceFirstPoints.js

@@ -20,7 +20,7 @@ const getInstruction = (identifiers) => {
     const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
     const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
     return `On considère une suite géométrique $u$ de premier rang $u_{${firstRank}}=${nodeInitial.toTex()}$ et de raison $${nodeReason.toTex()}$.
-Dans le repère ci-dessous, placer les points représentant les $${nbPoints}$ premiers termes de de $u$.`;
+Dans le repère ci-dessous, placer les points représentant les $${nbPoints}$ premiers termes de $u$.`;
 };
 const getAnswerStuff = (identifiers) => {
     const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
@@ -99,7 +99,7 @@ const isGGBAnswerValid = (ans, { ggbAnswer: _ggbAnswer, ...identifiers }) => {
     return points.every((p, i) => Math.abs(p.x - validPoints[i].x.evaluate()) < 0.4 &&
         Math.abs(p.y - validPoints[i].y.evaluate()) < 0.4);
 };
-const getPlaceFirstSequencePointsQuestion = (optsIn) => {
+const getGeometricPlaceFirstPointsQuestion = (optsIn) => {
     const opts = optsIn ?? optsDefault;
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     const typeSignReason = opts?.typeSignReason
@@ -172,8 +172,8 @@ export const geometricPlaceFirstPoints = {
     label: "Placer les premiers termes d'une suite géométrique dans un repère",
     isSingleStep: true,
     generator: (nb, opts) => 
-    // getDistinctQuestions(() => getPlaceFirstSequencePointsQuestion(opts), nb),
-    [...Array(nb).keys()].map(() => getPlaceFirstSequencePointsQuestion(opts)),
+    // getDistinctQuestions(() => getGeometricPlaceFirstPointsQuestion(opts), nb),
+    [...Array(nb).keys()].map(() => getGeometricPlaceFirstPointsQuestion(opts)),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsReason: NodeIdentifiers;
+    firstRank: number;
+};
+type Options = OptionFirstTermRankOne;
+export declare const geometricSignOfReasonFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricSignOfReasonFromGraph.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricSignOfReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAM3D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,CAAC;IAChC,aAAa,EAAE,eAAe,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiKF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBzE,CAAC"}