math-exercises 3.0.189 → 3.0.191

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"}

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

@@ -0,0 +1,252 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { frenchify } from "../../../../math/utils/latex/frenchify.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const _getStrStatClassForIndexCateg = (indexCateg, data, bounds) => {
+    const labels = bounds.map(frenchify);
+    const isLastCateg = indexCateg == data.length;
+    return `[${labels[indexCateg]};${labels[indexCateg + 1]}${isLastCateg ? "]" : "["}`;
+};
+const getComponentOfPointForStrGroupBy = (point, strGroupBy) => {
+    switch (strGroupBy) {
+        case "x":
+            return point.x.evaluate();
+        case "y":
+            return point.y.evaluate();
+        default:
+            throw new Error("Unsupported strGroupBy: " + strGroupBy);
+    }
+};
+const getArrValueForScatterPlotData = (arrPoint, strGroupBy) => {
+    return [
+        ...new Set(arrPoint.map((point) => getComponentOfPointForStrGroupBy(point, strGroupBy))),
+    ].toSorted((v1, v2) => v1 - v2);
+};
+const getInstruction = () => {
+    return `Remplir le tableau avec les données issues du nuage de points ci-dessous.`;
+};
+const getInitTable = (identifiers) => {
+    const { pointIds, strGroupBy, isTransposed } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrValue = getArrValueForScatterPlotData(arrPoint, strGroupBy);
+    const tableRaw = [
+        [`$${strGroupBy}$`, ...arrValue.map(() => "\\ ")],
+        ["\\text{valeur}", ...arrValue.map(() => "")],
+        ["\\text{effectif}", ...arrValue.map(() => "")],
+    ];
+    return isTransposed ? transpose(tableRaw) : tableRaw;
+};
+const getAnswerTable = (identifiers) => {
+    const { pointIds, strGroupBy, isTransposed } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrValue = getArrValueForScatterPlotData(arrPoint, strGroupBy);
+    const arrDict = arrValue.map((value) => {
+        const count = arrPoint.filter((point) => getComponentOfPointForStrGroupBy(point, strGroupBy) === value).length;
+        return {
+            value,
+            count,
+        };
+    });
+    const tableRaw = [
+        [`$${strGroupBy}$`, ...arrValue.map(() => "\\ ")],
+        ["\\text{valeur}", ...arrDict.map(({ value }) => value.frenchify())],
+        ["\\text{effectif}", ...arrDict.map(({ count }) => count.frenchify())],
+    ];
+    return isTransposed ? transpose(tableRaw) : tableRaw;
+};
+const getHint = (identifiers) => {
+    const { strGroupBy } = identifiers;
+    return `Pour chaque valeur $v$ de ${strGroupBy}, compte le nombre de points qui ont $${strGroupBy}=v$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pointIds, strGroupBy } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrValue = getArrValueForScatterPlotData(arrPoint, strGroupBy);
+    const arrDict = arrValue.map((value) => {
+        const count = arrPoint.filter((point) => getComponentOfPointForStrGroupBy(point, strGroupBy) === value).length;
+        return {
+            value,
+            count,
+        };
+    });
+    return `Pour chaque valeur $v$ de $${strGroupBy}$, on compte le nombre de points qui ont $${strGroupBy}=v$.
+
+
+${arrDict.map(({ value, count }) => `Il y a $${count}$ point${count === 1 ? "" : "s"} qui ${count === 1 ? "a" : "ont"} $${strGroupBy}=${value}$.`).join(`
+
+`)}`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointIds, strGroupBy } = identifiers;
+    const arrPoint = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const arrValue = getArrValueForScatterPlotData(arrPoint, strGroupBy);
+    const commands = [
+        ...arrPoint.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: false,
+            size: 6,
+            style: 3,
+        })),
+        ...(() => {
+            switch (strGroupBy) {
+                case "x":
+                    return arrValue.flatMap((value, i) => [
+                        `l${i} = Line((${value}, 0),(${value}, 1))`,
+                        `SetColor(l${i}, "${greenMain}")`,
+                    ]);
+                case "y":
+                    return arrValue.flatMap((value, i) => [
+                        `l${i} = Line((0, ${value}),(1, ${value}))`,
+                        `SetColor(l${i}, "${greenMain}")`,
+                    ]);
+                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: 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 getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return answerTable.every((rowAnswer, j) => rowAnswer.every((answer, i) => {
+            const ansParsed = numberParser(ans[i][j]);
+            const answerParsed = numberParser(answer);
+            return ansParsed === answerParsed;
+        }));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getScatterPlotFillDataTableFromScatterPlotDataQuestion = () => {
+    const length = 5;
+    const height = 5;
+    const arrArrDict = getCartesiansProducts([
+        [...Array(length).keys()].map((i) => i + 1),
+        [...Array(height).keys()].map((i) => i + 1),
+    ]).map(([x, y]) => {
+        return {
+            x,
+            y,
+            isActivated: coinFlip(),
+        };
+    });
+    //at least one point should be activated
+    {
+        const dictRandom = random(arrArrDict);
+        dictRandom.isActivated = true;
+    }
+    const arrPoint = arrArrDict
+        .filter(({ isActivated }) => isActivated)
+        .map(({ x, y }) => new Point(`P${x}${y}`, x, y));
+    const strGroupBy = coinFlip() ? "x" : "y";
+    const isTransposed = coinFlip();
+    const identifiers = {
+        pointIds: arrPoint.map((point) => point.toIdentifiers()),
+        strGroupBy,
+        isTransposed,
+    };
+    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 scatterPlotFillDataTableFromScatterPlotData = {
+    id: "scatterPlotFillDataTableFromScatterPlotData",
+    label: "Remplir un tableau avec les données issues d'un nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScatterPlotFillDataTableFromScatterPlotDataQuestion(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/scatterPlotFillDataTableWithDataClassesFromScatterPlotData.d.ts

@@ -0,0 +1,12 @@
+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;
+    isTransposed: boolean;
+    nodeIdsDataClasses: NodeIdentifiers[];
+};
+export declare const scatterPlotFillDataTableWithDataClassesFromScatterPlotData: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scatterPlotFillDataTableWithDataClassesFromScatterPlotData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scatterPlotFillDataTableWithDataClassesFromScatterPlotData.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/scatterPlot/scatterPlotFillDataTableWithDataClassesFromScatterPlotData.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0B7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,kBAAkB,EAAE,eAAe,EAAE,CAAC;CACvC,CAAC;AAwXF,eAAO,MAAM,0DAA0D,EAAE,QAAQ,CAAC,WAAW,CA2B1F,CAAC"}