math-exercises 3.0.86 → 3.0.87

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

@@ -0,0 +1,95 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, expCount, isSize, repCount }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, expCount.frenchify());
+    tryToAddWrongProp(propositions, repCount.frenchify());
+    while (propositions.length < n) {
+        let wrongValue;
+        wrongValue = randint(1, 200);
+        tryToAddWrongProp(propositions, wrongValue.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const answer = isSize ? expCount.frenchify() : repCount.frenchify();
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const qst = isSize
+        ? "Quelle est la taille de chaque échantillon ?"
+        : "Quel est le nombre d'échantillons obtenus?";
+    return `On lance $${expCount}$ fois trois pièces simultanément.\n\n
+  On répète l'expérience $${repCount}$ fois.\n\n
+  ${qst}`;
+};
+const getHint = ({ isSize }) => {
+    return isSize
+        ? `La taille d'un échantillon correspond au nombre de répétitions à l'intérieur d'une même expérience.`
+        : `Le nombre d'échantillons correspond au nombre de fois qu'on répète l'expérience entière.`;
+};
+const getCorrection = ({ expCount, repCount, isSize, }) => {
+    if (isSize) {
+        return `Chaque fois qu'on répète l'expérience, on lance $${expCount}$ fois trois pièces.  
+La taille de chaque échantillon est donc $${expCount}$.`;
+    }
+    else {
+        return `On répète l'expérience complète $${repCount}$ fois.  
+On obtient donc $${repCount}$ échantillons.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return answerNode.simplify().equals(ansNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetSampleCountAndSizeQuestion = (opts) => {
+    const expCount = randint(1, 301);
+    const repCount = randint(1, 51);
+    const isSize = opts?.isSize ?? coinFlip();
+    const identifiers = { expCount, repCount, isSize };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const getSampleCountAndSize = {
+    id: "getSampleCountAndSize",
+    label: "Distinguer taille et nombre d'échantillons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetSampleCountAndSizeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC"}

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

@@ -1,3 +1,5 @@
 export * from "./fluctuationInterval.js";
 export * from "./confidenceInterval.js";
 export * from "./isSamplingRepresentative.js";
+export * from "./getSampleCountAndSize.js";
+export * from "./samplingFrequency.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"samplingFrequency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sampling/samplingFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

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

@@ -0,0 +1,106 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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 { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { average } from "../../../utils/average.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const samples = identifiers.samples;
+    const avg = average(samples);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, round(avg + (coinFlip() ? randint(10, 30) / 100 : randint(-30, -10) / 100), 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const avg = average(identifiers.samples);
+    return round(avg, 1).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const length = identifiers.samples.length;
+    return `Ce graphique donne les fréquences $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
+};
+const getHint = (identifiers) => {
+    return `Chaque échantillon donne une valeur approximative proche de la probabilité réelle. 
+  
+Tu peux estimer cette probabilité en déterminant graphiquement la moyenne des fréquences des échantillons.`;
+};
+const getCorrection = (identifiers) => {
+    const { samples } = identifiers;
+    const avg = getAnswer(identifiers);
+    return `On lit graphiquement que la moyenne des fréquences est environ $${avg}$. Puisque le nombre d'échantillons est suffisant, on peut donc estimer que la probabilité de l'évènement $A$ vaut environ $${avg}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const commands = identifiers.samples.map((y, idx) => `(${idx}, ${y})`);
+    const yMax = Math.max(...identifiers.samples);
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: 5,
+        gridDistance: [1, 0.1],
+        xAxis: {
+            showPositive: true,
+            label: "N° d'échantillon",
+        },
+        yAxis: {
+            label: "Fréquence de l'évènement A",
+        },
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: [-1, identifiers.samples.length + 1, -0.1, yMax + 0.3],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    // On autorise une erreur de +/- 5% sur la frequence moyenne
+    const ev = parseAlgebraic(ans).evaluate();
+    const ansEv = parseAlgebraic(answer).evaluate();
+    return Math.abs(ev - ansEv) < 5 / 100;
+};
+const getSamplingFrequencyQuestion = (opts) => {
+    const freq = randint(2, 10) * 10; // multiple de 10 pour simplifier l'estimation pour l'utilisateur
+    let samples = [];
+    const length = randint(9, 14);
+    for (let i = 0; i < length; i++) {
+        samples.push(round((freq + randint(-10, 10)) / 100, 2));
+    }
+    const identifiers = { samples };
+    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 samplingFrequency = {
+    id: "samplingFrequency",
+    label: "Estimer une probabilité à partir d'un graphique de fréquences pour un nombre suffisant d'échantillons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSamplingFrequencyQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/intervals/index.d.ts

@@ -2,4 +2,6 @@ export * from "./inequalityToInterval.js";
 export * from "./intervalsIntersection.js";
 export * from "./intervalsUnion.js";
 export * from "./intervalToInequality.js";
+export * from "./isNumberInInterval.js";
+export * from "./intervalOnGraph.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/intervals/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/sets/intervals/index.js

@@ -2,3 +2,5 @@ export * from "./inequalityToInterval.js";
 export * from "./intervalsIntersection.js";
 export * from "./intervalsUnion.js";
 export * from "./intervalToInequality.js";
+export * from "./isNumberInInterval.js";
+export * from "./intervalOnGraph.js";

package/lib/exercises/math/sets/intervals/intervalOnGraph.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { IntervalNodeIdentifiers } from "../../../../tree/nodes/sets/intervalNode.js";
+type Identifiers = {
+    intervalNodeIdentifiers: IntervalNodeIdentifiers;
+};
+export declare const intervalOnGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=intervalOnGraph.d.ts.map

package/lib/exercises/math/sets/intervals/intervalOnGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intervalOnGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalOnGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,uBAAuB,EACxB,MAAM,uCAAuC,CAAC;AAI/C,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,uBAAuB,CAAC;CAClD,CAAC;AA6KF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAmBjD,CAAC"}

package/lib/exercises/math/sets/intervals/intervalOnGraph.js

@@ -0,0 +1,156 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randomColor } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { IntervalNodeConstructor, } from "../../../../tree/nodes/sets/intervalNode.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { intervalNodeIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(intervalNodeIdentifiers);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, interval.toClosedForm().toTex());
+    tryToAddWrongProp(propositions, interval.toComplement().toTex());
+    tryToAddWrongProp(propositions, interval.toLeftReversedClosure().toTex());
+    tryToAddWrongProp(propositions, interval.toReversedClosure().toTex());
+    tryToAddWrongProp(propositions, interval.toRightReversedClosure().toTex());
+    // tryToAddWrongProp(propositions, `${a} \\le x \\le ${b}`);
+    // tryToAddWrongProp(propositions, `${a} \\le x < ${b}`);
+    // tryToAddWrongProp(propositions, `${a} < x \\le ${b}`);
+    // tryToAddWrongProp(propositions, `${a} < x < ${b}`);
+    // tryToAddWrongProp(propositions, `${b} \\le x \\le ${a}`);
+    // tryToAddWrongProp(propositions, `${b} \\le x < ${a}`);
+    // tryToAddWrongProp(propositions, `${b} < x \\le ${a}`);
+    // tryToAddWrongProp(propositions, `${b} < x < ${a}`);
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { intervalNodeIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(intervalNodeIdentifiers);
+    return interval.toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Donner la notation de l'intervalle représenté sur la droite ci-dessous :`;
+};
+const getHint = (identifiers) => {
+    return `Écris, en utilisant des crochets, l'intervalle représenté sur la droite.`;
+};
+const getCorrection = (identifiers) => {
+    const { intervalNodeIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(intervalNodeIdentifiers);
+    return `L'intervalle représentée contient les nombres ${interval.toText(true, false)}.
+
+Cet intervalle se note donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { intervalNodeIdentifiers } = identifiers;
+    const interval = IntervalNodeConstructor.fromIdentifiers(intervalNodeIdentifiers);
+    let a = interval.a.evaluate();
+    if (a === Number.NEGATIVE_INFINITY)
+        a = -10000;
+    let b = interval.b.evaluate();
+    if (b === Number.POSITIVE_INFINITY)
+        b = 10000;
+    // const eqLeft = closedLeft ? "<=" : "<";
+    // const eqRight = closedRight ? "<=" : "<";
+    // const commands = [`${a} ${eqLeft} x ${eqRight} ${b}`];
+    const color = randomColor();
+    const commands = [
+        `S = Segment((${a}, 0), (${b}, 0))`,
+        `SetColor(S, "${color}")`,
+    ];
+    const y = 0.01;
+    const xDelta = 0.3;
+    if (a !== -10000) {
+        const isLeftClosed = interval.isLeftClosed();
+        commands.push(...[
+            `S_{a1} = Segment((${a}, -${y}), (${a}, ${y}))`,
+            `SetColor(S_{a1}, "${color}")`,
+            `S_{a2} = Segment((${a}, ${y}), (${a + (isLeftClosed ? xDelta : -xDelta)}, ${y}))`,
+            `SetColor(S_{a2}, "${color}")`,
+            `S_{a3} = Segment((${a}, -${y}), (${a + (isLeftClosed ? xDelta : -xDelta)}, -${y}))`,
+            `SetColor(S_{a3}, "${color}")`,
+        ]);
+    }
+    if (b !== 10000) {
+        const isRightClosed = interval.isRightClosed();
+        commands.push(...[
+            `S_{b1} = Segment((${b}, -${y}), (${b}, ${y}))`,
+            `SetColor(S_{b1}, "${color}")`,
+            `S_{b2} = Segment((${b}, ${y}), (${b + (isRightClosed ? -xDelta : xDelta)}, ${y}))`,
+            `SetColor(S_{b2}, "${color}")`,
+            `S_{b3} = Segment((${b}, -${y}), (${b + (isRightClosed ? -xDelta : xDelta)}, -${y}))`,
+            `SetColor(S_{b3}, "${color}")`,
+        ]);
+    }
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: [Math.max(-10, a) - 4, Math.min(10, b) + 4, -0.03, 0.03],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["lbracket", "semicolon", "rbracket", "inf"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = intervalParser(ans, { allowCommaInsteadOfSemicolon: true });
+    if (!parsed)
+        return false;
+    return parsed.toTex() === answer;
+};
+const getIntervalOnGraphQuestion = (opts) => {
+    const interval = IntervalNodeConstructor.random();
+    const identifiers = {
+        intervalNodeIdentifiers: interval.toIdentifiers(),
+    };
+    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 intervalOnGraph = {
+    id: "intervalOnGraph",
+    label: "Lire un intervalle sur une droite graduée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIntervalOnGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/intervals/isNumberInInterval.d.ts

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

package/lib/exercises/math/sets/intervals/isNumberInInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isNumberInInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/isNumberInInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAsLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}

package/lib/exercises/math/sets/intervals/isNumberInInterval.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "tex");
+    if (answer === "\\in") {
+        tryToAddWrongProp(propositions, "\\notin", "tex");
+    }
+    else {
+        tryToAddWrongProp(propositions, "\\in", "tex");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    if (intervalNode instanceof IntervalNode) {
+        const aValue = aNode.evaluate();
+        const aMin = intervalNode.a.evaluate();
+        const aMax = intervalNode.b.evaluate();
+        const leftClosed = intervalNode.isLeftClosed();
+        const rightClosed = intervalNode.isRightClosed();
+        if ((aValue > aMin || (leftClosed && aValue === aMin)) &&
+            (aValue < aMax || (rightClosed && aValue === aMax))) {
+            return "\\in";
+        }
+    }
+    return "\\notin";
+};
+const getInstruction = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    return `Compléter par le bon symbole : 
+  
+  
+$$
+${aNode.toTex()} \\ \\ldots \\ ${intervalNode.toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    return `Pour déterminer si $${aNode.toTex()}$ appartient à l'intervalle $${intervalNode.toTex()}$, il faut vérifier si cette valeur est comprise entre les bornes de l'intervalle.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, interval } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    const intervalNode = reifyAlgebraic(interval);
+    const aValue = aNode.evaluate();
+    const aMin = intervalNode.a.evaluate();
+    const aMax = intervalNode.b.evaluate();
+    const leftClosed = intervalNode.isLeftClosed();
+    const rightClosed = intervalNode.isRightClosed();
+    let minCondition, maxCondition;
+    if (leftClosed) {
+        minCondition = aValue >= aMin ? "vérifiée" : "non vérifiée";
+    }
+    else {
+        minCondition = aValue > aMin ? "vérifiée" : "non vérifiée";
+    }
+    if (rightClosed) {
+        maxCondition = aValue <= aMax ? "vérifiée" : "non vérifiée";
+    }
+    else {
+        maxCondition = aValue < aMax ? "vérifiée" : "non vérifiée";
+    }
+    const result = (aValue > aMin || (leftClosed && aValue === aMin)) &&
+        (aValue < aMax || (rightClosed && aValue === aMax));
+    return `Pour que le nombre $${aNode.toTex()}$ appartienne à l'intervalle $${intervalNode.toTex()}$, il faut qu'il soit ${leftClosed ? "supérieur ou égal" : "strictement supérieur"} à $${intervalNode.a.toTex()}$ et ${rightClosed ? "inférieur ou égal" : "strictement inférieur"} à $${intervalNode.b.toTex()}$.
+
+Vérifions ces conditions :
+- $${aNode.toTex()}$ ${leftClosed ? "$\\ge$" : "$>$"} $${intervalNode.a.toTex()}$ : condition ${minCondition}
+- $${aNode.toTex()}$ ${rightClosed ? "$\\le$" : "$<$"} $${intervalNode.b.toTex()}$ : condition ${maxCondition}
+
+${result
+        ? `Les deux conditions sont vérifiées, donc $${aNode.toTex()} \\in ${intervalNode.toTex()}$.`
+        : `Au moins une condition n'est pas vérifiée, donc $${aNode.toTex()} \\notin ${intervalNode.toTex()}$.`}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsNumberInIntervalQuestion = (ops) => {
+    const lowerBound = coinFlip()
+        ? randint(-10, 10)
+        : round(randfloat(-10, 10, 2), 2);
+    const width = randint(1, 20);
+    const upperBound = round(lowerBound + width, 2);
+    const closures = [
+        ClosureType.FF,
+        ClosureType.FO,
+        ClosureType.OF,
+        ClosureType.OO,
+    ];
+    const closure = random(closures);
+    const isInside = coinFlip();
+    let a;
+    if (isInside) {
+        a = coinFlip()
+            ? randint(Math.ceil(lowerBound), Math.floor(upperBound) - 1)
+            : randfloat(lowerBound, upperBound, 2);
+    }
+    else {
+        if (coinFlip()) {
+            const outisde = [];
+            a = coinFlip()
+                ? randint(-20, Math.floor(lowerBound) - 1)
+                : randfloat(-20, lowerBound - 0.01, 2);
+            outisde.push(a);
+            a = coinFlip()
+                ? randint(Math.ceil(upperBound) + 1, 20)
+                : randfloat(upperBound + 0.01, 20, 2);
+            outisde.push(a);
+            a = random(outisde);
+        }
+        else {
+            a = coinFlip() ? lowerBound : upperBound;
+        }
+    }
+    const interval = new IntervalNode(lowerBound.toTree(), upperBound.toTree(), closure);
+    const identifiers = {
+        a: a.toTree().toIdentifiers(),
+        interval: interval.toIdentifiers(),
+    };
+    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),
+    };
+};
+export const isNumberInInterval = {
+    id: "isNumberInInterval",
+    label: "Appartenance d'un nombre à un intervalle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsNumberInIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/squareRoots/simpifySquareRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simpifySquareRoot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/simpifySquareRoot.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAwGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"simpifySquareRoot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/simpifySquareRoot.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAwGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/squareRoots/simpifySquareRoot.js

@@ -110,4 +110,5 @@ export const simplifySquareRoot = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
 };

package/lib/exercises/math/squareRoots/squareRootIdentities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAsUF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAsUF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootIdentities.js

@@ -248,4 +248,5 @@ export const squareRootIdentities = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
 };

package/lib/exercises/math/squareRoots/squareRootsDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsDistributivity.js

@@ -106,4 +106,5 @@ export const squareRootsDistributivity = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
 };

package/lib/exercises/math/squareRoots/squareRootsFractions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsFractions.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}
+{"version":3,"file":"squareRootsFractions.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsFractions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}