math-exercises 3.0.156 → 3.0.157

package/lib/exercises/math/spaceGeometry/sphere/pinPointLatLon.2d.js

@@ -0,0 +1,205 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+const earthGlobe2DGGBCommands = () => {
+    const [pointN, pointS, pointE, pointO] = [
+        ["N", [0, 1]],
+        ["S", [0, -1]],
+        ["E", [1, 0]],
+        ["O", [-1, 0]],
+    ].map(([pointName, [x, y]]) => new Point(pointName, x, y));
+    return [
+        //Greenwich and equator
+        ...[pointN, pointS, pointE, pointO].flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            showLabel: true,
+            color: "#000000",
+            size: 2,
+        })),
+        `Seg_greenwich = Segment(S,N)`,
+        `SetColor(Seg_greenwich,"${greenMain}")`,
+        `Seg_equator = Segment(O,E)`,
+        `SetColor(Seg_equator,"${red}")`,
+        //labels
+        `Lbl_greenwich = Text(RotateText("\\tiny Greenwich", 90°), (-0.05, 0.62), true, true, 0, 0)`,
+        `Lbl_equator = Text("\\tiny Équateur", (0.62, 0), true, true, 0, 0)`,
+        `Lbl_15_greenwich = Text("\\tiny 15", (0.27, -0.05), true, true, 0, 0)`,
+        `SetFixed(Lbl_15_greenwich, true, false)`,
+        `Lbl_15_equator = Text("\\tiny 15", (-0.07, 0.27), true, true, 0, 0)`,
+        `SetFixed(Lbl_15_equator, true, false)`,
+        //curves
+        `l1 = Sequence(x² / sin²(λ) + y² = 1, λ, 0, π / 2, π / 12)`,
+        `SetColor(l1, "#AAAAAA")`,
+        `SetFilling(l1, 0)`,
+        `l2 = Sequence(If(x² + sin²(α) ≤ 1, sin(α)), α, (-π) / 2, π / 2, π / 12)`,
+        `SetColor(l2,"#AAAAAA")`,
+        `SetFilling(l2, 0)`,
+    ];
+};
+const xyPointForLatLonPoint = (latlonPoint) => {
+    const { x: lat, y: lon } = latlonPoint;
+    const toRadians = frac(PiNode, 180);
+    const phi = multiply(lat, toRadians);
+    const lambda = multiply(lon, toRadians);
+    const x = multiply(cos(phi), sin(lambda));
+    const y = sin(phi);
+    return new Point("S", x, y);
+};
+const getStrLatitude = (angleInDegrees) => {
+    if (angleInDegrees % 90 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°S`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°N`;
+    }
+};
+const getStrLongitude = (angleInDegrees) => {
+    if (angleInDegrees % 180 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°O`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°E`;
+    }
+};
+const getAnswerPoint = (identifiers) => {
+    const { namePointTarget, pointsDict } = identifiers;
+    const pointDst = PointConstructor.fromIdentifiers(pointsDict[namePointTarget]["2d"]);
+    return pointDst;
+};
+const getGGBAnswer = (identifiers) => {
+    const { namePointTarget, pointsDict } = identifiers;
+    const pointDst = PointConstructor.fromIdentifiers(pointsDict[namePointTarget]["2d"]);
+    return [`${pointDst.toMathString()}`];
+};
+const getInstruction = (identifiers) => {
+    const { namePointTarget, pointsDict } = identifiers;
+    const latLonPoint = PointConstructor.fromIdentifiers(pointsDict[namePointTarget].latLon);
+    const [lat, lon] = [latLonPoint.x.evaluate(), latLonPoint.y.evaluate()];
+    return `Placer le point $A$ de coordonnées $(${getStrLatitude(lat)};${getStrLongitude(lon)})$ sur la figure ci-dessous.`;
+};
+const getHint = () => {
+    return `Pour déterminer la latitude, on utlise les parallèles.
+Pour déterminer la longitude, on utilise les méridiens.`;
+};
+const getCorrection = () => {
+    return `La latitude donne la position Nord/Sud. 
+La longitude donne la position Est/Ouest.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { pointsDict } = identifiers;
+    const xyPoints = Object.values(pointsDict)
+        .map((pointMiniDict) => pointMiniDict["2d"])
+        .map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const commands = [
+        ...earthGlobe2DGGBCommands(),
+        ...xyPoints.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            showLabel: true,
+            size: 2,
+            color: greenMain,
+        })),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.1, 1.1, -1.1, 1.1],
+    });
+};
+const getStudentGGBOptions = () => {
+    const commands = [...earthGlobe2DGGBCommands()];
+    const studentGgb = new GeogebraConstructor({
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return studentGgb.getOptions({
+        coords: [-1.1, 1.1, -1.1, 1.1],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const isPointValid = () => {
+        const points = parseGGBPoints(ans)
+            .map((p) => ggbPointToCoords(p))
+            .map((coords, i) => new Point(`K_${i}`, coords.x, coords.y));
+        const answerPoint = getAnswerPoint(identifiers);
+        return points.some((point) => point.distanceTo(answerPoint) < 0.1);
+    };
+    return isPointValid();
+};
+const getPinPointLatLon2dQuestion = () => {
+    const letters = ["A"];
+    const arrLat = [...Array(9).keys()].map((i) => (i - 4) * 15);
+    const arrLon = [...Array(9).keys()].map((i) => (i - 4) * 15);
+    //we need student to figure out the correct mapping
+    const arrLatLon = getCartesiansProducts([arrLat, arrLon]).filter(([lat, lon]) => lat !== lon && -lat !== lon);
+    const pickedLatLon = randomMany(arrLatLon, letters.length);
+    const pointsDict = letters.reduce((acc, letter, i) => {
+        const [lat, lon] = pickedLatLon[i];
+        const latLonPoint = new Point(`${letter}`, lat, lon);
+        const xyPoint = xyPointForLatLonPoint(latLonPoint);
+        xyPoint.name = letter;
+        acc[letter] = {
+            latLon: latLonPoint.toIdentifiers(),
+            "2d": xyPoint.toIdentifiers(),
+        };
+        return acc;
+    }, {});
+    const namePointTarget = random(Object.keys(pointsDict));
+    const identifiers = {
+        pointsDict,
+        namePointTarget,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        identifiers,
+        instruction: getInstruction(identifiers),
+        ggbAnswer: getGGBAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const pinPointLatLon2d = {
+    id: "pinPointLatLon2d",
+    label: "Placer un point à partir de sa latitude et de sa longitude",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPinPointLatLon2dQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    isGGBAnswerValid,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "GGB",
+};

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointData: {
+        latLon: PointIdentifiers;
+        "2d": PointIdentifiers;
+    };
+    isLatitude: boolean;
+    namePointTarget: string;
+};
+export declare const sphereLatLonReading2d: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sphereLatLonReading.2d.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphereLatLonReading.2d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAuFtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,gBAAgB,CAAC;KACxB,CAAC;IAEF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA+KF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.js

@@ -0,0 +1,215 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { cos } from "../../../../tree/nodes/functions/cosNode.js";
+import { sin } from "../../../../tree/nodes/functions/sinNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+const earthGlobe2DGGBCommands = () => {
+    const [pointN, pointS, pointE, pointO] = [
+        ["N", [0, 1]],
+        ["S", [0, -1]],
+        ["E", [1, 0]],
+        ["O", [-1, 0]],
+    ].map(([pointName, [x, y]]) => new Point(pointName, x, y));
+    return [
+        //Greenwich and equator
+        ...[pointN, pointS, pointE, pointO].flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            showLabel: true,
+            color: "#000000",
+            size: 2,
+        })),
+        `Seg_greenwich = Segment(S,N)`,
+        `SetColor(Seg_greenwich,"${greenMain}")`,
+        `SetFixed(Seg_greenwich, true, false)`,
+        `Seg_equator = Segment(O,E)`,
+        `SetFixed(Seg_equator, true, false)`,
+        `SetColor(Seg_equator,"${red}")`,
+        //labels
+        `Lbl_greenwich = Text(RotateText("\\tiny Greenwich", 90°), (-0.05, 0.62), true, true, 0, 0)`,
+        `Lbl_equator = Text("\\tiny Équateur", (0.62, 0), true, true, 0, 0)`,
+        `Lbl_15_greenwich = Text("\\tiny 15", (0.27, -0.05), true, true, 0, 0)`,
+        `SetFixed(Lbl_15_greenwich, true, false)`,
+        `Lbl_15_equator = Text("\\tiny 15", (-0.07, 0.27), true, true, 0, 0)`,
+        `SetFixed(Lbl_15_equator, true, false)`,
+        //curves
+        `l1 = Sequence(x² / sin²(λ) + y² = 1, λ, 0, π / 2, π / 12)`,
+        `SetColor(l1, "#AAAAAA")`,
+        `SetFilling(l1, 0)`,
+        `l2 = Sequence(If(x² + sin²(α) ≤ 1, sin(α)), α, (-π) / 2, π / 2, π / 12)`,
+        `SetColor(l2,"#AAAAAA")`,
+        `SetFilling(l2, 0)`,
+    ];
+};
+const xyPointForLatLonPoint = (latlonPoint) => {
+    const { x: lat, y: lon } = latlonPoint;
+    const toRadians = frac(PiNode, 180);
+    const phi = multiply(lat, toRadians);
+    const lambda = multiply(lon, toRadians);
+    const x = multiply(cos(phi), sin(lambda));
+    const y = sin(phi);
+    return new Point("S", x, y);
+};
+const getStrLatitude = (angleInDegrees) => {
+    if (angleInDegrees % 90 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°S`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°N`;
+    }
+};
+const getStrLongitude = (angleInDegrees) => {
+    if (angleInDegrees % 180 === 0) {
+        return `${angleInDegrees.frenchify()}°`;
+    }
+    else if (angleInDegrees < 0) {
+        return `${(-angleInDegrees).frenchify()}°O`;
+    }
+    else {
+        return `${angleInDegrees.frenchify()}°E`;
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { pointData, isLatitude } = identifiers;
+    const propositions = [];
+    const latLonPoints = PointConstructor.fromIdentifiers(pointData.latLon);
+    if (isLatitude) {
+        addValidProp(propositions, getStrLatitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.y.evaluate()));
+        //wrongSign
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.x.evaluate()));
+        //madness
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.x.evaluate()));
+    }
+    else {
+        addValidProp(propositions, getStrLongitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.x.evaluate()));
+        //wrongSign
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.y.evaluate()));
+        //madness
+        tryToAddWrongProp(propositions, getStrLongitude(latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLongitude(-latLonPoints.x.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(latLonPoints.y.evaluate()));
+        tryToAddWrongProp(propositions, getStrLatitude(-latLonPoints.y.evaluate()));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pointData, isLatitude } = identifiers;
+    const latLonPoints = PointConstructor.fromIdentifiers(pointData.latLon);
+    if (isLatitude) {
+        return getStrLatitude(latLonPoints.x.evaluate());
+    }
+    else {
+        return getStrLongitude(latLonPoints.y.evaluate());
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isLatitude, namePointTarget } = identifiers;
+    return `Quelle est la ${isLatitude ? "latitude" : "longitude"} du point $${namePointTarget}$ sur la figure ci-dessous ?`;
+};
+const getHint = () => {
+    return `Pour déterminer la latitude, on utlise les parallèles.
+Pour déterminer la longitude, on utilise les méridiens.`;
+};
+const getCorrection = (identifiers) => {
+    const { isLatitude, namePointTarget } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La latitude donne la position Nord/Sud. 
+La longitude donne la position Est/Ouest.
+La ${isLatitude ? "latitude" : "longitude"} du point $${namePointTarget}$ est donc $${answer}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { pointData } = identifiers;
+    const xyPoint = PointConstructor.fromIdentifiers(pointData["2d"]);
+    const commands = [
+        ...earthGlobe2DGGBCommands(),
+        ...xyPoint.toGGBCommand({ isFixed: true, showLabel: true }),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1.1, 1.1, -1.1, 1.1],
+    });
+};
+const getKeys = () => {
+    return ["degree", "N", "O", "S", "E"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    console.log("ans", ans);
+    console.log("answer", answer);
+    const ansRefined = ans.replace("^{\\circ}", "°");
+    return ansRefined === answer;
+};
+const getSphereLatLonReading2dQuestion = () => {
+    const isLatitude = coinFlip();
+    const letters = ["A", "B", "C", "D"];
+    const arrLat = [...Array(9).keys()].map((i) => (i - 4) * 15);
+    const arrLon = [...Array(9).keys()].map((i) => (i - 4) * 15);
+    //we need student to figure out the correct mapping
+    const arrLatLon = getCartesiansProducts([arrLat, arrLon]).filter(([lat, lon]) => lat !== lon && -lat !== lon);
+    const pickedLatLon = randomMany(arrLatLon, letters.length);
+    const pointsDict = letters.reduce((acc, letter, i) => {
+        const [lat, lon] = pickedLatLon[i];
+        const latLonPoint = new Point(`${letter}`, lat, lon);
+        const xyPoint = xyPointForLatLonPoint(latLonPoint);
+        xyPoint.name = letter;
+        acc[letter] = {
+            latLon: latLonPoint.toIdentifiers(),
+            "2d": xyPoint.toIdentifiers(),
+        };
+        return acc;
+    }, {});
+    const namePointTarget = random(Object.keys(pointsDict));
+    const identifiers = {
+        isLatitude,
+        pointData: pointsDict[namePointTarget],
+        namePointTarget,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const sphereLatLonReading2d = {
+    id: "sphereLatLonReading2d",
+    label: "Donner la latitude/longitude d'un point sur une sphère ($2$D)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSphereLatLonReading2dQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.3d.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    pointsDict: Record<string, {
+        latLon: PointIdentifiers;
+        "3d": SpacePointIdentifiers;
+    }>;
+    isLatitude: boolean;
+    namePointTarget: string;
+};
+export declare const sphereLatLonReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sphereLatLonReading.3d.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphereLatLonReading.3d.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.3d.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAwO3C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAChB,MAAM,EACN;QACE,MAAM,EAAE,gBAAgB,CAAC;QACzB,IAAI,EAAE,qBAAqB,CAAC;KAC7B,CACF,CAAC;IACF,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAwMF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}