math-exercises 3.0.191 → 3.0.193

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,oDAAoD,CAAC;AACnE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC"}

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

@@ -1 +1,4 @@
-export * from "./geometricPlaceFirstPoints.js";
+export * from "./recognizeGeometricFromGraph.js";
+export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
+export * from "./readGeometricExpressionFromGraph.js";
+export * from "./compareGeometricReasonWithOneFromGraph.js";

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    q: number;
+    start: number;
+    fakeParams: {
+        start: number;
+        q: number;
+    }[];
+};
+export declare const plausibleGeometricSequenceExpressionFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibleGeometricSequenceExpressionFromGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleGeometricSequenceExpressionFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/plausibleGeometricSequenceExpressionFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC5C,CAAC;AAyIF,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAwB7E,CAAC"}

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

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../../math/utils/round.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, fakeParams }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    for (let i = 0; i < fakeParams.length; i++) {
+        tryToAddWrongProp(propositions, multiply(fakeParams[i].start, power(fakeParams[i].q, "n")).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { start, q } = identifiers;
+    return multiply(start, power(q, "n")).toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous les premiers points d'un nuage de points représentant une suite géométrique $u$..
+
+Parmi les formes explicites suivantes, laquelle peut être celle de $u$ ?`;
+};
+const getHint = () => {
+    return `Le sens de variation de la suite peut t'aider. Si on note $q$ sa raison, alors : 
+  
+-  si $q>1$, la suite est strictement croissante;
+-  si $0<q<1$, la suite est strictement décroissante.
+  
+D'autre part, tu peux lire la valeur du premier terme de la suite.`;
+};
+const getCorrection = (identifiers) => {
+    const { q, start } = identifiers;
+    const sens = q < 1 ? "décroissante" : "croissante";
+    return `On sait que la forme explicite de la suite $u$ est de la forme :
+  
+$$
+u_n = u_0\\times q^n
+$$
+
+D'après le graphique, la suite $u$ est ${sens}. On en déduit donc que $q ${q < 1 ? "<1" : ">1"}$. Cela permet donc d'exclure deux des propositions.
+
+Ensuite, on lit le premier terme de la suite : on trouve $u_0 \\approx ${round(start, 1).frenchify()}$.
+
+On en conclut donc que la seule forme explicite possible pour $u$ est :
+
+$$
+u_n = ${getAnswer(identifiers)}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+    });
+    const f2 = multiply(start, power(q, 2)).evaluate();
+    return ggb.getOptions({
+        coords: [-1, 5, -1, Math.max(start, f2) + 1],
+    });
+};
+const getPlausibleExponentialFunctionExpressionFromGraphQuestion = () => {
+    const start = randfloat(0.5, 4, 2);
+    const q = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+    let fakeParams = [];
+    if (q > 1) {
+        const firstDescQ = randfloat(0.1, 1, 2, [1]);
+        const secondDescQ = randfloat(0.1, 1, 2, [firstDescQ]);
+        const thirdQ = randfloat(1.1, 5, 2, [q]);
+        const firstStart = start;
+        const secondStart = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdStart = round(start - delta > 0 ? start - delta : start + delta, 2);
+        fakeParams = [
+            { q: firstDescQ, start: firstStart },
+            { q: secondDescQ, start: secondStart },
+            { q: thirdQ, start: thirdStart },
+        ];
+    }
+    else {
+        const firstAscQ = randfloat(1.1, 5, 2);
+        const secondAscQ = randfloat(1.1, 5, 2, [firstAscQ]);
+        const thirdQ = randfloat(0.1, 1, 2, [1, q]);
+        const firstStart = start;
+        const secondStart = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdStart = round(start - delta > 0 ? start - delta : start + delta, 2);
+        fakeParams = [
+            { q: firstAscQ, start: firstStart },
+            { q: secondAscQ, start: secondStart },
+            { q: thirdQ, start: thirdStart },
+        ];
+    }
+    const identifiers = {
+        start,
+        q,
+        fakeParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const plausibleGeometricSequenceExpressionFromGraph = {
+    id: "plausibleGeometricSequenceExpressionFromGraph",
+    label: "Donner la forme explicite possible d'une suite géométrique à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleExponentialFunctionExpressionFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    start: number;
+    q: number;
+};
+export declare const readGeometricExpressionFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=readGeometricExpressionFromGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"readGeometricExpressionFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/readGeometricExpressionFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqHF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CA0BlE,CAAC"}

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

@@ -0,0 +1,132 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fakeStart = randint(2, 10);
+        const fakeQ = random([0.2, 0.5, 2, 3, 4, 5]);
+        tryToAddWrongProp(propositions, multiply(fakeStart, power(fakeQ, "n")).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { q, start } = identifiers;
+    return multiply(start, power(q, "n")).simplify().toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous le nuage de points d'une suite géométrique $u$.
+  
+Déterminer la forme explicite de $u$.`;
+};
+const getHint = () => {
+    return `La forme explicite d'une suite géométrique $u$ de premier terme $u_0$ et de raison $q$ est :
+
+$$
+u_n = u_0\\times q^n
+$$
+  
+Commence par lire le premier terme de la suite $u_0$.
+  
+Puis, détermine la raison de la suite en observant comment on passe d'un terme au suivant. `;
+};
+const getCorrection = (identifiers) => {
+    const { q, start } = identifiers;
+    return `On lit le premier terme de la suite : 
+
+$$
+u_0 = ${start.frenchify()}
+$$
+
+Puis, on détermine la raison de la suite. Pour cela, on remarque que : 
+
+$$
+u_1 = ${round(start * q, 2).frenchify()}
+$$
+
+Pour passer de $u_0$ à $u_1$, on a donc multiplié par $${q.frenchify()}$ : c'est la raison de la suite.
+
+La forme explicite de $u$ est donc : 
+
+$$
+u_n = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: [-1, 5, -1, 1.2 * Math.max(start, q * start, q * q * start)],
+    });
+};
+const getKeys = () => {
+    return ["n"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadExponentialFunctionParamsOnGraphQuestion = () => {
+    const [start, q] = random([
+        [random([2, 4, 6, 8]), 0.5],
+        [random([0.2, 1, 2, 3, 4, 5]), 2],
+        [random([0.5, 2]), 3],
+    ]);
+    const identifiers = {
+        start,
+        q,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const readGeometricExpressionFromGraph = {
+    id: "readGeometricExpressionFromGraph",
+    connector: "=",
+    label: "Déterminer la forme explicite d'une suite géométrique à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadExponentialFunctionParamsOnGraphQuestion(opts), nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 10,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    isGeo: boolean;
+    sequence: number[];
+};
+type Options = {
+    firstTermRankOne?: boolean;
+};
+export declare const recognizeGeometricFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=recognizeGeometricFromGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeGeometricFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/recognizeGeometricFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA8IF,KAAK,OAAO,GAAG;IACb,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AASF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBtE,CAAC"}

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

@@ -0,0 +1,137 @@
+import { GeneratorOptionTarget, GeneratorOptionType, 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 { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+const getInstruction = () => {
+    return `La suite $u$ représentée ci-dessous semble-t-elle géométrique ?`;
+};
+const getAnswer = (identifiers) => {
+    const { isGeo } = identifiers;
+    return isGeo ? "Oui" : "Non";
+};
+const getGGBOptions = (identifiers, opts) => {
+    const { sequence } = identifiers;
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
+    const commands = sequence.flatMap((nb, index) => new Point(`A_{${index + rankOne}}`, (index + rankOne).toTree(), nb.toTree()).toGGBCommand({
+        showLabel: false,
+    }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        xAxis: { natural: true },
+    });
+    const yMin = Math.min(...sequence.slice(0, 5));
+    const yMax = Math.max(...sequence.slice(0, 5));
+    return ggb.getOptions({
+        coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
+    });
+};
+const getHint = () => {
+    return `Une suite est géométrique si, pour passer d'un terme au suivant, on multiplie toujours par le même nombre (appelé la raison de la suite).
+
+Sur le graphique, retrouve-t-on ce comportement ?`;
+};
+const getCorrection = (identifiers, opts) => {
+    const rankOne = opts?.firstTermRankOne ? 1 : 0;
+    const { isGeo, sequence } = identifiers;
+    const reason = round(sequence[1] / sequence[0], 2);
+    return `On peut lire graphiquement les premiers termes de la suite : 
+  
+${sequence
+        .slice(0, 5)
+        .map((e, i) => `$$
+u_{${i + rankOne}} = ${e.frenchify()}
+$$`)
+        .join("\n \n")}
+  
+${isGeo
+        ? `Sur ces premiers termes, on multiple donc par $${reason.frenchify()}$ pour passer d'un terme à l'autre. La suite semble donc bien géométrique.`
+        : "Puisqu'on ne multiplie pas toujours par le même nombre pour passer d'un terme à l'autre, la suite n'est donc pas géométrique."}`;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const getRandomFirstNonGeoTerms = () => {
+    const type = randint(0, 3);
+    switch (type) {
+        case 0: {
+            const firstAriTerm = randint(-5, 10);
+            const ariReason = randint(-4, 6, [0]);
+            return new Array(10)
+                .fill(0)
+                .map((_el, index) => firstAriTerm + ariReason * index);
+        }
+        case 1: {
+            const firstBernoulliTerm = randint(1, 10);
+            const secondBernoulliTerm = randint(1, 10, [firstBernoulliTerm]);
+            return new Array(10)
+                .fill(0)
+                .map((_el, index) => index % 2 ? firstBernoulliTerm : secondBernoulliTerm);
+        }
+        case 2:
+        default: {
+            const firstFakeAriTerm = randint(1, 20);
+            const res = new Array(10)
+                .fill(0)
+                .map(() => firstFakeAriTerm + randint(1, 4));
+            const disruptionIndex = randint(0, 5);
+            res[disruptionIndex] = res[disruptionIndex] + random([-1, 1]);
+            return res;
+        }
+    }
+};
+const getRecognizeArithmeticFromGraphQuestion = (opts) => {
+    const isGeo = coinFlip();
+    const firstGeoTerm = randint(1, 4);
+    const geoReason = random([0.5, 2, 3]);
+    const sequence = isGeo
+        ? new Array(10)
+            .fill(0)
+            .map((_el, index) => firstGeoTerm * geoReason ** index)
+        : getRandomFirstNonGeoTerms();
+    const identifiers = { sequence, isGeo };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const options = [
+    {
+        id: "firstTermRankOne",
+        label: "Utiliser $u_1$ comme premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+    },
+];
+export const recognizeGeometricFromGraph = {
+    id: "recognizeGeometricFromGraph",
+    label: "Reconnaître graphiquement si une suite est géométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRecognizeArithmeticFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

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

@@ -15,4 +15,5 @@ export * from "./situations/index.js";
 export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
 export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
+export * from "./graph/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,0CAA0C,CAAC;AAEzD,cAAc,gBAAgB,CAAC;AAE/B,cAAc,uBAAuB,CAAC;AAEtC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,qDAAqD,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;AAEtC,cAAc,+CAA+C,CAAC;AAC9D,cAAc,0DAA0D,CAAC;AACzE,cAAc,qDAAqD,CAAC;AACpE,cAAc,kBAAkB,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./situations/index.js";
 export * from "./geometricFindExplicitFormulaFromTwoTerms.js";
 export * from "./geometricFindExplicitFormulaFromTwoConsecutiveTerms.js";
 export * from "./geometricFindRandomTermFromTwoConsecutiveTerms.js";
+export * from "./graph/index.js";

package/lib/index.d.ts

@@ -1257,6 +1257,9 @@ declare const mathExercises: (Exercise<{
 }, {
     method: string;
 }> | Exercise<{
+    coeffs: number[];
+    isAskingX: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
@@ -1968,6 +1971,21 @@ declare const mathExercises: (Exercise<{
     yIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     zIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     tIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situation: number;
+    start: number;
+    reason: number;
+    x: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situation: number;
+    start: number;
+    rate: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situation: number;
+    start: number;
+    rate: number;
+    x: number;
+    displayedX: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     affine1Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
     affine2Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
@@ -3228,6 +3246,12 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     isJustified: boolean;
     cloudPointsIdentifiers: import("./math/geometry/CloudPoints.js").CloudPointsIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xs: number[];
+    ys: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xs: number[];
+    ys: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     pA: number;
     pB: number;
@@ -3769,6 +3793,24 @@ declare const mathExercises: (Exercise<{
     precisionReason: number;
     rankAsked: number;
 }, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    isGeo: boolean;
+    sequence: number[];
+}, {
+    firstTermRankOne?: boolean;
+}> | Exercise<{
+    q: number;
+    start: number;
+    fakeParams: {
+        start: number;
+        q: number;
+    }[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    start: number;
+    q: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    q: number;
+    start: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     rank: number;
     coeffs: number[];
 }, {
@@ -4385,32 +4427,9 @@ declare const mathExercises: (Exercise<{
     values: number[][];
     caseAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    labels: string[];
-    data: number[];
-    itemAsked: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    isAskingX: boolean;
-    xValue?: number;
-    yValue?: number;
-    a: number;
-    b: number;
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    points: number[][];
-    labels: string[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartiles: number[];
-    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
-    typeQ: "below" | "between" | "above";
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartileIndex: 0 | 1 | 2 | 3 | 4;
-    quartiles: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    indexTopic: number;
-    isLess: boolean;
-    arrDistrib: {
-        name: string;
-        indicators: number[];
-    }[];
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     barChart: {
         description: string;
@@ -4450,6 +4469,19 @@ declare const mathExercises: (Exercise<{
 }, {
     displayType: string;
 }> | Exercise<{
+    labels: string[];
+    data: number[];
+    itemAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isAskingX: boolean;
+    xValue?: number;
+    yValue?: number;
+    a: number;
+    b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    points: number[][];
+    labels: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     bigNumber: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -4462,6 +4494,20 @@ declare const mathExercises: (Exercise<{
     evolutionType: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartileIndex: 0 | 1 | 2 | 3 | 4;
+    quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartiles: number[];
+    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
+    typeQ: "below" | "between" | "above";
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    indexTopic: number;
+    isLess: boolean;
+    arrDistrib: {
+        name: string;
+        indicators: number[];
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     maxOrScam: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.191",
+  "version": "3.0.193",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [