math-exercises 3.0.198 → 3.0.200

package/lib/exercises/math/primitive/constantPrimitive.js

@@ -1,66 +1,85 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { addValidProp, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Monom } from "../../../math/polynomials/monom.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
-const getInstruction = (identifiers) => {
+const getAnswerNode = (identifiers, opts) => {
     const { c } = identifiers;
-    return `Déterminer la forme générale des primitives de la fonction constante $f$ définie par : 
+    const monom = new Monom(1, c);
+    if (opts?.askParticularPrimitive)
+        return monom.toTree();
+    return new AddNode(monom.toTree(), new VariableNode("C"));
+};
+const getInstruction = (identifiers, opts) => {
+    const { c } = identifiers;
+    const isAskingParticularPrimitive = opts?.askParticularPrimitive;
+    return `${isAskingParticularPrimitive
+        ? "Déterminer une primitive en particulier de la fonction constante $f$ définie par"
+        : "Déterminer la forme générale des primitives de la fonction constante $f$ définie par"} : 
   
 $$
 f(x) = ${c}
 $$`;
 };
-const getAnswer = (identifiers) => {
-    const { c } = identifiers;
-    const monom = new Monom(1, c);
-    const answer = new AddNode(monom.toTree(), new VariableNode("C")).toTex();
-    return answer;
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
 };
-export const getConstantPrimitive = () => {
+export const getConstantPrimitive = (opts) => {
     const c = randint(-19, 20, [0]);
     const identifiers = { c };
-    return getConstantPrimitiveQuestionFromIdentifiers(identifiers);
+    return getConstantPrimitiveQuestionFromIdentifiers(identifiers, opts);
 };
-export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers) => {
+export const getConstantPrimitiveQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        instruction: getInstruction(identifiers),
+        instruction: getInstruction(identifiers, opts),
         startStatement: `F(x)`,
-        answer: getAnswer(identifiers),
-        keys: ["x", "C"],
+        answer: getAnswer(identifiers, opts),
+        keys: opts?.askParticularPrimitive ? ["x"] : ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        options: opts,
     };
     return question;
 };
-export const getConstantPrimitivePropositions = (n, { answer }) => {
+export const getConstantPrimitivePropositions = (n, { answer, c }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    const cNode = new VariableNode("C");
     propWhile(propositions, n, () => {
-        const monom = new Monom(1, randint(-9, 10, [-1, 0, 1]));
-        const wrongAnswer = new AddNode(monom.toTree(), cNode);
+        const monom = new Monom(1, randint(-9, 10, opts?.askParticularPrimitive ? [-1, 0, 1, c] : [-1, 0, 1]));
+        const wrongAnswer = opts?.askParticularPrimitive
+            ? monom.toTree()
+            : new AddNode(monom.toTree(), new VariableNode("C"));
         tryToAddWrongProp(propositions, wrongAnswer.toTex());
     });
     return shuffle(propositions);
 };
-export const isConstantPrimitiveAnswerValid = (ans, { c }) => {
-    const answer = new AddNode(new Monom(1, c).toTree(), new VariableNode("C"));
+export const isConstantPrimitiveAnswerValid = (ans, { c }, opts) => {
+    const answer = getAnswerNode({ c }, opts);
     const texs = answer.toAllValidTexs();
     return texs.includes(ans);
 };
+const options = [
+    {
+        id: "askParticularPrimitive",
+        label: "Demander une primitive en particulier",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const constantPrimitive = {
     id: "constantPrimitive",
     connector: "=",
     label: "Primitive d'une constante",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getConstantPrimitive, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getConstantPrimitive(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions: getConstantPrimitivePropositions,
     isAnswerValid: isConstantPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getConstantPrimitiveQuestionFromIdentifiers,
+    options,
 };

package/lib/exercises/math/probaStat/stats2var/averagePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

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