math-exercises 2.2.71 → 2.2.73

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardDeviationTable = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const sqrtVEA_1 = require("../../../../exercises/vea/sqrtVEA");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const standardDeviation_1 = require("../../../../math/utils/standardDeviation");
+const variance_1 = require("../../../../math/utils/variance");
+const average_1 = require("../../../../utils/average");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
+const mdTable_1 = require("../../../../utils/markdown/mdTable");
+const getPropositions = (n, { answer, sortedValues, effectifs }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, variance_1.varianceWithEffectifs)(sortedValues, effectifs), 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(0, 5, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const sigma = (0, standardDeviation_1.standardDeviationWithEffectifs)(identifiers.sortedValues, identifiers.effectifs);
+    return (0, round_1.round)(sigma, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer l'écart-type de la série statistique suivante : 
+
+${(0, mdTable_1.mdTable)([
+        ["$x_i$", ...identifiers.sortedValues.map((e) => `$${e.frenchify()}$`)],
+        ["$n_i$", ...identifiers.effectifs.map((e) => `$${e.frenchify()}$`)],
+    ])}
+
+Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `On note : 
+  
+- $N$ le nombre de valeurs de la liste, 
+- $\\overline x$ la moyenne de la liste,
+- $x_1$, $x_2$, $\\ldots$, $x_N$ les valeurs de la liste,
+- $n_1$, $n_2$, $\\ldots$, $n_N$ les effectifs de la liste.
+
+Alors la variance est égale à : 
+
+$$
+V = \\frac{n_1(x_1-\\overline{x})^2  + \\ldots + n_N(x_N-\\overline{x})^2}{N}
+$$
+
+Puis, l'écart-type est la racine carrée de la variance.`;
+};
+const getCorrection = (identifiers) => {
+    const { sortedValues, effectifs } = identifiers;
+    const n = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = (0, average_1.averageWithEffectifs)(sortedValues, effectifs);
+    const roundedAvg = (0, round_1.round)(avg, 2);
+    const vce = (0, variance_1.varianceWithEffectifs)(sortedValues, effectifs);
+    const sigma = Math.sqrt(vce);
+    return `La moyenne $\\overline{x}$ de cette série vaut : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `\\overline{x}`,
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times ${e.frenchify()}`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(avg, 2)],
+    ])}
+
+La variance est  donc : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "V",
+            "=",
+            `\\frac{n_1(x_1-\\overline{x})^2 +  \\ldots + n_N(x_N-\\overline{x})^2}{N}`,
+        ],
+        [
+            "",
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times(${e.frenchify()} - ${roundedAvg.frenchify()})^2`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(vce, 2)],
+    ])}
+
+L'écart-type vaut alors : 
+
+$$
+\\sigma = \\sqrt{V} ${(0, approxOrEqual_1.approxOrEqual)(sigma, 2).join("")}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, sqrtVEA_1.sqrtVEA)(ans, answer, { decimalApproxAllowed: 0.01 });
+};
+const getStandardDeviationTableQuestion = (ops) => {
+    const nbValues = (0, randint_1.randint)(4, 7);
+    const values = [];
+    const effectifs = [];
+    for (let i = 0; i < nbValues; i++) {
+        values.push((0, randint_1.randint)(1, 15, values));
+        effectifs.push((0, randint_1.randint)(1, 7));
+    }
+    const identifiers = {
+        sortedValues: values.sort((a, b) => a - b),
+        effectifs,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        style: {
+            tableHasNoHeader: true,
+        },
+    };
+    return question;
+};
+exports.standardDeviationTable = {
+    id: "standardDeviationTable",
+    connector: "=",
+    label: "Calcul de l'écart-type d'un tableau d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getStandardDeviationTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"varianceList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/varianceList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA6GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varianceList = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const variance_1 = require("../../../../math/utils/variance");
+const average_1 = require("../../../../utils/average");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
+const getPropositions = (n, { answer, sortedValues }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)((0, average_1.average)(sortedValues), 2).frenchify());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(3, 10, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const vrc = (0, variance_1.variance)(identifiers.sortedValues, (0, average_1.average)(identifiers.sortedValues));
+    return (0, round_1.round)(vrc, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la variance de la série statistique suivante : 
+  
+$$
+${identifiers.sortedValues.map((e) => e.frenchify()).join("\\ ; \\ ")}
+$$
+
+Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `Si on note $N$ le nombre de valeurs, $\\overline x$ la moyenne de cette liste, et $x_1$, $x_2$, $\\ldots$, $x_N$ les valeurs de la liste, alors la variance est : 
+
+$$
+V = \\frac{(x_1-\\overline{x})^2 + (x_2-\\overline{x})^2 + \\ldots + (x_N-\\overline{x})^2}{N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const n = identifiers.sortedValues.length;
+    const avg = (0, average_1.average)(identifiers.sortedValues);
+    const roundedAvg = (0, round_1.round)(avg, 2);
+    const vce = (0, variance_1.variance)(identifiers.sortedValues, (0, average_1.average)(identifiers.sortedValues));
+    return `La moyenne $\\overline{x}$ de cette série vaut : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `\\overline{x}`,
+            "=",
+            `\\frac{${identifiers.sortedValues
+                .map((e) => e.frenchify())
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(avg, 2)],
+    ])}
+
+La variance est  donc : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "V",
+            "=",
+            `\\frac{(x_1-\\overline{x})^2 + (x_2-\\overline{x})^2 + \\ldots + (x_n-\\overline{x})^2}{N}`,
+        ],
+        [
+            "",
+            "=",
+            `\\frac{${identifiers.sortedValues
+                .map((e) => `(${e.frenchify()} - ${roundedAvg.frenchify()})^2`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(vce, 2)],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getVarianceListQuestion = (ops) => {
+    const nbValues = (0, randint_1.randint)(4, 7);
+    const values = [];
+    for (let i = 0; i < nbValues; i++) {
+        values.push((0, randint_1.randint)(1, 15));
+    }
+    const identifiers = {
+        sortedValues: values.sort((a, b) => a - b),
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.varianceList = {
+    id: "varianceList",
+    connector: "=",
+    label: "Calcul de la variance d'une liste de valeurs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getVarianceListQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"varianceTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/varianceTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA0HF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAiB/C,CAAC"}

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varianceTable = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rationalVEA_1 = require("../../../../exercises/vea/rationalVEA");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const variance_1 = require("../../../../math/utils/variance");
+const average_1 = require("../../../../utils/average");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
+const approxOrEqual_1 = require("../../../../utils/latex/approxOrEqual");
+const mdTable_1 = require("../../../../utils/markdown/mdTable");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(3, 10, 2).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const vce = (0, variance_1.varianceWithEffectifs)(identifiers.sortedValues, identifiers.effectifs);
+    return (0, round_1.round)(vce, 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer la variance de la série statistique suivante : 
+
+${(0, mdTable_1.mdTable)([
+        ["$x_i$", ...identifiers.sortedValues.map((e) => `$${e.frenchify()}$`)],
+        ["$n_i$", ...identifiers.effectifs.map((e) => `$${e.frenchify()}$`)],
+    ])}
+
+Arrondir au centième.`;
+};
+const getHint = (identifiers) => {
+    return `On note : 
+  
+- $N$ le nombre de valeurs de la liste, 
+- $\\overline x$ la moyenne de la liste,
+- $x_1$, $x_2$, $\\ldots$, $x_N$ les valeurs de la liste,
+- $n_1$, $n_2$, $\\ldots$, $n_N$ les effectifs de la liste.
+
+Alors la variance est égale à : 
+
+$$
+V = \\frac{n_1(x_1-\\overline{x})^2  + \\ldots + n_N(x_N-\\overline{x})^2}{N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { sortedValues, effectifs } = identifiers;
+    const n = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = (0, average_1.averageWithEffectifs)(sortedValues, effectifs);
+    const roundedAvg = (0, round_1.round)(avg, 2);
+    const vce = (0, variance_1.varianceWithEffectifs)(sortedValues, effectifs);
+    return `La moyenne $\\overline{x}$ de cette série vaut : 
+  
+${(0, alignTex_1.alignTex)([
+        [
+            `\\overline{x}`,
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times ${e.frenchify()}`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(avg, 2)],
+    ])}
+
+La variance est  donc : 
+
+${(0, alignTex_1.alignTex)([
+        [
+            "V",
+            "=",
+            `\\frac{n_1(x_1-\\overline{x})^2 +  \\ldots + n_N(x_N-\\overline{x})^2}{N}`,
+        ],
+        [
+            "",
+            "=",
+            `\\frac{${sortedValues
+                .map((e, i) => `${effectifs[i].frenchify()}\\times(${e.frenchify()} - ${roundedAvg.frenchify()})^2`)
+                .join("+")}}{${n}}`,
+        ],
+        ["", ...(0, approxOrEqual_1.approxOrEqual)(vce, 2)],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, rationalVEA_1.rationalVEA)(ans, answer);
+};
+const getVarianceTableQuestion = (ops) => {
+    const nbValues = (0, randint_1.randint)(4, 7);
+    const values = [];
+    const effectifs = [];
+    for (let i = 0; i < nbValues; i++) {
+        values.push((0, randint_1.randint)(1, 15, values));
+        effectifs.push((0, randint_1.randint)(1, 7));
+    }
+    const identifiers = {
+        sortedValues: values.sort((a, b) => a - b),
+        effectifs,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        style: {
+            tableHasNoHeader: true,
+        },
+    };
+    return question;
+};
+exports.varianceTable = {
+    id: "varianceTable",
+    connector: "=",
+    label: "Calcul de la variance d'un tableau d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getVarianceTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/vea/sqrtVEA.d.ts

@@ -1,6 +1,7 @@
 type Opts = {
     allowNonIrreductible?: boolean;
+    decimalApproxAllowed?: number;
 };
-export declare const sqrtVEA: (studentAns: string, answer: string, { allowNonIrreductible }?: Opts) => boolean;
+export declare const sqrtVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalApproxAllowed }?: Opts) => boolean;
 export {};
 //# sourceMappingURL=sqrtVEA.d.ts.map

package/lib/exercises/vea/sqrtVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqrtVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/sqrtVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AACF,eAAO,MAAM,OAAO,eACN,MAAM,UACV,MAAM,6BACY,IAAI,YAmB/B,CAAC"}
+{"version":3,"file":"sqrtVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/sqrtVEA.ts"],"names":[],"mappings":"AAMA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AACF,eAAO,MAAM,OAAO,eACN,MAAM,UACV,MAAM,mDACkC,IAAI,YA0BrD,CAAC"}

package/lib/exercises/vea/sqrtVEA.js

@@ -4,20 +4,23 @@ exports.sqrtVEA = void 0;
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const latexParser_1 = require("../../tree/parsers/latexParser");
 const sqrtParser_1 = require("../../tree/parsers/sqrtParser");
-const sqrtVEA = (studentAns, answer, { allowNonIrreductible } = {
+const sqrtVEA = (studentAns, answer, { allowNonIrreductible, decimalApproxAllowed } = {
     allowNonIrreductible: true,
 }) => {
     try {
         allowNonIrreductible = allowNonIrreductible ?? true;
+        decimalApproxAllowed = decimalApproxAllowed ?? 0.0000001;
         const parsed = (0, sqrtParser_1.sqrtParser)(studentAns);
         if (!parsed)
             return false;
         const parsedAnswer = (0, latexParser_1.parseAlgebraic)(answer);
         if ((0, numberNode_1.isNumberNode)(parsed)) {
-            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+            return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                decimalApproxAllowed);
         }
         else if (allowNonIrreductible) {
-            return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
+            return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) <
+                decimalApproxAllowed);
         }
         else {
             return parsed.equals(parsedAnswer);

package/lib/index.d.ts

@@ -236,6 +236,10 @@ declare const mathExercises: (Exercise<{
     affine2: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
     affine3: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers;
     affine4?: import("./math/polynomials/generalAffine").GeneralAffineIdentifiers | undefined;
+}, {}> | Exercise<{
+    type: number;
+    a: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    b: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
 }, {}> | Exercise<{
     randNbr: number;
 }, {}> | Exercise<{
@@ -1389,6 +1393,21 @@ declare const mathExercises: (Exercise<{
     sortedValues: number[];
 }, {}> | Exercise<{
     sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+}, {}> | Exercise<{
+    sortedValues: number[];
+    effectifs: number[];
 }, {}> | Exercise<{
     xValues: number[];
     yValues: 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":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAG1D,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC"}

package/lib/math/utils/quartiles.d.ts

@@ -0,0 +1,3 @@
+export declare const firstQuartile: (values: number[], effectifs?: number[]) => number;
+export declare const thirdQuartile: (values: number[], effectifs?: number[]) => number;
+//# sourceMappingURL=quartiles.d.ts.map

package/lib/math/utils/quartiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../src/math/utils/quartiles.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,WAAY,MAAM,EAAE,cAAc,MAAM,EAAE,WAkBnE,CAAC;AAEF,eAAO,MAAM,aAAa,WAAY,MAAM,EAAE,cAAc,MAAM,EAAE,WAkBnE,CAAC"}

package/lib/math/utils/quartiles.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.thirdQuartile = exports.firstQuartile = void 0;
+const firstQuartile = (values, effectifs) => {
+    if (!values.length)
+        throw Error("Malformed data in firstQuartile");
+    if (!effectifs?.length) {
+        const N = values.length;
+        const rank = Math.ceil(N / 4);
+        return values[rank - 1];
+    }
+    else {
+        const N = effectifs.reduce((acc, curr) => acc + curr, 0);
+        const rank = Math.ceil(N / 4);
+        let s = 0;
+        for (let i = 0; i < effectifs.length; i++) {
+            s += effectifs[i];
+            if (rank <= s) {
+                return values[i];
+            }
+        }
+        return values[values.length - 1];
+    }
+};
+exports.firstQuartile = firstQuartile;
+const thirdQuartile = (values, effectifs) => {
+    if (!values.length)
+        throw Error("Malformed data in thirdQuartile");
+    if (!effectifs?.length) {
+        const N = values.length;
+        const rank = Math.ceil((3 * N) / 4);
+        return values[rank - 1];
+    }
+    else {
+        const N = effectifs.reduce((acc, curr) => acc + curr, 0);
+        const rank = Math.ceil((3 * N) / 4);
+        let s = 0;
+        for (let i = 0; i < effectifs.length; i++) {
+            s += effectifs[i];
+            if (rank <= s) {
+                return values[i];
+            }
+        }
+        return values[values.length - 1];
+    }
+};
+exports.thirdQuartile = thirdQuartile;

package/lib/math/utils/standardDeviation.d.ts

@@ -0,0 +1,3 @@
+export declare const standardDeviation: (values: number[]) => number;
+export declare const standardDeviationWithEffectifs: (values: number[], effectifs: number[]) => number;
+//# sourceMappingURL=standardDeviation.d.ts.map

package/lib/math/utils/standardDeviation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standardDeviation.d.ts","sourceRoot":"","sources":["../../../src/math/utils/standardDeviation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,WAAY,MAAM,EAAE,WAEjD,CAAC;AACF,eAAO,MAAM,8BAA8B,WACjC,MAAM,EAAE,aACL,MAAM,EAAE,WAGpB,CAAC"}

package/lib/math/utils/standardDeviation.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardDeviationWithEffectifs = exports.standardDeviation = void 0;
+const average_1 = require("../../utils/average");
+const variance_1 = require("./variance");
+const standardDeviation = (values) => {
+    return Math.sqrt((0, variance_1.variance)(values, (0, average_1.average)(values)));
+};
+exports.standardDeviation = standardDeviation;
+const standardDeviationWithEffectifs = (values, effectifs) => {
+    return Math.sqrt((0, variance_1.varianceWithEffectifs)(values, effectifs));
+};
+exports.standardDeviationWithEffectifs = standardDeviationWithEffectifs;

package/lib/math/utils/variance.d.ts

@@ -1,4 +1,5 @@
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 export declare function varianceAsNode(xValues: number[], avgX: AlgebraicNode): AlgebraicNode;
 export declare function variance(xValues: number[], avgX: number): number;
+export declare const varianceWithEffectifs: (values: number[], effectifs: number[]) => number;
 //# sourceMappingURL=variance.d.ts.map

package/lib/math/utils/variance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../../src/math/utils/variance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,GAClB,aAAa,CAgBf;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhE"}
+{"version":3,"file":"variance.d.ts","sourceRoot":"","sources":["../../../src/math/utils/variance.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAO/D,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,EAAE,aAAa,GAClB,aAAa,CAgBf;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhE;AAED,eAAO,MAAM,qBAAqB,WACxB,MAAM,EAAE,aACL,MAAM,EAAE,WAapB,CAAC"}

package/lib/math/utils/variance.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.variance = exports.varianceAsNode = void 0;
+exports.varianceWithEffectifs = exports.variance = exports.varianceAsNode = void 0;
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
@@ -25,3 +25,11 @@ function variance(xValues, avgX) {
     return variance / xValues.length;
 }
 exports.variance = variance;
+const varianceWithEffectifs = (values, effectifs) => {
+    if (!values.length || !effectifs.length || values.length !== effectifs.length)
+        throw Error("Malformed data in variance");
+    const N = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = values.reduce((acc, value, index) => acc + value * effectifs[index], 0) / N;
+    return (values.reduce((acc, value, index) => acc + Math.pow(value - avg, 2) * effectifs[index], 0) / N);
+};
+exports.varianceWithEffectifs = varianceWithEffectifs;

package/lib/playground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAoDA,eAAO,MAAM,UAAU,YAAW,CAAC"}
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../src/playground.ts"],"names":[],"mappings":"AAqDA,eAAO,MAAM,UAAU,YAAW,CAAC"}

package/lib/tree/nodes/operators/addNode.js

@@ -368,6 +368,6 @@ const addSimplifyMonoms = (a, b, opts) => {
             return new numberNode_1.NumberNode(0);
         return new monomNode_1.MonomNode(sum, aMonom.degree, {
             variable: aMonom.variable,
-        }).toTree();
+        });
     }
 };

package/lib/tree/nodes/operators/multiplyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAS1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAwErC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAoJ/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}
+{"version":3,"file":"multiplyNode.d.ts","sourceRoot":"","sources":["../../../../src/tree/nodes/operators/multiplyNode.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,EACL,uBAAuB,EACvB,WAAW,EAEZ,MAAM,gBAAgB,CAAC;AAYxB,OAAO,EACL,aAAa,EACb,eAAe,EAEhB,MAAM,kBAAkB,CAAC;AAS1B,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,IAAI,YAAY,CAEzD;AAED,eAAO,MAAM,QAAQ,MAChB,aAAa,GAAG,MAAM,GAAG,MAAM,KAC/B,aAAa,GAAG,MAAM,GAAG,MAAM,SAC3B,WAAW,iBAOnB,CAAC;AACF,eAAO,MAAM,iBAAiB,QAAS,aAAa,EAAE,SAWrD,CAAC;AACF,qBAAa,YAAa,YAAW,uBAAuB;IAC1D,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,WAAW,CAAC;IAChB,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;gBAEjB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,aAAa,EACzB,IAAI,CAAC,EAAE,WAAW;IAUpB,OAAO,aAGL;IAEF,YAAY,IAAI,MAAM;IAItB,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,MAAM;IAwErC,SAAS;IAkDT,iBAAiB,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,YAAY,EAAE;IAyFrD,cAAc,CAAC,IAAI,CAAC,EAAE,WAAW,GAAG,MAAM,EAAE;IAG5C,aAAa;;;;;;;;;IAYb,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAItC,IAAI;IAGJ,cAAc;IACd,QAAQ,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,aAAa;IAiK/C,MAAM,CAAC,IAAI,EAAE,aAAa;IAU1B,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAQxD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa;CAMxD"}