math-exercises 3.0.189 → 3.0.191

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

@@ -0,0 +1,352 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenDark, greenLight, orange } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getComponentOfPointForStrGroupBy = (point, strGroupBy) => {
+    switch (strGroupBy) {
+        case "x":
+            return point.x;
+        case "y":
+            return point.y;
+        default:
+            throw new Error("Unsupported strGroupBy: " + strGroupBy);
+    }
+};
+const getInstruction = () => {
+    return `Remplir le tableau avec les données issues du nuage de points ci-dessous 
+(les classes sont déjà inscrites dans le tableau).`;
+};
+const getInitTable = (identifiers) => {
+    const { strGroupBy, isTransposed, nodeIdsDataClasses } = identifiers;
+    const arrDataClass = nodeIdsDataClasses.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const tableRaw = [
+        [`$${strGroupBy}$`, ...arrDataClass.map(() => `\\ `)],
+        [
+            "\\text{classe}",
+            ...arrDataClass.map((intervalNode) => intervalNode.toTex()),
+        ],
+        ["\\text{effectif}", ...arrDataClass.map(() => "")],
+    ];
+    return isTransposed ? transpose(tableRaw) : tableRaw;
+};
+const getAnswerTable = (identifiers) => {
+    const { pointIds, strGroupBy, isTransposed, nodeIdsDataClasses } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrDataClass = nodeIdsDataClasses.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrCount = arrDataClass.map((intervalNode) => {
+        return arrPoint.filter((point) => {
+            const nodeComponent = getComponentOfPointForStrGroupBy(point, strGroupBy);
+            return intervalNode.includes(nodeComponent);
+        }).length;
+    });
+    const tableRaw = [
+        [`$${strGroupBy}$`, ...arrDataClass.map(() => `\\ `)],
+        [
+            "\\text{classe}",
+            ...arrDataClass.map((intervalNode) => intervalNode.toTex()),
+        ],
+        ["\\text{effectif}", ...arrCount.map((v) => v.frenchify())],
+    ];
+    return isTransposed ? transpose(tableRaw) : tableRaw;
+};
+const getHint = (identifiers) => {
+    const { strGroupBy } = identifiers;
+    return `Pour chaque classe de $${strGroupBy}$, on compte le nombre de points qui ont $${strGroupBy}$ qui appartient à la classe.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds, strGroupBy, nodeIdsDataClasses } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrDataClass = nodeIdsDataClasses.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrCount = arrDataClass.map((intervalNode) => {
+        return arrPoint.filter((point) => {
+            const nodeComponent = getComponentOfPointForStrGroupBy(point, strGroupBy);
+            return intervalNode.includes(nodeComponent);
+        }).length;
+    });
+    return `Pour chaque classe de $${strGroupBy}$, on compte le nombre de points qui ont $${strGroupBy}$ qui appartient à la classe.
+
+${zip(arrDataClass, arrCount).map(([intervalNode, count]) => `Il y a $${count}$ point${count === 1 ? "" : "s"} qui ${count === 1 ? "a" : "ont"} $${strGroupBy}$ dans $${intervalNode.toTex()}$.`).join(`
+
+`)}`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointIds, strGroupBy, nodeIdsDataClasses } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrDataClass = nodeIdsDataClasses.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrArrPoint = arrDataClass.map((intervalNode) => {
+        return arrPoint.filter((point) => {
+            const nodeComponent = getComponentOfPointForStrGroupBy(point, strGroupBy);
+            return intervalNode.includes(nodeComponent);
+        });
+    });
+    const commands = [
+        ...arrArrPoint.flatMap((arrPoint, i) => arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: false,
+            size: 6,
+            style: 3,
+            color: i % 2 === 0 ? greenDark : greenLight,
+        }))),
+        ...(() => {
+            switch (strGroupBy) {
+                case "x":
+                    return arrDataClass.flatMap((nodeInterval, i) => {
+                        return [
+                            ...(() => {
+                                if (nodeInterval.closure === ClosureType.FF ||
+                                    nodeInterval.closure === ClosureType.FO) {
+                                    const value = nodeInterval.a.evaluate();
+                                    return [
+                                        `l${i}l = Line((${value}, 0),(${value}, 1))`,
+                                        `SetColor(l${i}l, "${orange}")`,
+                                    ];
+                                }
+                                else {
+                                    return [];
+                                }
+                            })(),
+                            ...(() => {
+                                if (nodeInterval.closure === ClosureType.FF ||
+                                    nodeInterval.closure === ClosureType.OF) {
+                                    const value = nodeInterval.b.evaluate();
+                                    return [
+                                        `l${i}h = Line((${value}, 0),(${value}, 1))`,
+                                        `SetColor(l${i}h, "${orange}")`,
+                                    ];
+                                }
+                                else {
+                                    return [];
+                                }
+                            })(),
+                        ];
+                    });
+                case "y":
+                    return arrDataClass.flatMap((nodeInterval, i) => {
+                        return [
+                            ...(() => {
+                                if (nodeInterval.closure === ClosureType.FF ||
+                                    nodeInterval.closure === ClosureType.FO) {
+                                    const value = nodeInterval.a.evaluate();
+                                    return [
+                                        `l${i}l = Line((0, ${value}),(1,${value}))`,
+                                        `SetColor(l${i}l, "${orange}")`,
+                                    ];
+                                }
+                                else {
+                                    return [];
+                                }
+                            })(),
+                            ...(() => {
+                                if (nodeInterval.closure === ClosureType.FF ||
+                                    nodeInterval.closure === ClosureType.OF) {
+                                    const value = nodeInterval.b.evaluate();
+                                    return [
+                                        `l${i}h = Line((0, ${value}),(1,${value}))`,
+                                        `SetColor(l${i}h, "${orange}")`,
+                                    ];
+                                }
+                                else {
+                                    return [];
+                                }
+                            })(),
+                        ];
+                    });
+                default:
+                    throw new Error("Unsupported strGroupBy: " + strGroupBy);
+            }
+        })(),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        fontSize: 16,
+        xAxis: {
+            showPositive: true,
+            label: "x",
+            steps: 1,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "y",
+            steps: 1,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -1,
+            xMax: 6,
+            yMin: -1,
+            yMax: 6,
+        }),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { pointIds } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const commands = [
+        ...arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: false,
+            size: 5,
+            style: 3,
+        })),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: false,
+        fontSize: 16,
+        xAxis: {
+            showPositive: true,
+            label: "x",
+            steps: 1,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "y",
+            steps: 1,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -1,
+            xMax: 6,
+            yMin: -1,
+            yMax: 6,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return answerTable[2].every((answer, i) => {
+            const ansParsed = numberParser(ans[2][i]);
+            const answerParsed = numberParser(answer);
+            return ansParsed === answerParsed;
+        });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScatterPlotFillDataTableWithDataClassesFromScatterPlotDataQuestion = () => {
+    const length = 6;
+    const height = 6;
+    const arrArrDict1 = getCartesiansProducts([
+        [...Array(length).keys()].map((i) => i + 1),
+        [...Array(height).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x,
+            y,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    const arrArrDict2 = getCartesiansProducts([
+        [...Array(length - 1).keys()].map((i) => i + 1),
+        [...Array(height - 1).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x: x + 0.333,
+            y: y + 0.333,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    const arrArrDict3 = getCartesiansProducts([
+        [...Array(length - 1).keys()].map((i) => i + 1),
+        [...Array(height - 1).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x: x + 0.666,
+            y: y + 0.666,
+            isActivated: probaFlip(0.14),
+        };
+    });
+    //at least one point should be activated
+    {
+        const dictRandom = random(arrArrDict1);
+        dictRandom.isActivated = true;
+    }
+    const arrPoint = [...arrArrDict1, ...arrArrDict2, ...arrArrDict3]
+        .filter(({ isActivated }) => isActivated)
+        .map(({ x, y }, i) => new Point(`P${i}`, x, y));
+    const strGroupBy = coinFlip() ? "x" : "y";
+    const isTransposed = coinFlip();
+    const templateArrLengthDataClass = probaLawFlip([
+        [[1, 1, 1, 2], 0.2],
+        [[1, 2, 2], 0.4],
+        [[1, 1, 3], 0.3],
+        [[2, 3], 0.1],
+    ]);
+    const arrLengthDataClass = shuffle(templateArrLengthDataClass);
+    const arrDataClass = arrLengthDataClass.reduce((acc, lengthDataClass, i, arr) => {
+        const nodeBoundLow = acc.nodeBoundLowWork;
+        const nodeBoundHigh = add(nodeBoundLow, lengthDataClass).simplify({
+            towardsDistribute: true,
+        });
+        const nodeDataClass = new IntervalNode(nodeBoundLow, nodeBoundHigh, i === arr.length - 1 ? ClosureType.FF : ClosureType.FO);
+        acc.dataClasses.push(nodeDataClass);
+        acc.nodeBoundLowWork = nodeBoundHigh;
+        return acc;
+    }, {
+        nodeBoundLowWork: (1).toTree(),
+        dataClasses: [],
+    }).dataClasses;
+    const identifiers = {
+        pointIds: arrPoint.map((point) => point.toIdentifiers()),
+        strGroupBy,
+        isTransposed,
+        nodeIdsDataClasses: arrDataClass.map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        initTable: getInitTable(identifiers),
+        answerTable: getAnswerTable(identifiers),
+        answerFormat: "tex",
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const scatterPlotFillDataTableWithDataClassesFromScatterPlotData = {
+    id: "scatterPlotFillDataTableWithDataClassesFromScatterPlotData",
+    label: "Remplir un tableau avec les données issues d'un nuage de points (avec des classes)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScatterPlotFillDataTableWithDataClassesFromScatterPlotDataQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    isAnswerTableValid,
+    getAnswerTable,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointIds: PointIdentifiers[];
+    strGroupBy: string;
+    nodeIdsDataClass: NodeIdentifiers;
+};
+export declare const scatterPlotInterpreting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotInterpreting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotInterpreting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwC7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,eAAe,CAAC;CACnC,CAAC;AA2aF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAmBzD,CAAC"}