math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/probaStat/tchebychev/tchebychevMinorizeProbaOfXInCenteredInterval.js

@@ -0,0 +1,155 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsA } = identifiers;
+    const [nodeE, nodeV, nodeA] = [nodeIdsE, nodeIdsV, nodeIdsA].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("X");
+    const nodeBoundLow = substract(nodeE, nodeA).simplify();
+    const nodeBoundHigh = add(nodeE, nodeA).simplify();
+    const texPWithinBounds = `P( ${nodeBoundLow.toTex()} < ${nodeVarX.toTex()} < ${nodeBoundHigh.toTex()} )`;
+    const nodeErrorMin = frac(nodeV, square(nodeA));
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        texPWithinBounds,
+        nodeErrorMin,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPWithinBounds } = getHydrated(identifiers);
+    return `Soit $X$ une variable aléatoire d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. 
+À l'aide du théorème de Bienaymé-Tchebychev, donner une minoration de $${texPWithinBounds}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeErrorMin } = getHydrated(identifiers);
+    return nodeErrorMin.simplify().toTex();
+};
+const getHint = () => {
+    const nodeE = new VariableNode("E(Y)");
+    const nodeV = new VariableNode("V(Y)");
+    const nodeA = new VariableNode("a");
+    const nodeVarY = new VariableNode("Y");
+    const nodeBoundLow = substract(nodeE, nodeA);
+    const nodeBoundHigh = add(nodeE, nodeA);
+    const texPWithinBounds = `P( ${nodeBoundLow.toTex()} < ${nodeVarY.toTex()} < ${nodeBoundHigh.toTex()} )`;
+    const nodeLhs = abs(substract(nodeVarY, nodeE).simplify());
+    const texPOutside = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const texPInside = `P( ${nodeLhs.toTex()} < ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, square(nodeA));
+    return `Soit $Y$ une variable aléatoire. Soit $a$ un réel strictement positif.
+
+D'après le théorème de Bienaymé-Tchebychev :
+
+${alignTex([
+        [texPOutside, "\\leq", nodeErrorMax.toTex()],
+        [`1 - ${texPOutside}`, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+        [texPInside, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+        [texPWithinBounds, `\\geq`, `1 - ${nodeErrorMax.toTex()}`],
+    ])}
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeA, nodeE, texPWithinBounds, nodeErrorMin } = getHydrated(identifiers);
+    const nodeVarX = new VariableNode("X");
+    const nodeLhs = abs(substract(nodeVarX, nodeE).simplify());
+    const texPInside = `P( ${nodeLhs.toTex()} < ${nodeA.toTex()} )`;
+    return `D'après le théorème de Bienaymé-Tchebychev :
+
+${alignTex([
+        [
+            `P( \\lvert X - E(X) \\rvert \\geq ${nodeA.toTex()})`,
+            `\\leq`,
+            `\\frac{V(X)}{${square(nodeA).toTex()}}`,
+        ],
+        [
+            `1 - P( \\lvert X - E(X) \\rvert \\geq ${nodeA.toTex()})`,
+            `\\geq`,
+            `1 - \\frac{V(X)}{${square(nodeA).toTex()}}`,
+        ],
+        [texPInside, `\\geq`, nodeErrorMin.toTex()],
+        [texPWithinBounds, `\\geq`, nodeErrorMin.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodeA = randint(2, Math.ceil(3 * nodeV.evaluate())).toTree();
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsA: nodeA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevMinorizeProbaOfXInCenteredIntervalQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const tchebychevMinorizeProbaOfXInCenteredInterval = {
+    id: "tchebychevMinorizeProbaOfXInCenteredInterval",
+    label: "Utiliser le théorème de Bienaymé Tchebychev pour donner une minoration de la probabilité de tomber dans un intervalle centré sur l'espérance",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevMinorizeProbaOfXInCenteredIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.d.ts

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

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTreeBernoulli.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/buildTreeBernoulli.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA4HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}

package/lib/exercises/math/probaStat/trees/buildTreeBernoulli.js

@@ -0,0 +1,124 @@
+import { treeTableVEA } from "../../../../exercises/vea/treeTableVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { n, nodeIdsProba } = identifiers;
+    const nodeProba = NodeConstructor.fromIdentifiers(nodeIdsProba);
+    return {
+        n,
+        nodeProba,
+    };
+};
+const getAnswerTreeTable = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    const arrBranch = [
+        [`${nodeProba.toTex()}`, "S"],
+        [`${substract(1, nodeProba).simplify().toTex()}`, "\\overline{S}"],
+    ];
+    return [
+        [arrBranch],
+        [arrBranch, arrBranch],
+        [arrBranch, arrBranch, arrBranch, arrBranch],
+    ].slice(0, n);
+};
+const getInstruction = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    return `Donner l'arbre qui représente un schéma de Bernoulli de paramètres $${n.frenchify()}$ et $${nodeProba.toTex()}$.`;
+};
+const getHint = () => {
+    return `Dans une épreuve de Bernoulli, les probabilités des $2$ seules issues possibles (succès $S$ et échec $\\overline{S}$) sont respectivement $p$ et $1-p$.
+
+Un schéma de Bernoulli de paramètres $n$ et $p$ est la répétitions de $n$ épreuves de Bernoulli identiques et indépendantes (toutes ayant la même probabilité de succès $p$).
+
+Commence donc par réprésenter les branches correspondant à la première épreuve, puis celles de la deuxième à partir des branches de la première, etc.`;
+};
+const getCorrection = (identifiers) => {
+    const { n, nodeProba } = getHydrated(identifiers);
+    return `Puisque c'est la même épreuve que l'on réalise $${n.frenchify()}$ fois, l'arbre va comporter un motif qui va se répéter.
+
+Ce motif est constitué des $2$ branches correspondant l'épreuve de Bernoulli : 
+  
+- la branche de l'issue succès $S$ avec une probabilité de $${nodeProba.toTex()}$
+- la branche de l'issue échec $\\overline{S}$ avec une probabilité de $${substract(1, nodeProba)
+        .simplify()
+        .toTex()}$
+
+On inscrit ce motif $1$ fois pour la première épreuve, 
+$2$ fois pour la deuxième épreuve (car la première épreuve a $2$ issues), 
+$4$ fois pour la troisième épreuve (car la séquence "première épreuve puis deuxième épreuve" a $4$ issues), ..., $2^{k-1}$ fois pour la $k$-ième épreuve.`;
+};
+const getKeys = (_identifiers) => {
+    return ["S", "overlineS"];
+};
+const isAnswerTreeTableValid = (ans, { answerTreeTable }) => {
+    try {
+        return treeTableVEA(ans, answerTreeTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getBuildTreeBernoulliQuestion = () => {
+    const n = coinFlip() ? 2 : 3;
+    const nodeProba = randfloat(0.2, 0.8, 1).toTree();
+    const identifiers = {
+        n,
+        nodeIdsProba: nodeProba.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { n } = identifiers;
+    return {
+        answerTreeTable: getAnswerTreeTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTreeTable: (() => {
+            const arrBranch = [
+                ["", ""],
+                ["", ""],
+            ];
+            switch (n) {
+                case 2: {
+                    return [[arrBranch], [arrBranch, arrBranch]];
+                }
+                case 3: {
+                    return [
+                        [arrBranch],
+                        [arrBranch, arrBranch],
+                        [arrBranch, arrBranch, arrBranch, arrBranch],
+                    ];
+                }
+                default: {
+                    throw new Error("Unsupported n: " + n);
+                }
+            }
+        })(),
+    };
+};
+export const buildTreeBernoulli = {
+    id: "buildTreeBernoulli",
+    label: "Donner l'arbre qui permet de représenter un schéma de Bernoulli de paramètres $n$ et $p$ (decontextualisé)",
+    isSingleStep: true,
+    generator: (nb, opts) => 
+    // getDistinctQuestions(() => getBuildTreeBernoulliQuestion(opts), nb),
+    [...Array(nb).keys()].map(() => getBuildTreeBernoulliQuestion(opts)),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTreeTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTreeTable,
+    getQuestionFromIdentifiers,
+    answerType: "treeDiagram",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/trees/index.d.ts

@@ -2,4 +2,5 @@ export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProba
 export * from "./fillProbaTreeWithComplementaryProbabilities.js";
 export * from "./buildTreeFromSituation.js";
 export * from "./probaTreeSituationTotalProbaFormula.js";
+export * from "./buildTreeBernoulli.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/trees/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,sBAAsB,CAAC;AAC9B,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,sBAAsB,CAAC;AAC9B,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC;AACzD,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/probaStat/trees/index.js

@@ -2,3 +2,4 @@ export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProba
 export * from "./fillProbaTreeWithComplementaryProbabilities.js";
 export * from "./buildTreeFromSituation.js";
 export * from "./probaTreeSituationTotalProbaFormula.js";
+export * from "./buildTreeBernoulli.js";

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"}