math-exercises 3.0.190 → 3.0.192

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotReadingPercentages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxPlotReadingPercentages.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/boxPlot/boxPlotReadingPercentages.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC,KAAK,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,CAAC;AAElD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,EAAE,aAAa,EAAE,CAAC;IAClC,KAAK,EAAE,YAAY,CAAC;CACrB,CAAC;AA0NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotReadingPercentages.js

@@ -0,0 +1,198 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [0, 25, 50, 75, 100].forEach((percentage) => {
+        tryToAddWrongProp(propositions, percentage.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { arrQuartileIndex } = identifiers;
+    return multiply(substract(arrQuartileIndex[1], arrQuartileIndex[0]), 25)
+        .simplify()
+        .toTex();
+};
+const getFrenchStringForDuQuartile = (quartileIndex) => {
+    switch (quartileIndex) {
+        case 0:
+            return "du minimum";
+        case 1:
+            return "du premier quartile";
+        case 2:
+            return "de la médiane";
+        case 3:
+            return "du troisième quartile";
+        case 4:
+            return "du maximum";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { quartiles, arrQuartileIndex, typeQ } = identifiers;
+    const vMin = quartiles[arrQuartileIndex[0]];
+    const vMax = quartiles[arrQuartileIndex[1]];
+    return `On a représenté une série statistique à une variable sous forme d'une boîte à moustaches.
+${(() => {
+        switch (typeQ) {
+            case "below":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont inférieures ou égales à $${vMax}$ ?`;
+            case "between":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont comprises entre $${vMin}$ et $${vMax}$ ?`;
+            case "above":
+                return `Quelle est la proportion de valeurs (en pourcentage) qui sont supérieures ou égales à $${vMin}$ ?`;
+        }
+    })()}
+`;
+};
+const getHint = () => {
+    return `$25\\%$ des données sont inférieures ou égales au premier quartile ($Q_1$).
+
+$50\\%$ des données sont inférieures ou égales à la médiane ($Q_2$).
+
+$75\\%$ des données sont inférieures ou égales au troisième quartile ($Q_3$).`;
+};
+const getCorrection = (identifiers) => {
+    const { quartiles, arrQuartileIndex, typeQ } = identifiers;
+    const texPercentage = getAnswer(identifiers);
+    switch (typeQ) {
+        case "below":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[1]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[1])}.
+
+La proportion de valeurs inférieures ou égales à $ ${quartiles[arrQuartileIndex[1]]} $ est donc $${texPercentage}\\%$.`;
+        case "between":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[0]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[0])} , et $ ${quartiles[arrQuartileIndex[1]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[1])}.
+
+La proportion de valeurs comprises entre $ ${quartiles[arrQuartileIndex[0]]} $ et $ ${quartiles[arrQuartileIndex[1]]} $ est donc $${texPercentage}\\%$.`;
+        case "above":
+            return `D'après la boîte à moustaches, $ ${quartiles[arrQuartileIndex[0]]} $ est la valeur ${getFrenchStringForDuQuartile(arrQuartileIndex[0])}.
+
+   
+La proportion de valeurs supérieures ou égales à $ ${quartiles[arrQuartileIndex[0]]} $ est donc  $${texPercentage}\\%$.`;
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { quartiles } = identifiers;
+    const [q0, q1, q2, q3, q4] = quartiles;
+    const yOffset = 2;
+    const yScale = 0.8;
+    const commands = [
+        `BM = BoxPlot(${yOffset}, ${yScale}, ${q0}, ${q1}, ${q2}, ${q3}, ${q4})`,
+        `ShowLabel(BM, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: q0,
+            xMax: q4,
+            yMin: -2,
+            yMax: 5,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getBoxPlotReadingPercentagesQuestion = () => {
+    const arrBounds = probaLawFlip([
+        [
+            [
+                { min: 0, max: 8 },
+                { min: 12, max: 20 },
+            ],
+            0.6,
+        ],
+        [
+            [
+                { min: -8, max: 0 },
+                { min: 20, max: 28 },
+            ],
+            0.2,
+        ],
+        [
+            [
+                { min: -20, max: -12 },
+                { min: 0, max: 8 },
+            ],
+            0.2,
+        ],
+    ]);
+    const [q0, q1] = [0, 1]
+        .map((_) => randint(arrBounds[0].min, arrBounds[0].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const [q3, q4] = [0, 1]
+        .map((_) => randint(arrBounds[1].min, arrBounds[1].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const q2 = randint(q1, q3, [q1]); //we prevent q2 from being equal to q1 or q3
+    const quartiles = [q0, q1, q2, q3, q4];
+    const arrQuartileIndexAvailable = [
+        0,
+        ...(q0 !== q1 ? [1] : []),
+        2,
+        ...(q3 !== q4 ? [3] : []),
+        4,
+    ];
+    const arrQuartileIndex = randomMany(arrQuartileIndexAvailable, 2).toSorted((i1, i2) => i1 - i2);
+    const typeQ = random([
+        ...(arrQuartileIndex[0] === 0 ? ["below"] : []),
+        "between",
+        ...(arrQuartileIndex[1] === 4 ? ["above"] : []),
+    ]);
+    const identifiers = { quartiles, arrQuartileIndex, typeQ };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const boxPlotReadingPercentages = {
+    id: "boxPlotReadingPercentages",
+    label: "Lire des proportions sur une boîte à moustaches",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoxPlotReadingPercentagesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/dataRepresentations/boxPlot/compareBoxPlot.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    indexTopic: number;
+    isLess: boolean;
+    arrDistrib: Distrib[];
+};
+type Distrib = {
+    name: string;
+    indicators: number[];
+};
+export declare const compareBoxPlot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareBoxPlot.d.ts.map

package/lib/exercises/math/dataRepresentations/boxPlot/compareBoxPlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareBoxPlot.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/boxPlot/compareBoxPlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAKF,KAAK,OAAO,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8PF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}

package/lib/exercises/math/dataRepresentations/boxPlot/compareBoxPlot.js

@@ -0,0 +1,192 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueDark, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+const distribNames = ["A", "B"];
+const colors = [blueDark, red];
+class Topic {
+    type;
+    questions1;
+    funcIndicator;
+    constructor(type, questions1, funcIndicator) {
+        this.type = type;
+        this.questions1 = questions1;
+        this.funcIndicator = funcIndicator;
+    }
+    getQuestion(isLess) {
+        return `Quelle série a ${this.getFrenchStringForTheMoreOrLessIndicator(isLess)} ?`;
+    }
+    getFrenchStringForTheMoreOrLessIndicator(isLess) {
+        return this.questions1[isLess ? 0 : 1];
+    }
+    compare(d1, d2) {
+        return this.funcIndicator(d1) - this.funcIndicator(d2);
+    }
+    isCompatibleWithArrDistrib(arrDistrib) {
+        const arrIndicator = arrDistrib.map((d) => this.funcIndicator(d));
+        return arrIndicator[1] !== arrIndicator[0];
+    }
+}
+const arrTopic = [
+    new Topic("l'étendue", ["la plus petite étendue", "la plus grande étendue"], (d) => d.indicators[4] - d.indicators[0]),
+    new Topic("l'écart interquartile", ["le plus petit écart interquartile", "le plus grand écart interquartile"], (d) => d.indicators[3] - d.indicators[1]),
+    new Topic("le minimum", ["le minimum le plus petit", "le minimum le plus grand"], (d) => d.indicators[0]),
+    new Topic("la médiane", ["la plus petite médiane", "la plus grande médiane"], (d) => d.indicators[2]),
+    new Topic("le maximum", ["le maximum le plus petit", "le maximum le plus grand"], (d) => d.indicators[4]),
+];
+const createRandomDistrib = (name, min = 5, max = 20) => {
+    const indicators = randomMany([...Array(max - min + 1).keys()].map((i) => i + min), 5).toSorted((i1, i2) => i1 - i2);
+    const d = {
+        name,
+        indicators: indicators,
+    };
+    return d;
+};
+const getPropositions = (n, { answer, arrDistrib }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    arrDistrib.forEach((d) => {
+        tryToAddWrongProp(propositions, d.name);
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { indexTopic, isLess: isLess, arrDistrib } = identifiers;
+    const topic = arrTopic[indexTopic];
+    const funcCompare = (d1, d2) => isLess ? topic.compare(d1, d2) : topic.compare(d2, d1);
+    const arrDistribSorted = arrDistrib.toSorted(funcCompare);
+    const distribAnswer = arrDistribSorted[0];
+    return distribAnswer.name;
+};
+const getInstruction = (identifiers) => {
+    const { indexTopic, isLess: isLess, arrDistrib } = identifiers;
+    return `Voici $${arrDistrib.length}$ boîtes à moustaches, chacune représentant une série statistique spécifique.
+
+${arrTopic[indexTopic].getQuestion(isLess)}`;
+};
+const getHint = () => {
+    return `Une boite à moustaches permet de lire les indicateurs statistiques d'une série :
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/boxplot.png)
+`;
+};
+const getCorrection = (identifiers) => {
+    const { indexTopic, isLess: isLess, arrDistrib } = identifiers;
+    const topic = arrTopic[indexTopic];
+    return `${arrDistrib.map((d) => `Pour la série $${d.name}$, ${topic.type} vaut $${topic
+        .funcIndicator(d)
+        .frenchify()}$.`).join(`
+
+`)}
+
+
+C'est donc la série $${getAnswer(identifiers)}$ qui a ${topic.getFrenchStringForTheMoreOrLessIndicator(isLess)}.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { arrDistrib } = identifiers;
+    const yPaddingPure = 3;
+    const yAltitude0Pure = 5;
+    const yScale = 4;
+    const yPadding = yPaddingPure + yScale;
+    const yAltitude0 = yAltitude0Pure + yScale / 2;
+    const xMin = Math.min(...arrDistrib.map((d) => d.indicators[0]));
+    const xMax = Math.max(...arrDistrib.map((d) => d.indicators[4]));
+    const yMin = -yAltitude0;
+    const yMax = yAltitude0 + arrDistrib.length * yPadding;
+    const xLabel = xMin - 2;
+    function createBoxPlotCommands(d, color, yOffset, yScale, xLabel) {
+        const [q0, q1, q2, q3, q4] = d.indicators;
+        const commands = [
+            `B_${d.name} = BoxPlot(${yOffset}, ${yScale}, ${q0}, ${q1}, ${q2}, ${q3}, ${q4})`,
+            `SetColor(B_${d.name}, "${color}")`,
+            `ShowLabel(B_${d.name}, false)`,
+            `T_${d.name} = Text("\\footnotesize ${d.name}", (${xLabel},${yOffset + 4}), true, true)`,
+            `SetColor(T_${d.name}, "${color}")`,
+        ];
+        return commands;
+    }
+    const commands = arrDistrib.flatMap((d, i) => createBoxPlotCommands(d, colors[i], yAltitude0 + (yPadding + yScale) * i, yScale, xLabel));
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        hideGrid: true,
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: [xMin - 5, xMax + 5, yMin - 5, yMax + 5],
+    });
+};
+const getBoxPlotReadingQuestion = () => {
+    const nbDistri = 2;
+    const nbInAnswer = 1;
+    const genParams = {
+        min: 0,
+        max: 20,
+        nbUniqueValues: 7,
+        minCount: 1,
+        maxCount: 5,
+    };
+    const isLess = coinFlip();
+    let indexTopic;
+    let isQuestionOk = false;
+    let counter = 0;
+    let arrDistrib;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("Too many iterations in compareBoxPlot");
+        arrDistrib = [...Array(nbDistri).keys()].map((i) => {
+            const name = distribNames[i];
+            const d = createRandomDistrib(name, genParams.min, genParams.max);
+            return d;
+        });
+        indexTopic = randint(0, arrTopic.length);
+        const topic = arrTopic[indexTopic];
+        isQuestionOk = topic.isCompatibleWithArrDistrib(arrDistrib);
+    } while (!isQuestionOk);
+    const identifiers = { nbInAnswer, indexTopic, isLess, arrDistrib };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const compareBoxPlot = {
+    id: "compareBoxPlot",
+    label: "Comparer des séries à l'aide de boîtes à moustaches",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getBoxPlotReadingQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/dataRepresentations/boxPlot/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./boxPlotInterpreting.js";
+export * from "./boxPlotReading.js";
+export * from "./boxPlotReadingPercentages.js";
+export * from "./compareBoxPlot.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/dataRepresentations/boxPlot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/boxPlot/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/dataRepresentations/boxPlot/index.js

@@ -0,0 +1,4 @@
+export * from "./boxPlotInterpreting.js";
+export * from "./boxPlotReading.js";
+export * from "./boxPlotReadingPercentages.js";
+export * from "./compareBoxPlot.js";

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

@@ -1,15 +1,12 @@
-export * from "./tableReading.js";
-export * from "./barChartReading.js";
+export * from "./tables/index.js";
+export * from "./barChart/index.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
-export * from "./boxPlotReadingPercentages.js";
-export * from "./boxPlotReading.js";
-export * from "./compareBoxPlot.js";
-export * from "./barChartInterpreting.js";
+export * from "./barChart/barChartInterpreting.js";
 export * from "./dataToGraphGraphToData.js";
 export * from "./cartesianGraphExtremaReading.js";
 export * from "./scatterPlotCommenting.js";
-export * from "./boxPlotInterpreting.js";
+export * from "./boxPlot/index.js";
 export * from "./graphReading.js";
 export * from "./plausibleGraph.js";
 export * from "./halfPieChartReading.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC"}

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

@@ -1,22 +1,15 @@
-export * from "./tableReading.js";
-export * from "./barChartReading.js";
+export * from "./tables/index.js";
+export * from "./barChart/index.js";
 export * from "./functionGraphReading.js";
 export * from "./pieChartReading.js";
-export * from "./boxPlotReadingPercentages.js";
-export * from "./boxPlotReading.js";
-export * from "./compareBoxPlot.js";
-export * from "./barChartInterpreting.js";
+export * from "./barChart/barChartInterpreting.js";
 export * from "./dataToGraphGraphToData.js";
 export * from "./cartesianGraphExtremaReading.js";
 export * from "./scatterPlotCommenting.js";
-export * from "./boxPlotInterpreting.js";
+export * from "./boxPlot/index.js";
 export * from "./graphReading.js";
 export * from "./plausibleGraph.js";
 export * from "./halfPieChartReading.js";
 export * from "./halfPieChartCommenting.js";
 export * from "./histogram/index.js";
 // export * from "./placePointsFromDataTable.js";
-// export * from "./testGen.js";
-// export * from "./testGenGGB.js";
-// export * from "./testGenStudentGGB.js";
-// export * from "./testGGB.js";

package/lib/exercises/math/dataRepresentations/scatterPlot/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./scatterPlotCommenting.js";
+export * from "./scatterPlotFillDataTableFromScatterPlotData.js";
+export * from "./scatterPlotFillDataTableWithDataClassesFromScatterPlotData.js";
+export * from "./scatterPlotInterpreting.js";
+export * from "./scatterPlotBuildScatterPlotFromDataTable.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/dataRepresentations/scatterPlot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kDAAkD,CAAC;AACjE,cAAc,iEAAiE,CAAC;AAChF,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+CAA+C,CAAC"}

package/lib/exercises/math/dataRepresentations/scatterPlot/index.js

@@ -0,0 +1,5 @@
+export * from "./scatterPlotCommenting.js";
+export * from "./scatterPlotFillDataTableFromScatterPlotData.js";
+export * from "./scatterPlotFillDataTableWithDataClassesFromScatterPlotData.js";
+export * from "./scatterPlotInterpreting.js";
+export * from "./scatterPlotBuildScatterPlotFromDataTable.js";

package/lib/exercises/math/dataRepresentations/scatterPlot/scatterPlotBuildScatterPlotFromDataTable.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    isRowBased: boolean;
+    rowBasedDataTable: string[][];
+    indexX: number;
+    indexY: number;
+    arrCoordsAsNodeIds: NodeIdentifiers[][];
+};
+export declare const scatterPlotBuildScatterPlotFromDataTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotBuildScatterPlotFromDataTable.d.ts.map

package/lib/exercises/math/dataRepresentations/scatterPlot/scatterPlotBuildScatterPlotFromDataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotBuildScatterPlotFromDataTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotBuildScatterPlotFromDataTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,eAAe,EAAE,EAAE,CAAC;CACzC,CAAC;AA0QF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}