math-exercises 3.0.83 → 3.0.85

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

@@ -0,0 +1,108 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { round } from "../../../../math/utils/round.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const offset = randfloat(0.1, 1, 2);
+        tryToAddWrongProp(propositions, round(answer.unfrenchify() + offset, 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const sum = xValues.reduce((sum, v, i) => sum + v * yValues[i], 0);
+    const mean = round(sum, 2);
+    return mean.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    return `Un film a été noté par les spectateurs : 
+
+  
+${mdTable([
+        ["Note", ...xValues.map((v) => dollarize(v))],
+        ["Fréquence", ...yValues.map((v) => dollarize(`${round(v * 100, 2)} \\%`))],
+    ])}
+
+Quelle est la note moyenne du film ?`;
+};
+const getHint = (identifiers) => {
+    return `Pour calculer la moyenne, multiplie chaque valeur $x_i$ par sa fréquence correspondante $f_i$, puis additionne ces produits.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const products = xValues.map((v, i) => round(v * yValues[i], 2));
+    const total = getAnswer(identifiers);
+    return `On calcule les produits des notes par leur fréquence : \n\n
+  
+${xValues
+        .map((v, i) => `$$
+${v} \\times ${yValues[i].frenchify()} = ${products[i].frenchify()}
+$$`)
+        .join("\n\n")}
+  
+En additionnant ces produits, on obtient la moyenne $\\overline{x}$ :
+
+$$
+\\overline x = ${total}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateMeanFromFrequenciesQuestion = (ops) => {
+    const xValues = [0, 1, 2, 3, 4];
+    const raw = xValues.map(() => Math.random());
+    const total = raw.reduce((sum, v) => sum + v, 0);
+    const yValues = raw.map((v) => round(v / total, 2));
+    const sumRounded = yValues.reduce((sum, v) => sum + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    yValues[yValues.length - 1] = round(yValues[yValues.length - 1] + diff, 2);
+    const identifiers = { xValues, yValues };
+    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 calculateMeanFromFrequencies = {
+    id: "calculateMeanFromFrequencies",
+    label: "Calculer une moyenne à partir de fréquences",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateMeanFromFrequenciesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -3,6 +3,9 @@ type Identifiers = {
     indicatorAsked: string;
     values: number[];
 };
-export declare const choseReasoningForIndicator: Exercise<Identifiers>;
+type Options = {
+    indicators: string[];
+};
+export declare const choseReasoningForIndicator: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=choseReasoningForIndicator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA2IF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBrE,CAAC"}

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

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
@@ -6,6 +6,16 @@ import { operatorComposition } from "../../../../tree/utilities/operatorComposit
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { average } from "../../../../utils/average.js";
+const options = [
+    {
+        id: "indicators",
+        label: "Indicateurs",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Moyenne", "Médiane"],
+        values: ["Moyenne", "Médiane"],
+    },
+];
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
@@ -52,7 +62,7 @@ const getCorrection = (identifiers) => {
         : `La médiane est la valeur centrale de la série : c'est à dire qu'il y a autant de valeurs inférieures à elle que de valeurs supérieures. Ici, ${getAnswer(identifiers).toLocaleLowerCase()}.
 `;
 };
-const getChoseReasoningForIndicatorQuestion = (ops) => {
+const getChoseReasoningForIndicatorQuestion = (opts) => {
     const max = 2 * randint(5, 20);
     const x = max / 2;
     let otherValues = [];
@@ -74,18 +84,18 @@ const getChoseReasoningForIndicatorQuestion = (ops) => {
     shuffled.splice(3, 0, x);
     const identifiers = {
         values: shuffled,
-        indicatorAsked: random(["moyenne", "médiane"]),
+        indicatorAsked: random(opts?.indicators ?? ["moyenne", "médiane"]),
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         answerFormat: "raw",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -101,4 +111,8 @@ export const choseReasoningForIndicator = {
     answerType: "QCU",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    options,
+    pdfOptions: {
+        shouldSpreadPropositions: true,
+    },
 };

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

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,139 @@
+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 { standardDeviation } from "../../../../math/utils/stats/standardDeviation.js";
+import { average } from "../../../../utils/average.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Série 1", "raw");
+    tryToAddWrongProp(propositions, "Série 2", "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);
+    return std1 > std2 ? "Série A" : "Série B";
+};
+const getInstruction = () => {
+    return `Laquelle des deux séries représentées ci-dessous semble la plus dispersée ?`;
+};
+const getHint = () => {
+    return `Observe la répartition des valeurs dans chaque série. Une série est plus dispersée si ses valeurs sont plus éloignées de sa moyenne.`;
+};
+const getCorrection = (identifiers) => {
+    const { serie1, serie2, labels } = identifiers;
+    const average1 = average(serie1);
+    const average2 = average(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()}$).
+  
+C'est donc la ${result} qui semble la plus dispersée.
+  `;
+};
+const getGGBOptions = ({ labels, serie1, serie2, }) => {
+    const serie1Data = serie1.join(",");
+    const serie2Data = serie2.join(",");
+    const commands = [
+        `A = BarChart({0.85,1.85,2.85,3.85}, {${serie1Data}}, 0.3)`,
+        `B = BarChart({1.15,2.15,3.15,4.15}, {${serie2Data}}, 0.3)`,
+        `SetLabelMode(A, 0)`,
+        `SetLabelMode(B, 0)`,
+        ...labels.map((l, i) => `Text("\\footnotesize ${l}", (${i + 1}, 2), true, true, 0, -1)`),
+        `Text("\\footnotesize Diamètre\\ (en \\ cm)", (3, -3.5), true, true, 0, -1)`,
+        `SetColor(A, "#168187")`,
+        `SetColor(B, "#376FDE")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        gridDistance: [1, 1],
+        fontSize: 16,
+        lockedAxesRatio: 1 / 13,
+        xAxis: {
+            showPositive: true,
+            hidden: true,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Effectif$",
+            steps: 10,
+        },
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({ coords: [-0.2, 5.2, 0, 30] });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+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 identifiers = {
+        labels,
+        serie1,
+        serie2,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const compareSeriesDispersion = {
+    id: "compareSeriesDispersion",
+    label: "Comparer des écarts-types à partir de diagramme d'effectifs de plusieurs séries",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareSeriesDispersionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"cumulativeSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/cumulativeSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4GF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

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

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { xVals, yVals, x } = identifiers;
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${xVals[x]}`);
+    tryToAddWrongProp(propositions, `${xVals[x]}`);
+    for (let k = 0; k < yVals.length; k++) {
+        let sum = 0;
+        for (let i = 0; i <= k; i++) {
+            sum += yVals[i];
+        }
+        tryToAddWrongProp(propositions, `${sum}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { yVals, x } = identifiers;
+    let sum = 0;
+    for (let i = 0; i <= x; i++) {
+        sum += yVals[i];
+    }
+    return `${sum}`;
+};
+const getInstruction = (identifiers) => {
+    const { xVals, yVals, x } = identifiers;
+    return `On considère la série statistique suivante :
+  
+${mdTable([
+        ["Valeur", ...xVals.map((x) => dollarize(x))],
+        ["Effectif", ...yVals.map((y) => dollarize(y))],
+    ])}
+
+Calculez l'effectif cumulé croissant de la valeur $${xVals[x]}$.
+`;
+};
+const getHint = (identifiers) => {
+    return `L'effectif cumulé croissant d'une valeur correspond à la somme des effectifs des valeurs inférieures ou égales à cette valeur`;
+};
+const getCorrection = (identifiers) => {
+    const { xVals, yVals, x } = identifiers;
+    let sum = 0;
+    for (let i = 0; i <= x; i++) {
+        sum += yVals[i];
+    }
+    return `L'effectif cumulé croissant de $${xVals[x]}$ correspond à la somme des effectifs des valeurs inférieures ou égales à $${xVals[x]}$ :
+  
+$$
+${x > 0
+        ? `${operatorComposition(AddNode, yVals.slice(0, x + 1).map((e) => e.toTree())).toTex()} = ${sum}`
+        : `${sum}`}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getCumulativeSumQuestion = (ops) => {
+    let xVals = [randint(1, 10)];
+    let yVals = [randint(1, 10, xVals)];
+    for (let i = 1; i < randint(3, 6); i++) {
+        xVals.push(xVals[i - 1] + randint(1, 10));
+        yVals.push(yVals[i - 1] + randint(1, 10));
+    }
+    const identifiers = {
+        xVals,
+        yVals,
+        x: randint(1, xVals.length),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const cumulativeSum = {
+    id: "cumulativeSum",
+    label: "Calculer des effectifs cumulés croissants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCumulativeSumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -13,4 +13,8 @@ export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
 export * from "./choseReasoningForIndicator.js";
+export * from "./compareSeriesDispersion.js";
+export * from "./averageLinearity.js";
+export * from "./calculateMeanFromFrequencies.js";
+export * from "./cumulativeSum.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC"}

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

@@ -13,3 +13,7 @@ export * from "./standardDeviationTable.js";
 export * from "./interquartilesList.js";
 export * from "./interquartilesTable.js";
 export * from "./choseReasoningForIndicator.js";
+export * from "./compareSeriesDispersion.js";
+export * from "./averageLinearity.js";
+export * from "./calculateMeanFromFrequencies.js";
+export * from "./cumulativeSum.js";

package/lib/index.d.ts

@@ -103,6 +103,15 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     a: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     interval: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    x: number;
+}, {}> | Exercise<{
+    type: number;
+    expr: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {}> | Exercise<{
+    point: import("./math/geometry/point.js").PointIdentifiers;
+    bounding: number;
 }, {}> | Exercise<{
     integerFirst: boolean;
     integer: number;
@@ -179,6 +188,11 @@ declare const mathExercises: (Exercise<{
     a: number;
     n: number;
     isSimplified: boolean;
+}, {}> | Exercise<{
+    a: number;
+    b: number;
+    c: number;
+    d: number;
 }, {}> | Exercise<{
     numbers: number[];
 }, {}> | Exercise<{
@@ -1559,6 +1573,8 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, {}> | Exercise<{
+    intervalNodeIdentifiers: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, {}> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -1754,23 +1770,6 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     kIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     uCoeffs: number[];
-}, {}> | Exercise<{
-    kind: "factor";
-    a: number;
-    operator: "multiplication" | "division" | "soustraction" | "addition";
-    factor: number;
-} | {
-    kind: "series";
-    series: number[];
-    operator: "multiplication" | "division" | "soustraction" | "addition";
-    factor: number;
-}, {}> | Exercise<{
-    repartitions: number[];
-    colorAskedIndex: number;
-}, {}> | Exercise<{
-    questionType: string;
-    value?: string;
-    color?: import("./exercises/utils/cardsData.js").CardsColor;
 }, {}> | Exercise<{
     flip: number;
     pA?: number;
@@ -1778,11 +1777,6 @@ declare const mathExercises: (Exercise<{
     pAB?: number;
     pA_B?: number;
     pB_A?: number;
-}, {}> | Exercise<{
-    isParityQuestion: boolean;
-    isEvenQuestion: boolean;
-    nbFaces: number;
-    faceAsked: number;
 }, {}> | Exercise<{
     A: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     B: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
@@ -1838,6 +1832,29 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     indicatorAsked: string;
     values: number[];
+}, {
+    indicators: string[];
+}> | Exercise<{
+    labels: number[];
+    serie1: number[];
+    serie2: number[];
+}, {}> | Exercise<{
+    kind: "factor";
+    a: number;
+    operator: "multiplication" | "division" | "soustraction" | "addition";
+    factor: number;
+} | {
+    kind: "series";
+    series: number[];
+    operator: "multiplication" | "division" | "soustraction" | "addition";
+    factor: number;
+}, {}> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, {}> | Exercise<{
+    xVals: number[];
+    yVals: number[];
+    x: number;
 }, {}> | Exercise<{
     xValues: number[];
     yValues: number[];
@@ -1903,6 +1920,8 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     values: number[];
     target: number;
+}, {}> | Exercise<{
+    samples: number[];
 }, {}> | Exercise<{
     xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -1916,12 +1935,6 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     xValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     yValuesIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
-}, {}> | Exercise<{
-    labels: string[];
-    pValues: number[];
-    missingIndex: number;
-}, {}> | Exercise<{
-    pA: number;
 }, {}> | Exercise<{
     pA: number;
     pB: number;
@@ -1929,9 +1942,6 @@ declare const mathExercises: (Exercise<{
     pIntersection: number;
     target: "pA" | "pB" | "pUnion" | "pIntersection";
 }, {}> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, {}> | Exercise<MathExercises.Identifiers, {}> | Exercise<{
     total: number;
     distribution: number[];
     observe: boolean;
@@ -1950,9 +1960,43 @@ declare const mathExercises: (Exercise<{
     };
     question: "union" | "intersection" | "comp";
 }, {}> | Exercise<{
-    xVals: number[];
-    yVals: number[];
-    x: number;
+    eventA: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    eventB: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    question: "union" | "intersection" | "comp";
+}, {}> | Exercise<{
+    repartitions: number[];
+    colorAskedIndex: number;
+}, {}> | Exercise<{
+    questionType: string;
+    value?: string;
+    color?: import("./exercises/utils/cardsData.js").CardsColor;
+}, {}> | Exercise<{
+    isParityQuestion: boolean;
+    isEvenQuestion: boolean;
+    nbFaces: number;
+    faceAsked: number;
+}, {}> | Exercise<{
+    pA: number;
+}, {}> | Exercise<{
+    labels: string[];
+    pValues: number[];
+    missingIndex: number;
+}, {}> | Exercise<MathExercises.Identifiers, {}> | Exercise<{
+    a: number;
+    type: number;
+}, {}> | Exercise<{
+    labels: string[];
+    serie1: number[];
+    serie2: number[];
+    a: number;
+    b: number;
+    isBetween: boolean;
 }, {}> | Exercise<{
     firstValue: number;
     askedRank: number;