math-exercises 3.0.102 → 3.0.104

package/lib/exercises/math/probaStat/stats1var/averageLinearity.js

@@ -1,8 +1,8 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
-import { divide } from "../../../../tree/nodes/operators/divideNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
@@ -70,7 +70,7 @@ const getAnswer = (identifiers) => {
             return multiply(moyenne, factor).simplify().toTex();
         case "division":
         default:
-            return frac(moyenne, factor).simplify().toTex();
+            return round(moyenne / factor, 4).frenchify();
     }
 };
 const getInstruction = (identifiers) => {
@@ -134,7 +134,7 @@ const getCorrection = (identifiers) => {
             break;
         case "division":
         default:
-            latexFormula = `${divide(moyenne, factor).toTex()} = ${frac(moyenne, factor).toTex()}`;
+            latexFormula = `${frac(moyenne, factor).toTex()} = ${round(moyenne / factor, 4).frenchify()}`;
             break;
     }
     return `Il y a eu une ${operator} de $${factor.frenchify()}$ sur les valeurs de la série, donc la moyenne devient :
@@ -146,7 +146,7 @@ $$`;
 const isAnswerValid = (ans, { answer }) => {
     try {
         const parsed = parseAlgebraic(ans);
-        return parsed.simplify().toTex() === answer;
+        return parsed.simplify({ fractionsToDecimal: true }).toTex() === answer;
     }
     catch (err) {
         return handleVEAError(err);
@@ -214,4 +214,5 @@ export const averageLinearity = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
 };

package/lib/exercises/math/probaStat/stats1var/compareSeriesDispersion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareSeriesDispersion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/compareSeriesDispersion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA8JF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAqBzD,CAAC"}
+{"version":3,"file":"compareSeriesDispersion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/compareSeriesDispersion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA+HF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAqBzD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/compareSeriesDispersion.js

@@ -1,42 +1,23 @@
 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 { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
-import { standardDeviation } from "../../../../math/utils/stats/standardDeviation.js";
-import { average } from "../../../../utils/average.js";
+import { gaussianWithNoise } from "../../../../math/utils/stats/gaussianWithNoise.js";
+import { standardDeviationWithEffectifs, } from "../../../../math/utils/stats/standardDeviation.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { averageWithEffectifs } from "../../../../utils/average.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
     tryToAddWrongProp(propositions, "Série A", "raw");
     tryToAddWrongProp(propositions, "Série B", "raw");
-    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
     return shuffleProps(propositions, n);
 };
-function computeStats(serie, labels, shouldRound = false) {
-    const total = serie.reduce((a, b) => a + b, 0);
-    const rawMean = serie.reduce((acc, e, i) => acc + e * labels[i], 0) / total;
-    const rawVariance = serie.reduce((acc, e, i) => acc + e * Math.pow(labels[i] - rawMean, 2), 0) /
-        total;
-    const rawEcartType = Math.sqrt(rawVariance);
-    if (shouldRound) {
-        return {
-            total,
-            mean: round(rawMean, 2),
-            variance: round(rawVariance, 2),
-            ecartType: round(rawEcartType, 2),
-        };
-    }
-    return {
-        total,
-        mean: rawMean,
-        variance: rawVariance,
-        ecartType: rawEcartType,
-    };
-}
 const getAnswer = ({ serie1, serie2, labels }) => {
-    const std1 = standardDeviation(serie1);
-    const std2 = standardDeviation(serie2);
+    const std1 = standardDeviationWithEffectifs(labels, serie1);
+    const std2 = standardDeviationWithEffectifs(labels, serie2);
     return std1 > std2 ? "Série A" : "Série B";
 };
 const getInstruction = () => {
@@ -47,8 +28,8 @@ const getHint = () => {
 };
 const getCorrection = (identifiers) => {
     const { serie1, serie2, labels } = identifiers;
-    const average1 = average(serie1);
-    const average2 = average(serie2);
+    const average1 = averageWithEffectifs(labels, serie1);
+    const average2 = averageWithEffectifs(labels, serie2);
     const result = getAnswer(identifiers);
     const otherSeries = result === "Série A" ? "série B" : "série A";
     return `On observe que les valeurs de la ${otherSeries} sont plus concentrées autour de la moyenne de cette série (qui vaut environ $${round(result === "Série A" ? average2 : average1, 0).frenchify()}$).
@@ -96,12 +77,13 @@ const isAnswerValid = (ans, { answer }) => {
 const getCompareSeriesDispersionQuestion = () => {
     const labels = [10, 20, 30, 40];
     const baseValue = randint(10, 25);
-    const serie1 = labels.map(() => randint(baseValue - 3, baseValue + 3));
-    const serie2 = labels.map(() => randint(1, 35));
+    const firstIsAnswer = coinFlip();
+    const wrong = labels.map(() => randint(baseValue - 3, baseValue + 3));
+    const right = gaussianWithNoise(4, randfloat(0.1, 0.9).toTree()).map((e) => Math.min(e * 60, 30));
     const identifiers = {
         labels,
-        serie1,
-        serie2,
+        serie1: firstIsAnswer ? right : wrong,
+        serie2: firstIsAnswer ? wrong : right,
     };
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.d.ts

@@ -3,7 +3,7 @@ type Identifiers = {
     labels: string[];
     serie1: number[];
     serie2: number[];
-    a: number;
+    a?: number;
     b: number;
     isBetween: boolean;
 };

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getQuartileProportionQuestion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAwMF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}
+{"version":3,"file":"getQuartileProportionQuestion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAoOF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/probaStat/stats1var/getQuartileProportionQuestion.js

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
@@ -13,30 +14,16 @@ const getPropositions = (n, { answer }) => {
     return shuffleProps(propositions, n);
 };
 const getAnswer = ({ serie1, serie2, a, b, isBetween, }) => {
-    const mainSeries = serie1.includes(b) ? serie1 : serie2;
-    const otherSeries = mainSeries === serie1 ? serie2 : serie1;
-    const indexOfB = mainSeries.indexOf(b);
-    const indexOfA = mainSeries.indexOf(a);
-    const diff = indexOfB - indexOfA + 1;
-    let count = 0;
-    for (let idx = 0; idx < otherSeries.length; idx++) {
-        const val = otherSeries[idx];
-        if (isBetween) {
-            if ((val >= a || otherSeries[idx + 1] > a) &&
-                (val <= b || otherSeries[idx - 1] < b)) {
-                count++;
-            }
-        }
-        else {
-            if (val < b) {
-                count++;
-            }
-        }
+    if (isBetween) {
+        const serie1Space = serie1.indexOf(b) - serie1.indexOf(a);
+        const serie2Space = serie2.indexOf(b) - serie2.indexOf(a);
+        return serie1Space > serie2Space ? "Série $1$" : "Série $2$";
+    }
+    else {
+        const serie1Index = serie1.indexOf(b);
+        const serie2Index = serie2.indexOf(b);
+        return serie1Index < serie2Index ? "Série $1$" : "Série $2$";
     }
-    const mainSeriesText = mainSeries === serie1 ? "Série $1$" : "Série $2$";
-    const otherSeriesText = mainSeries === serie1 ? "Série $2$" : "Série $1$";
-    const condition = isBetween ? diff >= count : indexOfB < count;
-    return condition ? mainSeriesText : otherSeriesText;
 };
 const getInstruction = ({ labels, serie1, serie2, a, b, isBetween, }) => {
     const question = isBetween
@@ -60,63 +47,29 @@ Les quartiles permettent de découper une série en quatre parties égales :
 };
 const getCorrection = (identifiers) => {
     const { labels, serie1, serie2, a, b, isBetween } = identifiers;
-    const isBInSerie1 = serie1.includes(b);
-    const mainSeries = isBInSerie1 ? serie1 : serie2;
-    const otherSeries = isBInSerie1 ? serie2 : serie1;
-    const mainSeriesLabel = isBInSerie1 ? "série $1$" : "série $2$";
-    const otherSeriesLabel = isBInSerie1 ? "série $2$" : "série $1$";
-    const indexOfA = mainSeries.indexOf(a);
-    const indexOfB = mainSeries.indexOf(b);
-    let i = 0;
-    for (let idx = 0; idx < otherSeries.length; idx++) {
-        const val = otherSeries[idx];
-        if (isBetween) {
-            if ((val >= a || otherSeries[idx + 1] > a) &&
-                (val <= b || otherSeries[idx - 1] < b)) {
-                i++;
-            }
-        }
-        else {
-            if (val < b) {
-                i++;
-            }
-        }
+    const labelDollarized = labels.map((l, i) => i === 1 || i === 3 ? dollarize(l) : l);
+    if (isBetween) {
+        const serie1BIndex = serie1.indexOf(b);
+        const serie2BIndex = serie2.indexOf(b);
+        const serie1AIndex = serie1.indexOf(a);
+        const serie2AIndex = serie2.indexOf(a);
+        const serie1Space = serie1BIndex - serie1AIndex;
+        const serie2Space = serie2BIndex - serie2AIndex;
+        return `Dans la série $1$, ${labelDollarized[serie1AIndex]} $=${a}$, et ${labelDollarized[serie1BIndex]} $=${b}$, donc $${serie1Space * 25} \\%$ des valeurs sont comprises entre $${a}$ et $${b}$.
+    
+Dans la série $2$, ${labelDollarized[serie2AIndex]} $=${a}$, et ${labelDollarized[serie2BIndex]} $=${b}$, donc $${serie2Space * 25} \\%$ des valeurs sont comprises entre $${a}$ et $${b}$.
+
+C'est donc la ${serie2Space < serie1Space ? "série $1$" : "série $2$"} qui a la plus grande proportion de valeurs supérieures à $${b}$.`;
     }
-    const quartilePercentages = [0, 25, 50, 75, 100];
-    const labelA = labels[indexOfA];
-    const labelB = labels[indexOfB];
-    const valueA = a;
-    const valueB = b;
-    const diff = indexOfB - indexOfA + 1;
-    const percentageBetween = quartilePercentages[diff - 1];
-    const percentageAbove = 100 - quartilePercentages[indexOfB];
-    const answer = getAnswer(identifiers);
-    const answerFormatted = answer === "Série $1$" ? "série $1$" : "série $2$";
-    const decideWord = answerFormatted === mainSeriesLabel ? "moins" : "plus";
-    const proportionB = isBetween
-        ? `$${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
-        : `$${percentageAbove}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
-    const proportionOther = i === 0
-        ? `Il n'y a aucune valeur dans l'intervalle $[${valueA}; ${valueB}]$.\n\n`
-        : isBetween
-            ? `${decideWord} $${percentageBetween}\\%$ des valeurs sont entre $${valueA}$ et $${valueB}$.\n\n`
-            : `${otherSeries[indexOfB] > valueB ? "plus" : "moins"} de $${100 - quartilePercentages[i - 1]}\\%$ des valeurs sont supérieures à $${valueB}$.\n\n`;
-    const comparison = isBetween
-        ? `La ${answer} a donc une proportion plus grande de valeurs dans l'intervalle.`
-        : `La ${answer} a donc une proportion plus grande de valeurs supérieures à $${valueB}$.`;
-    return isBetween
-        ? `On peut estimer cette proportion en observant la position des valeurs $${valueA}$ et $${valueB}$ dans chaque série :
+    else {
+        const serie1Index = serie1.indexOf(b);
+        const serie2Index = serie2.indexOf(b);
+        return `Dans la série $1$, ${labelDollarized[serie1Index]} $=${b}$, donc $${100 - serie1Index * 25} \\%$ des valeurs sont supérieures à $${b}$.
     
-  - Dans la ${mainSeriesLabel}, on a $${labelA} = ${valueA}$ et $${labelB} = ${valueB}$, donc ${proportionB}
-  - Dans la ${otherSeriesLabel}, on a $${labelA} = ${otherSeries[indexOfA]}$ et $${labelB} = ${otherSeries[indexOfB]}$, donc ${proportionOther}
-  
-  ${comparison}`
-        : `On peut estimer cette proportion en observant la position de la valeur $${valueB}$ dans chaque série :
-  
-  - Dans la ${mainSeriesLabel}, on a $${labelB} = ${valueB}$, donc ${proportionB}
-  - Dans la ${otherSeriesLabel}, on a $${labelB} = ${otherSeries[indexOfB]}$, ${proportionOther}
-  
-  ${comparison}`;
+Dans la série $2$, ${labelDollarized[serie2Index]} $=${b}$, donc $${100 - serie2Index * 25} \\%$ des valeurs sont supérieures à $${b}$.
+
+C'est donc la ${serie1Index < serie2Index ? "série $1$" : "série $2$"} qui a la plus grande proportion de valeurs supérieures à $${b}$.`;
+    }
 };
 const getKeys = () => [];
 const isAnswerValid = (ans, { answer }) => {
@@ -127,25 +80,93 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
-const makeQuartileSeries = (min, exclude) => {
-    const serie = [min];
-    for (let i = 0; i < 4; i++) {
-        const prev = serie[serie.length - 1];
-        serie.push(randint(prev + 1, prev + 6, exclude));
-    }
-    return serie;
-};
 const getGetQuartileProportionQuestionQuestion = () => {
     const labels = ["Min", "Q_1", "Méd", "Q_3", "Max"];
-    const min = randint(0, 10);
-    const serie1 = makeQuartileSeries(min);
-    const serie2 = makeQuartileSeries(min, serie1);
+    let a = undefined;
+    let b;
+    let serie1;
+    let serie2;
     const isBetween = coinFlip();
-    const chosenSerie = coinFlip() ? serie1 : serie2;
-    const indexOfA = randint(0, serie1.length - (isBetween ? 1 : 2));
-    const a = chosenSerie[indexOfA];
-    const indexOfB = randint(indexOfA + 1, isBetween ? chosenSerie.length : chosenSerie.length - 1);
-    const b = chosenSerie[indexOfB];
+    if (isBetween) {
+        const serie1Indexes = randTupleInt(2, {
+            from: 0,
+            to: 5,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        let serie2Indexes = [];
+        do {
+            serie2Indexes = randTupleInt(2, {
+                from: 0,
+                to: 5,
+                allDifferent: true,
+            }).sort((a, b) => a - b);
+        } while (serie2Indexes[1] - serie2Indexes[0] ===
+            serie1Indexes[1] - serie1Indexes[0] ||
+            (serie1Indexes[0] === serie2Indexes[0] &&
+                serie1Indexes[1] === serie2Indexes[1]));
+        a = randint(5, 20);
+        b = randint(a + 5, 30);
+        const serie1Prev = randTupleInt(serie1Indexes[0], {
+            from: 1,
+            to: a,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1Between = randTupleInt(serie1Indexes[1] - serie1Indexes[0] - 1, {
+            from: a + 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1End = randTupleInt(4 - serie1Indexes[1], {
+            from: b + 1,
+            to: 40,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Prev = randTupleInt(serie2Indexes[0], {
+            from: 1,
+            to: a,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Between = randTupleInt(serie2Indexes[1] - serie2Indexes[0] - 1, {
+            from: a + 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2End = randTupleInt(4 - serie2Indexes[1], {
+            from: b + 1,
+            to: 40,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        serie1 = [...serie1Prev, a, ...serie1Between, b, ...serie1End];
+        serie2 = [...serie2Prev, a, ...serie2Between, b, ...serie2End];
+    }
+    else {
+        b = randint(5, 20);
+        //build les deux series avec a ayant un index <4 et différents
+        const serie1Index = randint(0, 4);
+        const serie2Index = randint(0, 4, [serie1Index]);
+        const serie1Prev = randTupleInt(serie1Index, {
+            from: 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Prev = randTupleInt(serie2Index, {
+            from: 1,
+            to: b,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie1Next = randTupleInt(4 - serie1Index, {
+            from: b + 1,
+            to: 30,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        const serie2Next = randTupleInt(4 - serie2Index, {
+            from: b + 1,
+            to: 30,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+        serie1 = [...serie1Prev, b, ...serie1Next];
+        serie2 = [...serie2Prev, b, ...serie2Next];
+    }
     const identifiers = { labels, serie1, serie2, a, b, isBetween };
     return getQuestionFromIdentifiers(identifiers);
 };

package/lib/exercises/math/probaStat/stats1var/interquartilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interquartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/interquartilesList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"interquartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/interquartilesList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/interquartilesList.js

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

package/lib/exercises/math/probaStat/stats1var/interquartilesTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interquartilesTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/interquartilesTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAqHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"interquartilesTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/interquartilesTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAqHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/interquartilesTable.js

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

package/lib/exercises/math/probaStat/stats1var/quartiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6HF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAa3C,CAAC"}
+{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6HF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/quartiles.js

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

package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}
+{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/quartilesList.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"fineAdjustementExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/fineAdjustementExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAM5C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;CAChD,CAAC;AAyIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"fineAdjustementExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/fineAdjustementExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAM5C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;CAChD,CAAC;AA0IF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/stats2var/fineAdjustementExercise.js

@@ -83,7 +83,7 @@ const getPropositions = (n, { answer, isJustified }) => {
     let randomNb;
     while (propositions.length < n) {
         randomNb = randfloat(0, 0.5, 2);
-        tryToAddWrongProp(propositions, `Un ajustement affine est justifié. Le coefficient de détermination vaut ${randomNb}`);
+        tryToAddWrongProp(propositions, `Un ajustement affine est justifié. Le coefficient de détermination vaut ${randomNb}`, "raw");
     }
     return shuffleProps(propositions, n);
 };

package/lib/exercises/math/python/pythonForLoopInstructionCompletion.js

@@ -40,7 +40,7 @@ Par quoi faut-il remplacer les trois points ?
 def boucle(a):
   for num in range(${iterations}):
     a=...
-return a
+  return a
 \`\`\`
 `;
 };

package/lib/exercises/math/python/variableType.js

@@ -100,7 +100,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const variableType = {
     id: "variableType",
-    label: "Déterminer le type d’une variable en Python",
+    label: "Déterminer le type d'une variable en Python",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getVariableTypeQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/python/whileLoop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}
+{"version":3,"file":"whileLoop.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/whileLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}

package/lib/exercises/math/python/whileLoop.js

@@ -18,6 +18,7 @@ const getInstruction = (identifiers) => {
     const { a, initialValue, opIndex, step, x } = identifiers;
     const op = operations[opIndex];
     return `Qu'affichera le programme suivant ?
+  
 \`\`\`
 a = ${a}
 n = ${initialValue}

package/lib/exercises/math/python/whileLoopCount.js

@@ -11,7 +11,7 @@ def boucle(x):
   return x
 \`\`\`
 
-Si l'on saisit la commande boucle($${inputValue}$), combien de fois la boucle s'exécute-t-elle ?`;
+Si l'on saisit la commande \`boucle(${inputValue})\`, combien de fois la boucle s'exécute-t-elle ?`;
 };
 const getAnswer = ({ inputValue, threshold }) => {
     let x = inputValue;
@@ -53,7 +53,7 @@ const getQuestionFromIdentifiers = (identifiers) => ({
     hint: getHint(identifiers),
     correction: getCorrection(identifiers),
     keys: [],
-    answerFormat: "raw",
+    answerFormat: "tex",
     identifiers,
 });
 const getPyWhileLoopCountQuestion = () => {

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

@@ -1 +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"}
+{"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;AAsGF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAoBnD,CAAC"}

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

@@ -25,9 +25,7 @@ const getInstruction = (identifiers) => {
     return `Ce graphique donne les fréquences de $${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.`;
+    return `Tu peux estimer la probabilité de $A$ en déterminant graphiquement la moyenne des fréquences des échantillons.`;
 };
 const getCorrection = (identifiers) => {
     const { samples } = identifiers;

package/lib/exercises/math/sequences/genericSequenceVariations.js

@@ -5,9 +5,9 @@ import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { coeffs } = identifiers;
     const u = new Polynomial(coeffs, "n");
-    return `Soit $u$ la suite définie par $u_n = ${u
-        .toTree()
-        .toTex()}$. Quel est le sens de variations de $u$ ?`;
+    return `Soit $u$ la suite définie par $u_n = ${u.toTree().toTex()}$. 
+    
+Quel est le sens de variations de $u$ ?`;
 };
 const getAnswer = (identifiers) => {
     const { coeffs } = identifiers;

package/lib/exercises/math/sequences/sequencePlot.js

@@ -80,7 +80,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         ggbOptions: getGGBOptions(identifiers),
         keys: [],
-        answerFormat: "raw",
+        answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),

package/lib/exercises/pc/electricity/kirchhoffVoltageLaw.js

@@ -57,7 +57,7 @@ La tension $U_{DC}$ aux bornes de la diode est $${uDC}$ $V$.
 
 La tension $U_{ED}$ aux bornes du conducteur ohmique est $${uED} \\ \\textrm{V}$.
 
-Cacluler la tension de la pile $U_{AB}$.
+Calculer la tension de la pile $U_{AB}$.
 
 ${schema}`;
         case "UED":

package/lib/index.d.ts

@@ -2061,7 +2061,7 @@ declare const mathExercises: (Exercise<{
     labels: string[];
     serie1: number[];
     serie2: number[];
-    a: number;
+    a?: number;
     b: number;
     isBetween: boolean;
 }, {}> | Exercise<{

package/lib/math/probability/binomial.d.ts

@@ -3,6 +3,7 @@ export declare class Binomial {
     n: number;
     p: AlgebraicNode;
     constructor(n: number, p: AlgebraicNode);
+    equals(k: number): number;
     sup(k: number): number;
     inf(k: number): number;
     ineq(a: number, b: number): number;

package/lib/math/probability/binomial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binomial.d.ts","sourceRoot":"","sources":["../../../src/math/probability/binomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,qBAAa,QAAQ;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,aAAa,CAAC;gBACL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa;IAKvC,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAW1B"}
+{"version":3,"file":"binomial.d.ts","sourceRoot":"","sources":["../../../src/math/probability/binomial.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,qBAAa,QAAQ;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,aAAa,CAAC;gBACL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa;IAoBvC,MAAM,CAAC,CAAC,EAAE,MAAM;IAQhB,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,GAAG,CAAC,CAAC,EAAE,MAAM;IAWb,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;CAW1B"}

package/lib/math/probability/binomial.js

@@ -7,6 +7,26 @@ export class Binomial {
         this.n = n;
         this.p = p;
     }
+    // //ex sample([1,2,3]) renvoit un échantillon [v_i] où v_i = nb de fois où on a obtenu i succès avec B(n,p)
+    // sample(values: number[]) {
+    //   const proba = this.p.evaluate();
+    //   const res = [];
+    //   for (const v of values) {
+    //     let count = 0;
+    //     for (let i = 0; i < this.n; i++) {
+    //       const success = Math.random() < proba;
+    //       success && count++;
+    //     }
+    //     v === count && res.push(count);
+    //   }
+    //   return res;
+    // }
+    equals(k) {
+        const proba = this.p.evaluate();
+        return (combinations(k, this.n) *
+            Math.pow(proba, k) *
+            Math.pow(1 - proba, this.n - k));
+    }
     sup(k) {
         const proba = this.p.evaluate();
         return sum(k, this.n, (i) => combinations(i, this.n) *

package/lib/math/utils/stats/gaussianWithNoise.d.ts

@@ -0,0 +1,3 @@
+import { AlgebraicNode } from "../../../tree/nodes/algebraicNode.js";
+export declare const gaussianWithNoise: (n: number, p: AlgebraicNode) => number[];
+//# sourceMappingURL=gaussianWithNoise.d.ts.map

package/lib/math/utils/stats/gaussianWithNoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianWithNoise.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/stats/gaussianWithNoise.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,eAAO,MAAM,iBAAiB,MAAO,MAAM,KAAK,aAAa,aAO5D,CAAC"}