math-exercises 2.2.77 → 2.2.79

package/lib/exercises/math/sampling/fluctuationInterval.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fluctuationInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+const intervalParser_1 = require("../../../tree/parsers/intervalParser");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const alignTex_1 = require("../../../utils/latex/alignTex");
+const getPropositions = (nb, { answer, n, p, wordingType }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < nb) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer({
+            n: (0, coinFlip_1.coinFlip)() ? n : 50 * (0, randint_1.randint)(1, 20),
+            p: (0, coinFlip_1.coinFlip)() ? p : (0, randfloat_1.randfloat)(0.2, 0.8, 2),
+            wordingType,
+        }));
+    }
+    return (0, exercise_1.shuffleProps)(propositions, nb);
+};
+const getAnswer = (identifiers) => {
+    //p-1/sqrt(n), p+1/sqrt(n)
+    const { p, n } = identifiers;
+    const oneOverSqrt = 1 / Math.sqrt(n);
+    const a = (0, round_1.round)(p - oneOverSqrt, 2);
+    const b = (0, round_1.round)(p + oneOverSqrt, 2);
+    return new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure_1.ClosureType.FF).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { p, n } = identifiers;
+    const pPercent = (0, round_1.round)(p * 100, 1);
+    switch (identifiers.wordingType) {
+        case 1:
+            return `Une urne opaque contient $${pPercent}\\%$ de boules rouges. On effectue $${n}$ tirages avec remise. On note $f$ la fréquence des boules rouges tirées. Au seuil de $95\\%$, à quel intervalle devrait appartenir $f$ ? Arrondir les données au centième.`;
+        case 2:
+            return `Une loterie contient $${pPercent}\\%$ de tickets gagnants. Un joueur achète $${n}$ tickets. On note $f$ la fréquence des tickets gagnants achetés par le joueur. Au seuil de $95\\%$, à quel intervalle devrait appartenir $f$ ? Arrondir les données au centième.`;
+        case 3:
+        default:
+            return `Un fabricant prétend que $${pPercent}\\%$ de ses produits sont recyclables. Dans un contrôle qualité sur un échantillon de $${n}$ produits, quel sera l'intervalle probable pour la fréquence observée de produits recyclables, avec un seuil de confiance de 99% ?`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Si $p$ est la proportion théorique et $n$ est la taille de l'échantillon, alors l'intervalle de fluctuation au seuil de $95\\%$ est : 
+  
+$$
+\\left[p-\\frac{1}{\\sqrt{n}}; p+\\frac{1}{\\sqrt{n}}\\right]
+$$
+
+Cela signifie que dans $95\\%$ des cas, la fréquence $f$ observée est comprise entre $p-\\frac{1}{\\sqrt{n}}$ et $p+\\frac{1}{\\sqrt{n}}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { p, n } = identifiers;
+    const pPercent = (0, round_1.round)(p * 100, 1);
+    const answer = getAnswer(identifiers);
+    const a = (0, substractNode_1.substract)(p, (0, fractionNode_1.frac)(1, (0, sqrtNode_1.sqrt)(n))).toTex();
+    const b = (0, addNode_1.add)(p, (0, fractionNode_1.frac)(1, (0, sqrtNode_1.sqrt)(n))).toTex();
+    return `La proportion théorique $p$ est $p = ${p.frenchify()}$. La taille de l'échantillon $n$ est $n = ${n.frenchify()}$.
+
+On sait que l'intervalle de fluctuation au seuil de $95\\%$ est : 
+  
+$$
+\\left[p-\\frac{1}{\\sqrt{n}}; p+\\frac{1}{\\sqrt{n}}\\right]
+$$
+
+Dans $95\\%$ des cas, on peut donc affirmer que la fréquence $f$ observée devrait appartenir à l'intervalle : 
+
+${(0, alignTex_1.alignTex)([
+        ["", `\\left[ ${a} ; ${b} \\right]`],
+        ["=", answer],
+    ])}  
+  `;
+};
+const getKeys = (identifiers) => {
+    return ["lbracket", "semicolon", "rbracket"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = (0, intervalParser_1.intervalParser)(ans);
+        if (!parsed)
+            return false;
+        return parsed.toTex() === answer;
+    }
+    catch (err) {
+        return false;
+    }
+};
+const getFluctuationIntervalQuestion = (ops) => {
+    const p = (0, randfloat_1.randfloat)(0.2, 0.8, 2);
+    const n = 50 * (0, randint_1.randint)(1, 20);
+    const identifiers = {
+        p,
+        n,
+        wordingType: (0, randint_1.randint)(1, 4),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.fluctuationInterval = {
+    id: "fluctuationInterval",
+    connector: "=",
+    label: "Déterminer l'intervalle de fluctuation au seuil de $95\\%$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getFluctuationIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,4 @@
+export * from "./fluctuationInterval";
+export * from "./confidenceInterval";
+export * from "./isSamplingRepresentative";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC"}

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

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fluctuationInterval"), exports);
+__exportStar(require("./confidenceInterval"), exports);
+__exportStar(require("./isSamplingRepresentative"), exports);

package/lib/exercises/math/sampling/isSamplingRepresentative.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    p: number;
+    k: number;
+    n: number;
+    isRepresentative: boolean;
+    wordingType: number;
+};
+export declare const isSamplingRepresentative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isSamplingRepresentative.d.ts.map

package/lib/exercises/math/sampling/isSamplingRepresentative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSamplingRepresentative.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/isSamplingRepresentative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,OAAO,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4GF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}

package/lib/exercises/math/sampling/isSamplingRepresentative.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSamplingRepresentative = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const coinFlip_1 = require("../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.isRepresentative ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { p, k, n, wordingType } = identifiers;
+    switch (wordingType) {
+        case 1:
+            return `La fréquence des yeux bleus en France est d'environ $${p.frenchify()}$. On a prélevé un échantillon de $${n}$ individus dont $${k}$ ont les yeux bleus. Cet échantillon est-il représentatif de la population pour ce caractère ?`;
+        case 2:
+            return `La proportion de français possédant un animal de compagnie est d'environ $${p.frenchify()}$. On a prélevé un échantillon de $${n}$ individus dont $${k}$ possèdent un animal de compagnie. Cet échantillon est-il représentatif de la population pour ce caractère ?`;
+        case 3:
+        default:
+            return `La proportion de français lisant au moins un livre par an est d'environ $${p.frenchify()}$. On a prélevé un échantillon de $${n}$ individus dont $${k}$ lisent au moins un livre par an. Cet échantillon est-il représentatif de la population pour ce caractère ?`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Déterminer l'intervalle de fluctuation au seuil de $95\\%$ : 
+  
+$$
+\\left[p-\\frac{1}{\\sqrt{n}}; p+\\frac{1}{\\sqrt{n}}\\right]
+$$
+
+où $p$ est la proportion théorique et $n$ est la taille de l'échantillon.	
+
+Si la fréquence $f$ observée est comprise dans cet intervalle, alors l'échantillon est représentatif de la population pour ce caractère, au seuil de $95\\%$.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { p, n, k } = identifiers;
+    return `L'échantillon est représentatif si la fréquence $f$ observée est comprise dans l'intervalle de fluctuation.
+  
+On détermine l'intervalle de fluctuation au seuil de $95\\%$ : 
+  
+$$
+\\left[p-\\frac{1}{\\sqrt{n}}; p+\\frac{1}{\\sqrt{n}}\\right] \\approx \\left[${(0, round_1.round)(p - 1 / Math.sqrt(n), 2).frenchify()} ; ${(0, round_1.round)(p + 1 / Math.sqrt(n), 2).frenchify()} \\right]
+$$
+
+Puis, on calcule la fréquence $f$ observée : 
+
+$$
+f = \\frac{${k}}{${n}} \\approx ${(0, round_1.round)(k / n, 2).frenchify()}
+$$
+
+${identifiers.isRepresentative
+        ? `Puisque $f$ appartient bien à l'intervalle de fluctuation, on peut affirmer que l'échantillon est représentatif au seuil de $95\\%$.`
+        : `Puisque $f$ n'appartient pas à l'intervalle de fluctuation, on peut affirmer que l'échantillon n'est pas représentatif au seuil de $95\\%$.`}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getIsSamplingRepresentativeQuestion = (ops) => {
+    const p = (0, randfloat_1.randfloat)(0.2, 0.8, 2);
+    const n = 50 * (0, randint_1.randint)(1, 20);
+    const isRepresentative = (0, coinFlip_1.coinFlip)();
+    //k est dans n*(p-1/sqrt(n)), n*(p+1/sqrt(n))
+    const interval = [p - 1 / Math.sqrt(n), p + 1 / Math.sqrt(n)];
+    const k = isRepresentative
+        ? (0, randint_1.randint)(Math.ceil(n * interval[0]), Math.floor(n * interval[1]))
+        : (0, coinFlip_1.coinFlip)()
+            ? (0, randint_1.randint)(1, Math.floor(n * interval[0]))
+            : (0, randint_1.randint)(Math.ceil(n * interval[1]), n - 1);
+    const identifiers = {
+        p,
+        k,
+        n,
+        isRepresentative,
+        wordingType: (0, randint_1.randint)(1, 4),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.isSamplingRepresentative = {
+    id: "isSamplingRepresentative",
+    label: "Déterminer si un échantillon est représentatif",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getIsSamplingRepresentativeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

package/lib/exercises/math/sequences/geometric/geometricVariations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EACL,eAAe,EAEhB,MAAM,kCAAkC,CAAC;AAM1C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricVariations = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Strictement croissante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Strictement décroissante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Constante", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non monotone", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const qEv = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q).evaluate();
+    if (qEv > 1) {
+        return identifiers.a > 0
+            ? "Strictement croissante"
+            : "Strictement décroissante";
+    }
+    else {
+        return identifiers.a > 0
+            ? "Strictement décroissante"
+            : "Strictement croissante";
+    }
+};
+const getInstruction = (identifiers) => {
+    const q = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q);
+    const a = identifiers.a;
+    const statement = (0, multiplyNode_1.multiply)(a, (0, powerNode_1.power)(q, "n")).simplify();
+    return `Soit $u$ la suite définie sur $\\mathbb{N}$ par 
+
+$$
+u_n = ${statement.toTex()}
+$$
+
+Quel est le sens de variations de $u$ ?`;
+};
+const getHint = (identifiers) => {
+    return `La suite géométrique $u_n = q^n$ est : 
+  
+- strictement croissante si $q>1$;
+- strictement décroissante si $0<q<1$. 
+
+Puis, multiplier $u$ par un nombre positif ne change pas son sens de variations, tandis que multiplier par un nombre negatif inverse le sens de variations.
+`;
+};
+const getCorrection = (identifiers) => {
+    const q = (0, nodeConstructor_1.reifyAlgebraic)(identifiers.q);
+    const qEv = q.evaluate();
+    const qLessThanOne = qEv < 1;
+    const a = identifiers.a;
+    const answer = getAnswer(identifiers);
+    const statement = (0, multiplyNode_1.multiply)(a, (0, powerNode_1.power)(q, "x")).simplify();
+    return `Puisque $${qLessThanOne ? `0 < ${q.toTex()} < 1` : `${q.toTex()}>1`}$, la suite $${(0, powerNode_1.power)(q, "n").toTex()}$ est strictement ${qLessThanOne ? "décroissante" : " croissante"}.
+  
+En multipliant $${(0, powerNode_1.power)(q, "n").toTex()}$ par $${a.frenchify()} ${a < 0 ? "<0" : ">0"}$, ${a < 0
+        ? `on inverse son sens de variations.`
+        : `on ne change pas son sens de variation.`}
+
+Ainsi, la suite $u_n = ${statement.toTex()}$ est ${answer.toLocaleLowerCase()}.
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getGeometricVariationsQuestion = (ops) => {
+    const a = (0, randfloat_1.randfloat)(0.1, 3, 2, [1]) * ((0, coinFlip_1.coinFlip)() ? 1 : -1);
+    const qLessThanOne = (0, coinFlip_1.coinFlip)();
+    let q;
+    if (qLessThanOne) {
+        q = (0, coinFlip_1.coinFlip)()
+            ? (0, randfloat_1.randfloat)(0.1, 1, 2).toTree()
+            : rational_1.RationalConstructor.randomIrreductibleProba().toTree();
+    }
+    else {
+        q = (0, coinFlip_1.coinFlip)()
+            ? (0, randfloat_1.randfloat)(1.1, 10, 2).toTree()
+            : rational_1.RationalConstructor.randomIrreductible(11, {
+                onlySupOne: true,
+            }).toTree();
+    }
+    const identifiers = {
+        a,
+        q: q.toIdentifiers(),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.geometricVariations = {
+    id: "geometricVariations",
+    label: "Déterminer le sens de variations d'une suite géométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getGeometricVariationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -8,4 +8,5 @@ export * from "./geometricFindExplicitFormulaFirstTermRandom";
 export * from "./geometricFindTerm";
 export * from "./geometricRecognizeReasonFromFirstTerms";
 export * from "./geometricFirstTermsGeneralSum";
+export * from "./geometricVariations";
 //# 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,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC"}

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

@@ -24,3 +24,4 @@ __exportStar(require("./geometricFindExplicitFormulaFirstTermRandom"), exports);
 __exportStar(require("./geometricFindTerm"), exports);
 __exportStar(require("./geometricRecognizeReasonFromFirstTerms"), exports);
 __exportStar(require("./geometricFirstTermsGeneralSum"), exports);
+__exportStar(require("./geometricVariations"), exports);

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts

@@ -2,6 +2,7 @@ export type ToGGBCommandsProps = {
     isFixed?: boolean;
     showLabel?: boolean;
     showUnderlyingPointsLabel?: boolean;
+    showUnderlyingPoints?: boolean;
     style?: number;
     size?: number;
     color?: string;

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -5,14 +5,14 @@ const toolBarConstructor = (options) => {
     let customToolBar = "0||6";
     if (options.point)
         customToolBar += "||1";
+    if (options.intersect)
+        customToolBar += "||5";
     if (options.join)
         customToolBar += "||2";
     if (options.parallel)
         customToolBar += "||3";
     if (options.orthogonal)
         customToolBar += "||4";
-    if (options.intersect)
-        customToolBar += "||5";
     if (options.vector)
         customToolBar += "||7";
     if (options.circleTwoPoints)

package/lib/geogebra/parsers/parseGGBPoints.js

@@ -4,7 +4,7 @@ exports.parseGGBPoints = void 0;
 const deleteObjectNamesFromAnswer_1 = require("../deleteObjectNamesFromAnswer");
 const parseGGBPoints = (commands) => {
     const unnamed = (0, deleteObjectNamesFromAnswer_1.deleteObjectNamesFromAnswer)(commands);
-    const re = /\([^,]*,[^)]*\)/;
+    const re = /^\([^,]*,[^)]*\)/;
     return unnamed.filter((cmd) => !!cmd.match(re)?.length);
 };
 exports.parseGGBPoints = parseGGBPoints;

package/lib/index.d.ts

@@ -903,6 +903,9 @@ declare const mathExercises: (Exercise<{
     b: number;
     aU: number;
     bU: number;
+}, {}> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    a: number;
 }, {}> | Exercise<{
     coin: boolean;
     radius: number;
@@ -1186,6 +1189,9 @@ declare const mathExercises: (Exercise<{
 }, {
     useVector: boolean;
 }> | Exercise<{
+    point: import("./math/geometry/point").PointIdentifiers;
+    line: import("./math/geometry/line").LineIdentifiers;
+}, {}> | Exercise<{
     type: number;
     commands: string[];
 }, {}> | Exercise<{
@@ -1305,6 +1311,9 @@ declare const mathExercises: (Exercise<{
     subPopulationEffectif: number;
     subPopulationPercent: number;
     contextType: number;
+}, {}> | Exercise<{
+    vd: number;
+    percentRate: number;
 }, {}> | Exercise<{
     int: number;
     power: number;
@@ -1339,6 +1348,12 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     tenPower: number;
     decimal: number;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    k: number;
+    l: number;
+    m: number;
 }, {}> | Exercise<{
     c: number;
 }, {}> | Exercise<{
@@ -1590,6 +1605,9 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     nbTerms: number;
+}, {}> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    a: number;
 }, {}> | Exercise<{
     rank: number;
     coeffs: number[];
@@ -1771,6 +1789,20 @@ declare const mathExercises: (Exercise<{
         n: number;
         p: number;
     };
+}, {}> | Exercise<{
+    p: number;
+    n: number;
+    wordingType: number;
+}, {}> | Exercise<{
+    k: number;
+    n: number;
+    wordingType: number;
+}, {}> | Exercise<{
+    p: number;
+    k: number;
+    n: number;
+    isRepresentative: boolean;
+    wordingType: number;
 }, {}>)[];
 declare const pcExercises: (Exercise<{
     numbers: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/geometry/circle.d.ts

@@ -0,0 +1,10 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
+import { Point } from "./point";
+export declare class Circle {
+    center: Point;
+    point: Point;
+    name: string;
+    constructor(center: Point, point: Point, name?: string);
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
+}
+//# sourceMappingURL=circle.d.ts.map

package/lib/math/geometry/circle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/circle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,MAAM;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;gBACD,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAMtD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;CAkC7B"}

package/lib/math/geometry/circle.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Circle = void 0;
+class Circle {
+    constructor(center, point, name) {
+        this.center = center;
+        this.point = point;
+        this.name = name ?? "C";
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showUnderlyingPoints = true, } = {}) {
+        const commands = [];
+        if (shouldBuildPoints) {
+            const ACommands = this.center.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            const BCommands = this.point.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            commands.push(...ACommands, ...BCommands, `${this.name}=Circle(${this.center.name},${this.point.name})`);
+        }
+        else {
+            commands.push(`${this.name}=Circle(${this.center.toMathString()},${this.point.toMathString()})`);
+        }
+        commands.push(...[
+            `SetFixed(${this.name},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
+        ]);
+        return commands;
+    }
+}
+exports.Circle = Circle;

package/lib/math/geometry/line.d.ts

@@ -49,7 +49,7 @@ export declare class Line {
     };
     toTex(): string;
     toTexNoLeftRight(): string;
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showUnderlyingPoints, }?: ToGGBCommandsProps): string[];
     intersect(line: Line, intersectName?: string): Point;
 }
 //# sourceMappingURL=line.d.ts.map

package/lib/math/geometry/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAO3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;IAOnD,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO;CAGpC;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAYtB,iBAAiB;IAIjB,YAAY,CAAC,KAAK,EAAE,KAAK;IAYzB,gBAAgB,CAAC,KAAK,EAAE,KAAK;IAW7B,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAK7C,aAAa,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAW7C,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,oBAA2B,GAC5B,GAAE,kBAAuB;IAmC5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAW7C"}