math-exercises 3.0.152 → 3.0.153

package/lib/exercises/math/spaceGeometry/sphere/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./pickIsPointInSphereOrBall.js";
+export * from "./sphereLatLonReading.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/index.js

@@ -0,0 +1,2 @@
+export * from "./pickIsPointInSphereOrBall.js";
+export * from "./sphereLatLonReading.js";

package/lib/exercises/math/spaceGeometry/sphere/pickIsPointInSphereOrBall.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    nbs: number[];
+    radius: number;
+    isSphere: boolean;
+};
+export declare const pickIsPointInSphereOrBall: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pickIsPointInSphereOrBall.d.ts.map

package/lib/exercises/math/spaceGeometry/sphere/pickIsPointInSphereOrBall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pickIsPointInSphereOrBall.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/pickIsPointInSphereOrBall.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA6IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}

package/lib/exercises/math/spaceGeometry/sphere/pickIsPointInSphereOrBall.js

@@ -0,0 +1,127 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const namePoints = ["A", "B", "C", "D"];
+const isInSphereOrBall = (rCandidate, rSphere, isSphere) => {
+    return isSphere ? rCandidate === rSphere : rCandidate <= rSphere;
+};
+const getPropositions = (_, { nbs, radius, isSphere }) => {
+    const propositions = [];
+    namePoints.forEach((namePoint, i) => {
+        const nb = nbs[i];
+        if (isInSphereOrBall(nb, radius, isSphere))
+            addValidProp(propositions, namePoint);
+        else
+            tryToAddWrongProp(propositions, namePoint);
+    });
+    return propositions;
+};
+const getAnswer = () => {
+    return "";
+};
+const getInstruction = (identifiers) => {
+    const { nbs, radius, isSphere } = identifiers;
+    return `${joinanded([...namePoints, "O"].map((namePoint) => `$${namePoint}$`), ", ", " et ")} sont des points de l'espace tels que 
+${joinanded([...namePoints].map((namePoint, i) => `$O${namePoint} = ${nbs[i].frenchify()} \\ \\textrm{cm}$`), ", ", " et ")}.
+
+Parmi les points ci-dessous, lequel ou lesquels appartiennent à la ${isSphere ? `sphère` : `boule`} de centre $O$ et de rayon $${radius.frenchify()} \\ \\textrm{cm}$ ?`;
+};
+const getHint = () => {
+    return `- Une sphère de centre $O$ et de rayon $r$ est l'ensemble des points $M$ de l'espace tels que $OM=r$. 
+  
+- Une boule de centre $O$ et de rayon $r$ est l'ensemble des points $M$ de l'espace tels que $OM\\leq r$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nbs, radius, isSphere } = identifiers;
+    if (isSphere) {
+        return `La sphère de centre $O$ et de rayon $${radius.frenchify()}\\ \\textrm{cm}$ est l'ensemble des points dont la distance à $O$ est exactement $${radius.frenchify()}\\ \\textrm{cm}$. 
+
+C'est une surface.
+
+${namePoints.map((namePoint, i) => `
+
+$$
+O${namePoint} = ${nbs[i].frenchify()} \\ \\textrm{cm} ${nbs[i] === radius ? `` : `\\neq ${radius.frenchify()} \\ \\textrm{cm}`} 
+$$
+
+donc $${namePoint}$ ${isInSphereOrBall(nbs[i], radius, isSphere)
+            ? `appartient`
+            : `n'appartient pas`} à la sphère de rayon $${radius.frenchify()}\\ \\textrm{cm}$.`).join(`
+      
+`)}`;
+    }
+    else {
+        return `La boule de centre $O$ et de rayon $${radius.frenchify()}\\ \\textrm{cm}$ est l'ensemble des points dont la distance à $O$ inférieure ou égale à $${radius.frenchify()}\\ \\textrm{cm}$. 
+
+C'est un solide.
+
+${namePoints.map((namePoint, i) => `
+
+$$
+O${namePoint} = ${nbs[i].frenchify()} \\ \\textrm{cm} ${nbs[i] > radius ? `>` : `\\leq`} ${radius.frenchify()} \\ \\textrm{cm}
+$$
+
+donc $${namePoint}$ ${isInSphereOrBall(nbs[i], radius, isSphere)
+            ? `appartient`
+            : `n'appartient pas`} à la boule de rayon $${radius.frenchify()}\\ \\textrm{cm}$.`).join(`
+      
+`)}`;
+    }
+};
+const getPickIsPointInSphereOrBallQuestion = () => {
+    const nbPoints = 4;
+    const rMin = 1;
+    const rMax = 36;
+    const radius = randint(1, rMax + 1);
+    const isSphere = coinFlip();
+    const mandatory = isSphere
+        ? probaFlip(0.6)
+            ? [radius]
+            : [radius, radius]
+        : [radius];
+    const nbs = shuffle([
+        ...randomMany([...Array(rMax - rMin + 1).keys()].map((i) => i + rMin), nbPoints - mandatory.length),
+        ...mandatory,
+    ]);
+    const identifiers = {
+        nbs,
+        radius,
+        isSphere,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pickIsPointInSphereOrBall = {
+    id: "pickIsPointInSphereOrBall",
+    connector: "=",
+    label: "Déterminer les points qui appartiennent à une sphère ou à une boule",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPickIsPointInSphereOrBallQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.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.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sphereLatLonReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sphere/sphereLatLonReading.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.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/geogebra/geogebraConstructor.d.ts

@@ -19,6 +19,8 @@ export declare class GeogebraConstructor {
     forbidShiftDragZoom?: boolean;
     commands?: string[];
     is3D?: boolean;
+    projection?: number;
+    projectionParam?: number;
     gridDistance?: [number, number] | false;
     hideGrid?: boolean;
     hideAxes?: boolean;

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAoBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAuBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAsBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAyBzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -4,6 +4,8 @@ export class GeogebraConstructor {
     forbidShiftDragZoom;
     commands;
     is3D;
+    projection;
+    projectionParam;
     gridDistance;
     hideGrid;
     hideAxes;
@@ -23,6 +25,8 @@ export class GeogebraConstructor {
         this.forbidShiftDragZoom = options?.forbidShiftDragZoom ?? false;
         this.commands = options.commands;
         this.is3D = options?.is3D;
+        this.projection = options?.projection;
+        this.projectionParam = options?.projectionParam;
         this.gridDistance = options?.gridDistance ?? [1, 1];
         this.hideGrid = options?.hideGrid;
         this.hideAxes = options?.hideAxes;
@@ -104,6 +108,8 @@ export class GeogebraConstructor {
             commands: this.commands,
             coords: coords,
             is3D: this.is3D,
+            projection: this.projection,
+            projectionParam: this.projectionParam,
             gridDistance: this.gridDistance,
             hideAxes: this.hideAxes,
             hideGrid: this.hideGrid,