math-exercises 3.0.190 → 3.0.192

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

@@ -0,0 +1,206 @@
+import { randomDataTable } from "../../../../exercises/utils/data/randomDataTable.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const getStrGraphName = (identifiers) => {
+    const { rowBasedDataTable, indexX, indexY } = identifiers;
+    const [nameTexX, nameTexY] = [indexX, indexY].map((i) => rowBasedDataTable[i][0]);
+    const graphName = `${nameTexY} en fonction de ${nameTexX}`;
+    return graphName;
+};
+const getDataTable = (identifiers) => {
+    const { isRowBased, rowBasedDataTable } = identifiers;
+    return isRowBased ? rowBasedDataTable : transpose(rowBasedDataTable);
+};
+const getInstruction = (identifiers) => {
+    return `À partir du tableau de données ci-dessous, construire le nuage de points "${getStrGraphName(identifiers)}".
+
+${mdTable(getDataTable(identifiers))}
+  
+`;
+};
+const getHint = () => {
+    return `Quand on construit un nuage de points "$u$ en fonction de $v$", $u$ se lira sur l'axe des ordonnées et $v$ sur l'axe des abscisses.`;
+};
+const getCorrection = (identifiers) => {
+    const { rowBasedDataTable, indexX, indexY } = identifiers;
+    const [nameTexX, nameTexY] = [indexX, indexY].map((i) => rowBasedDataTable[i][0]);
+    const solutionPoints = getSolutionPoints(identifiers);
+    return `On place chaque point de coordonnées (${nameTexX};${nameTexY}).
+  
+On place donc les points de coordonnées ${joinanded(solutionPoints.map((p) => `$(${p.x.toTex()};${p.y.toTex()})$`), ", ", " et ")}.`;
+};
+const getSolutionPoints = (identifiers) => {
+    const { arrCoordsAsNodeIds } = identifiers;
+    const arrCoordsAsNodes = arrCoordsAsNodeIds.map(([nodeIdsX, nodeIdsY]) => [nodeIdsX, nodeIdsY].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+    return arrCoordsAsNodes.map(([nodeX, nodeY], i) => {
+        return new Point(`S_${i}`, nodeX, nodeY);
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    return [
+        ...solutionPoints.flatMap((point) => point.toGGBCommand({ color: `${greenMain}`, showLabel: false })),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { indexX, indexY, rowBasedDataTable } = identifiers;
+    const [nameTexX, nameTexY] = [indexX, indexY].map((i) => rowBasedDataTable[i][0]);
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        forbidShiftDragZoom: true,
+        xAxis: {
+            label: nameTexX,
+            steps: 1,
+        },
+        yAxis: {
+            label: nameTexY,
+            steps: 1,
+        },
+    });
+    return ggb.getOptions({
+        coords: [-1, 7, -1, 7],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const pointsCoords = Object.keys(objectDict).map((name) => ggbParser.pointCoords(name));
+    const pointsCoordsSortedByAscXSortedByAscY = pointsCoords
+        .toSorted(([x1], [x2]) => {
+        return x1 - x2;
+    })
+        .toSorted(([_x1, y1], [_x2, y2]) => {
+        return y1 - y2;
+    });
+    const solutionPointsSortedByAscXSortedByAscY = getSolutionPoints(identifiers)
+        .toSorted((p1, p2) => {
+        return p1.x.evaluate() - p2.x.evaluate();
+    })
+        .toSorted((p1, p2) => {
+        return p1.y.evaluate() - p2.y.evaluate();
+    });
+    return (pointsCoordsSortedByAscXSortedByAscY.length ===
+        solutionPointsSortedByAscXSortedByAscY.length &&
+        pointsCoordsSortedByAscXSortedByAscY.every(([x, y], i) => {
+            const studentPoint = new Point("StudentPoint", x, y);
+            const solutionPoint = solutionPointsSortedByAscXSortedByAscY[i];
+            const distance = studentPoint.distanceTo(solutionPoint);
+            return distance < 1;
+        }));
+};
+const getScatterPlotBuildScatterPlotFromDataTableQuestion = () => {
+    function createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY) {
+        const [nodesX, nodesY] = [indexX, indexY].map((i) => rowBasedDataTable[i]
+            .slice(1)
+            .map((strValue) => parseAlgebraic(strValue)));
+        const arrCoordsAsNodes = nodesX.map((nodeX, i) => {
+            const nodeY = nodesY[i];
+            return [nodeX, nodeY];
+        });
+        return arrCoordsAsNodes;
+    }
+    const isRowBased = coinFlip();
+    const nbValues = 4;
+    const dictCateg = {
+        a: {
+            nameTex: "a",
+            gen: (min = 1, max = 6) => Math.max(min, Math.min(max, randint(min, max + 1))),
+        },
+        b: {
+            nameTex: "b",
+            gen: (min = 1, max = 6) => Math.max(min, Math.min(max, randint(min, max + 1))),
+        },
+        c: {
+            nameTex: "c",
+            gen: (min = 1, max = 6) => Math.max(min, Math.min(max, randint(min, max + 1))),
+        },
+    };
+    let rowBasedDataTable = [];
+    let indexX = -1;
+    let indexY = -1;
+    let arrCoordsAsNodes = [];
+    let counter = -1;
+    let isValidTable = false;
+    while (!isValidTable && counter < 100) {
+        counter++;
+        const arrCategAndValues = Object.values(dictCateg).map((categ) => {
+            return {
+                categ,
+                values: [...Array(nbValues).keys()].map(() => categ.gen()),
+            };
+        });
+        rowBasedDataTable = randomDataTable(arrCategAndValues, true);
+        [indexX, indexY] = randomMany([...Array(rowBasedDataTable.length).keys()], 2);
+        arrCoordsAsNodes = createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY);
+        const arrXY = arrCoordsAsNodes.map(([nodeX, nodeY]) => [nodeX, nodeY].map((node) => node.evaluate()));
+        const isDuplicateData = () => [...new Set(arrXY.map(([x, y]) => `${x};${y}`))].length < arrXY.length;
+        isValidTable = !isDuplicateData();
+    }
+    if (!isValidTable) {
+        rowBasedDataTable = [
+            ["a", "3", "2", "3"],
+            ["b", "1", "2", "3"],
+            ["c", "1", "1", "2"],
+        ];
+        [indexX, indexY] = [0, 1];
+        arrCoordsAsNodes = createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY);
+    }
+    const identifiers = {
+        isRowBased,
+        rowBasedDataTable,
+        indexX,
+        indexY,
+        arrCoordsAsNodeIds: arrCoordsAsNodes.map(([nodeX, nodeY]) => [nodeX, nodeY].map((node) => node.toIdentifiers())),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstCellIsDivided: false,
+                firstColumnIsHeader: identifiers.isRowBased,
+                firstRowIsHeader: !identifiers.isRowBased,
+            },
+        },
+    };
+};
+export const scatterPlotBuildScatterPlotFromDataTable = {
+    id: "scatterPlotBuildScatterPlotFromDataTable",
+    label: "Construire un nuage de points à partir d'un tableau de données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScatterPlotBuildScatterPlotFromDataTableQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { CloudPointsIdentifiers } from "../../../../math/geometry/CloudPoints.js";
+type Identifiers = {
+    cloudPointsIdentifiers: CloudPointsIdentifiers;
+    evolutionType: string;
+};
+export declare const scatterPlotCommenting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotCommenting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotCommenting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAK5C,KAAK,WAAW,GAAG;IACjB,sBAAsB,EAAE,sBAAsB,CAAC;IAC/C,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAmQF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -0,0 +1,210 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { CloudPoints, CloudPointsConstructor, } from "../../../../math/geometry/CloudPoints.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const countries = [
+    "Lusitalie",
+    "Franemagne",
+    "Esprèce",
+    "Belgarie",
+    "Slovégal",
+    "Finlange",
+    "Suénemark",
+    "Cromanie",
+    "Polgique",
+    "Maltonie",
+];
+const getInstruction = () => {
+    return `Observe ce nuage de points.
+  
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
+};
+const getHint = () => {
+    return `Regarde si les points semblent respecter une règle ou bien pas du tout.`;
+};
+const getCorrection = (identifiers) => {
+    const { evolutionType, cloudPointsIdentifiers } = identifiers;
+    const allValidProps = propsForEvolutionType[evolutionType];
+    const cloudPoints = CloudPointsConstructor.fromIdentifiers(cloudPointsIdentifiers);
+    return `Voici tout ce que l'on peut dire sur ce nuage de points : 
+  
+${allValidProps.join(`
+  
+`)}
+
+${(() => {
+        switch (evolutionType) {
+            case "increasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une faible croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une forte croissance du PIB.`;
+            }
+            case "decreasing": {
+                const [pointLowX, pointHighX] = cloudPoints.points.toSorted((p1, p2) => p1.x.evaluate() - p2.x.evaluate());
+                return `En particulier :
+      
+Le pays ${pointLowX.name} a un faible taux de chômage et une forte croissance du PIB.
+        
+Le pays ${pointHighX.name} a un fort taux de chômage et une faible croissance du PIB.`;
+            }
+            case "unpredictible": {
+                return `En effet, 
+il y a des pays avec un taux de chômage faible et une croissance faible,
+il y a des pays avec un taux de chômage faible et une croissance forte,
+il y a des pays avec un taux de chômage fort et une croissance faible,
+il y a des pays avec un taux de chômage fort et une croissance forte.
+`;
+            }
+            default:
+                return ``;
+        }
+    })()}`;
+};
+const propsForEvolutionType = {
+    increasing: [
+        `Plus le taux de chômage est élevé et plus la croissance du PIB est élevée.`,
+    ],
+    decreasing: [
+        `Plus le taux de chômage est élevé et plus la croissance du PIB est faible.`,
+    ],
+    unpredictible: [
+        `Il n'y a aucun lien entre le taux de chômage et la croissance du PIB.`,
+    ],
+    increasingThenDecreasing: [],
+    decreasingThenIncreasing: [],
+};
+const getPropositions = (n, { evolutionType }) => {
+    const propositions = [];
+    const allValidProps = propsForEvolutionType[evolutionType];
+    const validPropsPicked = randomMany(propsForEvolutionType[evolutionType], randint(1, propsForEvolutionType[evolutionType].length + 1));
+    validPropsPicked.forEach((str) => {
+        addValidProp(propositions, str, "raw");
+    });
+    const invalidProps = [
+        ...Object.values(propsForEvolutionType).flatMap((props) => props),
+    ].filter((prop) => !allValidProps.includes(prop));
+    invalidProps.forEach((str) => {
+        tryToAddWrongProp(propositions, str, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getGGBOptions = (identifiers) => {
+    const { cloudPointsIdentifiers } = identifiers;
+    const cloudPoints = new CloudPoints(cloudPointsIdentifiers.pointsIdentifiers.map((i) => PointConstructor.fromIdentifiers(i)));
+    const commands = cloudPoints.points.flatMap((point, i) => {
+        return [
+            `${point.name}=Point({${point.getXnumber()},${point.getYnumber()}})`,
+            `SetFixed(${point.name},true, false)`,
+            `Lbl_{${i}} = Text("\\tiny ${point.name}", (${point.x.toMathString()},${point.y.evaluate() + 0.7}), true, true, 0, 0)`,
+            `SetFixed(Lbl_{${i}},true, false)`,
+        ];
+    });
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: false,
+        hideGrid: false,
+        xAxis: {
+            steps: 1,
+            label: "Chômage (%)",
+        },
+        yAxis: {
+            steps: 0.5,
+            label: "Croissance du PIB (%)",
+        },
+        fontSize: 15,
+    });
+    const xValues = cloudPoints.points.map((element) => {
+        return element.getXnumber();
+    });
+    const yValues = cloudPoints.points.map((element) => {
+        return element.getYnumber();
+    });
+    const xMin = Math.min(...xValues);
+    const xMax = Math.max(...xValues);
+    const yMin = Math.min(...yValues);
+    const yMax = Math.max(...yValues);
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+    });
+};
+const getScatterPlotCommentingQuestion = () => {
+    const nbCountries = 6;
+    const countriesPicked = randomMany(countries, nbCountries);
+    const boxFull = { xMin: 3, xMax: 13, yMin: 0, yMax: 4 };
+    const evolutionType = random(["increasing", "decreasing", "unpredictible"]);
+    let cloudPointsWithEvoBoxed;
+    switch (evolutionType) {
+        case "increasing":
+        case "decreasing":
+            {
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountries, evolutionType), boxFull);
+            }
+            break;
+        case "unpredictible":
+        default:
+            {
+                const nbCountriesTop = Math.floor(nbCountries / 2);
+                const nbCountriesBottom = nbCountries - nbCountriesTop;
+                const cloudPointsTop = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesTop, "scatter"), {
+                    xMin: 0,
+                    xMax: 1,
+                    yMin: 0.7,
+                    yMax: 1,
+                });
+                const cloudPointsBottom = CloudPointsConstructor.cloudPointsByReboxingCloudPoints(CloudPointsConstructor.randomWithEvolutionType(nbCountriesBottom, "scatter"), {
+                    xMin: 0,
+                    xMax: 1,
+                    yMin: 0,
+                    yMax: 0.3,
+                });
+                cloudPointsWithEvoBoxed =
+                    CloudPointsConstructor.cloudPointsByReboxingCloudPoints(new CloudPoints([
+                        ...cloudPointsTop.points,
+                        ...cloudPointsBottom.points,
+                    ]), boxFull);
+            }
+            break;
+    }
+    const namedPoints = cloudPointsWithEvoBoxed.points.map((point, i) => new Point(countriesPicked[i], point.x, point.y));
+    const cloudPointsNamed = new CloudPoints(namedPoints);
+    const identifiers = {
+        cloudPointsIdentifiers: cloudPointsNamed.toIdentifiers(),
+        evolutionType,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const scatterPlotCommenting = {
+    id: "scatterPlotCommenting",
+    label: "Commenter un nuage de points",
+    isSingleStep: true,
+    hasGeogebra: true,
+    generator: (nb) => getDistinctQuestions(getScatterPlotCommentingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    getHint,
+    getCorrection,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointIds: PointIdentifiers[];
+    strGroupBy: string;
+    isTransposed: boolean;
+};
+export declare const scatterPlotFillDataTableFromScatterPlotData: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotFillDataTableFromScatterPlotData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotFillDataTableFromScatterPlotData.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotFillDataTableFromScatterPlotData.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AA+CtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA4PF,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAAC,WAAW,CAuB3E,CAAC"}