math-exercises 3.0.156 → 3.0.158

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

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

@@ -0,0 +1,390 @@
+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 { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { randint } from "../../../../math/utils/random/randint.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 } from "../../../../utils/alea/random.js";
+const earthGlobeGGBCommands = () => {
+    const radius = 10;
+    const radiusMore = 10.5;
+    const radiusMoreMore = 11;
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //sphere
+        `Sph = Sphere((0,0,0), 0.99 * ${radius})`,
+        `SetColor(Sph, "#d3dde6ff")`,
+        `SetFilling(Sph, 0.84)`,
+        `SetLineThickness(Sph, 1)`,
+        //circles and arcs
+        //méridien
+        `c = Circle((0, 0, ${radius}), (${radius}, 0, 0), (0, 0, -${radius}))`,
+        `SetVisibleInView(c, -1, false)`,
+        `m = Arc(c, (0, 0, ${radius}), (0, 0, -${radius}) )`,
+        `SetColor(m, "${greenMain}")`,
+        `SetLineThickness(m, 3)`,
+        // `SetCaption(m, "$\\footnotesize \\text{Méridien de Greenwich}$")`,
+        // `ShowLabel(m, true)`,
+        //équateur
+        `d = Circle((${radius}, 0, 0), (0, ${radius}, 0), (-${radius}, 0, 0))`,
+        `SetColor(d, "${red}")`,
+        `SetLineThickness(d, 3)`,
+        // `SetCaption(d, "$\\footnotesize \\text{Équateur}$")`,
+        // `ShowLabel(d, true)`,
+        //other circles
+        `A_1 = (${radius}, 0, 0)`,
+        `l1 = Sequence(Rotate(m, nn * 15°, zAxis), nn, 1, 24)`,
+        `l2 = Sequence(Rotate(A_1, nn * 15°, yAxis), nn, -5, 5)`,
+        `l3 = Sequence(z(Element(l2, nn)), nn, 1, Length(l2))`,
+        `l4 = Sequence(x(Element(l2, nn)), nn, 1, Length(l2))`,
+        `l5 = Sequence(Circle((0, 0, Element(l3, nn)), Element(l4, nn), zAxis), nn, 1, Length(l2))`,
+        `SetVisibleInView(l2, -1, false)`, //Use -1 for the 3D View
+        `SetVisibleInView(A_1, -1, false)`,
+        //cercles::parallèles
+        `SetColor(l5, "${red}")`,
+        `SetLineThickness(l5, 1)`,
+        //cercles::méridiens
+        `SetColor(l1, "${greenMain}")`,
+        `SetLineThickness(l1, 1)`,
+        //markers
+        //marqueurs::parallèles
+        `lp0 = Sequence(Rotate((${radiusMore}, 0, 0), nn * 15°, yAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp0, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = -(90 - i * 15);
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P0_{${i}} = Point({x(Element(lp0, ${i})), y(Element(lp0, ${i})), z(Element(lp0, ${i}))})`,
+                `SetPointSize(P0_{${i}}, 1)`,
+                `SetColor(P0_{${i}}, "${red}")`,
+                `SetCaption(P0_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P0_{${i}}, true)`,
+            ];
+        }),
+        `lp2 = Sequence(Rotate(((-${radiusMore}), 0, 0), nn * 15°, yAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp2, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 90 - i * 15;
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P2_{${i}} = Point({x(Element(lp2, ${i})), y(Element(lp2, ${i})), z(Element(lp2, ${i}))})`,
+                `SetPointSize(P2_{${i}}, 1)`,
+                `SetColor(P2_{${i}}, "${red}")`,
+                `SetCaption(P2_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P2_{${i}}, true)`,
+            ];
+        }),
+        `lp1 = Sequence(Rotate((0, -${radiusMore}, 0), nn * 15°, xAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp1, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = -(90 - i * 15);
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P1_{${i}} = Point({x(Element(lp1, ${i})), y(Element(lp1, ${i})), z(Element(lp1, ${i}))})`,
+                `SetPointSize(P1_{${i}}, 1)`,
+                `SetColor(P1_{${i}}, "${red}")`,
+                `SetCaption(P1_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P1_{${i}}, true)`,
+            ];
+        }),
+        `lp3 = Sequence(Rotate((0, ${radiusMore}, 0), nn * 15°, xAxis), nn, -5, 5)`,
+        `SetVisibleInView(lp3, -1, false)`,
+        ...[...Array(11).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 90 - i * 15;
+            let strAngle;
+            if (angleInDegrees == 0) {
+                return [];
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°N`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°S`;
+            }
+            return [
+                `P3_{${i}} = Point({x(Element(lp3, ${i})), y(Element(lp3, ${i})), z(Element(lp3, ${i}))})`,
+                `SetPointSize(P3_{${i}}, 1)`,
+                `SetColor(P3_{${i}}, "${red}")`,
+                `SetCaption(P3_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(P3_{${i}}, true)`,
+            ];
+        }),
+        //marqueurs::méridiens
+        `lm0 = Sequence(Rotate((${radiusMoreMore}, 0, 0), nn * 15°, zAxis), nn, -11, 12)`,
+        `SetVisibleInView(lm0, -1, false)`,
+        ...[...Array(24).keys()]
+            .map((i) => i + 1)
+            .flatMap((i) => {
+            const angleInDegrees = 180 - i * 15;
+            let strAngle;
+            if (angleInDegrees == -180 || angleInDegrees == 0) {
+                strAngle = `${angleInDegrees.frenchify()}°`;
+            }
+            else if (angleInDegrees < 0) {
+                strAngle = `${(-angleInDegrees).frenchify()}°E`;
+            }
+            else {
+                strAngle = `${angleInDegrees.frenchify()}°O`;
+            }
+            return [
+                `M0_{${i}} = Point({x(Element(lm0, ${i})), y(Element(lm0, ${i})), z(Element(lm0, ${i}))})`,
+                `SetPointSize(M0_{${i}}, 1)`,
+                `SetColor(M0_{${i}}, "black")`,
+                `SetCaption(M0_{${i}}, "$\\footnotesize \\text{${strAngle}}$")`,
+                `ShowLabel(M0_{${i}}, true)`,
+            ];
+        }),
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const spacePointForLatLonPoint = (latlonPoint, radius) => {
+    const { x: lat, y: lon } = latlonPoint;
+    const toRadians = frac(PiNode, 180);
+    const delta = multiply(lat, toRadians);
+    const theta = multiply(lon, toRadians);
+    const chunk = multiply(radius, cos(delta));
+    const x = multiply(chunk, cos(theta));
+    const y = multiply(chunk, sin(theta));
+    const z = multiply(radius, sin(delta));
+    return new SpacePoint("S", x, y, z);
+};
+// const latLonPointForSpacePoint = (
+//   spacePoint: SpacePoint,
+//   center: SpacePoint,
+// ) => {
+//   const { x, y, z } = spacePoint;
+//   const vec3d = SpaceVectorConstructor.fromPoints(
+//     new SpacePoint("O", (0).toTree(), (0).toTree(), (0).toTree()),
+//     spacePoint,
+//   );
+//   const radius = vec3d.getNorm();
+//   const delta = substract(
+//     frac(PiNode, 2),
+//     Math.atan2(y.evaluate(), x.evaluate()),
+//   );
+//   const theta = Math.acos(z.evaluate()) / radius.evaluate();
+//   const toDegrees = frac(180, PiNode).evaluate();
+//   const lat = multiply(delta, toDegrees).evaluate();
+//   const lon = multiply(theta, toDegrees).evaluate();
+//   return new Point("L", lat, lon);
+// };
+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 { pointsDict, namePointTarget, isLatitude } = identifiers;
+    const propositions = [];
+    const latLonPoints = PointConstructor.fromIdentifiers(pointsDict[namePointTarget].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 { pointsDict, namePointTarget, isLatitude } = identifiers;
+    const latLonPoints = PointConstructor.fromIdentifiers(pointsDict[namePointTarget].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 ?
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+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 { pointsDict, namePointTarget } = identifiers;
+    const spacePoints = Object.values(pointsDict).map((miniDict) => SpacePointConstructor.fromIdentifiers(miniDict["3d"]));
+    const spacePointTarget = SpacePointConstructor.fromIdentifiers(pointsDict[namePointTarget]["3d"]);
+    const radius = 5;
+    // const zoomInCuboid = [-1, -1, -1, 1, 1, 1].map((v) => v * 0.5);
+    const commands = [
+        ...earthGlobeGGBCommands(),
+        ...spacePoints.flatMap((spacePoint) => spacePoint.toGGBCommand()),
+        // `ZoomIn(${zoomInCuboid.join(",")})`,        //does not work -_-
+        // `ZoomIn(2,${spacePointTarget.toCoords()})`, //does not work -_-
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+        viewDirectionVector: [
+            -spacePointTarget.x.evaluate(),
+            -spacePointTarget.y.evaluate(),
+            -spacePointTarget.z.evaluate(),
+        ],
+    });
+    const xMax = radius;
+    const xMin = -xMax;
+    const yMax = radius;
+    const yMin = -yMax;
+    const zMax = radius;
+    const zMin = -zMax;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getSphereLatLonReadingQuestion = () => {
+    const isLatitude = coinFlip();
+    const radius = 10;
+    const letters = ["A", "B", "C", "D"];
+    const pointsDict = letters.reduce((acc, letter) => {
+        const lat = randint(-4, 5) * 15;
+        const lon = randint(-11, 12) * 15;
+        const latLonPoint = new Point(`LatLon_{letter}`, lat, lon);
+        const spacePoint = spacePointForLatLonPoint(latLonPoint, radius.toTree());
+        spacePoint.name = letter;
+        acc[letter] = {
+            latLon: latLonPoint.toIdentifiers(),
+            "3d": spacePoint.toIdentifiers(),
+        };
+        return acc;
+    }, {});
+    const namePointTarget = random(Object.keys(pointsDict));
+    const identifiers = {
+        isLatitude,
+        pointsDict,
+        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 sphereLatLonReading = {
+    id: "sphereLatLonReading",
+    label: "Donner la latitude/longitude d'un point sur une sphère",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSphereLatLonReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aIds: NodeIdentifiers;
+    bIds: NodeIdentifiers;
+};
+export declare const areReelsOnTheSameTrigoCirclePoint: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=areReelsOnTheSameTrigoCirclePoint.d.ts.map

package/lib/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areReelsOnTheSameTrigoCirclePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/circle/areReelsOnTheSameTrigoCirclePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAqBnE,CAAC"}