math-exercises 3.0.149 → 3.0.151

package/lib/exercises/math/spaceGeometry/sections/areaOfRectangularPrismSection.js

@@ -0,0 +1,360 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueLight, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const rectangularPrismSectionGGBCommands = (AB, AD, AE, offset, isShowSectionPlane, planeType) => {
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //points
+        `A = Point({${AD},${AB},${AE}})`,
+        `ShowLabel(A,true)`,
+        `B = Point({${AD},0,${AE}})`,
+        `ShowLabel(B,true)`,
+        `C = Point({0,0,${AE}})`,
+        `ShowLabel(C,true)`,
+        `D = Point({0,${AB},${AE}})`,
+        `ShowLabel(D,true)`,
+        `E = Point({${AD},${AB},0})`,
+        `ShowLabel(E,true)`,
+        `F = Point({${AD},0,0})`,
+        `ShowLabel(F,true)`,
+        `G = Point({0,0,0})`,
+        `ShowLabel(G,true)`,
+        `H = Point({0,${AB},0})`,
+        `ShowLabel(H,true)`,
+        ...(() => {
+            switch (planeType) {
+                case "ABCD":
+                    {
+                        return [
+                            `I = Point({${AD},${AB},${AE - offset}})`,
+                            `ShowLabel(I,true)`,
+                        ];
+                    }
+                    break;
+                case "ABFE":
+                    {
+                        return [
+                            `I = Point({${AD - offset},${AB},${AE}})`,
+                            `ShowLabel(I,true)`,
+                        ];
+                    }
+                    break;
+                case "ADHE":
+                    {
+                        return [
+                            `I = Point({${AD},${AB - offset},${AE}})`,
+                            `ShowLabel(I,true)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+        //prism
+        `Pri = Prism(A,B,C,D,E)`,
+        `SetColor(Pri, "#d3dde6ff")`,
+        `SetFilling(Pri, 0.36)`,
+        `SetLineThickness(Pri, 1)`,
+        //plane
+        ...(isShowSectionPlane
+            ? (() => {
+                switch (planeType) {
+                    case "ABCD":
+                        {
+                            return [
+                                `Pl = Plane((0,0,${AE - offset}), (0,1,${AE - offset}), (0,1,${AE - offset}))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    case "ABFE":
+                        {
+                            return [
+                                `Pl = Plane((${AD - offset},0,0), (${AD - offset},1,0), (${AD - offset},0,1))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    case "ADHE":
+                        {
+                            return [
+                                `Pl = Plane((0,${AB - offset},0), (0,${AB - offset},1), (1,${AB - offset},0))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    default:
+                        throw new Error("unsupported planeType: " + planeType);
+                }
+            })()
+            : []),
+        //section
+        ...(() => {
+            switch (planeType) {
+                case "ABCD":
+                    {
+                        return [
+                            `s = Polygon((0,0,${AE - offset}), (${AD},0,${AE - offset}), (${AD},${AB},${AE - offset}), (0,${AB},${AE - offset}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "ABFE":
+                    {
+                        return [
+                            `s = Polygon((${AD - offset},0,0), (${AD - offset},0,${AE}), (${AD - offset},${AB},${AE}), (${AD - offset},${AB},0))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "ADHE":
+                    {
+                        return [
+                            `s = Polygon((0,${AB - offset},0), (0,${AB - offset},${AE}), (${AD},${AB - offset},${AE}), (${AD},${AB - offset},0))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+        //center view
+        `CenterView(A)`,
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { AB, AD, AE, offset, planeType } = identifiers;
+    return `Soit $ABCDEFGH$ un pavé droit tel que $AB = ${AB} \\ \\textrm{cm}$, $AD = ${AD} \\ \\textrm{cm}$ et $AE = ${AE} \\ \\textrm{cm}$.
+
+Un plan parallèle à $${planeType}$ coupe $ABCDEFGH$ en une section telle que $AI = ${offset.frenchify()}\\ \\textrm{cm}$.
+
+Quelle est l'aire de la section plane en $\\textrm{cm}^2$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { AB, AD, AE, planeType } = identifiers;
+    const nodeArea = (() => {
+        switch (planeType) {
+            case "ABCD":
+                {
+                    return multiply(AB, AD);
+                }
+                break;
+            case "ABFE":
+                {
+                    return multiply(AB, AE);
+                }
+                break;
+            case "ADHE":
+                {
+                    return multiply(AD, AE);
+                }
+                break;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })();
+    return nodeArea.simplify();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Utilise la formule qui donne l'aire d'un rectangle.`;
+};
+const getCorrection = (identifiers) => {
+    const { AB, AD, AE, planeType } = identifiers;
+    const [length1, length2] = (() => {
+        switch (planeType) {
+            case "ABCD":
+                return [AB, AD];
+            case "ABFE":
+                return [AB, AE];
+            case "ADHE":
+                return [AD, AE];
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })();
+    return `La section est un rectangle 
+${(() => {
+        switch (planeType) {
+            case "ABCD":
+                return `dont un des côtés est de longueur $AB$ et l'autre de longueur $AD$.`;
+            case "ABFE":
+                return `dont un des côtés est de longueur $AB$ et l'autre de longueur $AE$.`;
+            case "ADHE":
+                return `dont un des côtés est de longueur $AD$ et l'autre de longueur $AE$.`;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })()}
+
+L'aire vaut donc : 
+
+$$
+\\mathcal{A}_{\\text{rectangle}} = ${length1} \\times ${length2} = ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { AB, AD, AE, offset, planeType } = identifiers;
+    const commands = [
+        ...rectangularPrismSectionGGBCommands(AB, AD, AE, offset, false, planeType),
+        `SetFilling(s, 0.36)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+    });
+    const xMax = AD;
+    const xMin = 0;
+    const yMax = AB;
+    const yMin = 0;
+    const zMax = AE;
+    const zMin = 0;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { AB, AD, AE, offset, planeType } = identifiers;
+    const commands = [
+        ...rectangularPrismSectionGGBCommands(AB, AD, AE, offset, true, planeType),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+    });
+    const xMax = AD;
+    const xMin = 0;
+    const yMax = AB;
+    const yMin = 0;
+    const zMax = AE;
+    const zMin = 0;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+    catch (e) {
+        return handleVEAError(e);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { AB, AD, AE } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //wrong side
+    ["ABCD", "ADHE", "ABFE"].forEach((planeType) => {
+        const identifiersWrong = Object.assign({}, identifiers, { planeType });
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    //perimeter
+    [
+        [AB, AD],
+        [AB, AE],
+        [AD, AE],
+    ].forEach(([length1, length2]) => {
+        const nodePerimeter = multiply(2, add(length1, length2));
+        tryToAddWrongProp(propositions, nodePerimeter.evaluate().frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAreaOfRectangularPrismSectionQuestion = () => {
+    const planeType = random(["ABCD", "ADHE", "ABFE"]);
+    const [l1, l2] = randomMany([...Array(17).keys()].map((i) => i + 5), 2);
+    const [AB, AD, AE] = shuffle([l1, l2, randint(5, 21)]);
+    const offset = (() => {
+        switch (planeType) {
+            case "ABCD":
+                return randint(2, AE);
+            case "ADHE":
+                return randint(2, AB);
+            case "ABFE":
+                return randint(2, AD);
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })();
+    const identifiers = { AB, AD, AE, offset, planeType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        keys: getKeys(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+export const areaOfRectangularPrismSection = {
+    id: "areaOfRectangularPrismSection",
+    connector: "=",
+    label: "Calculer l'aire d'une section plane de pavé droit",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getAreaOfRectangularPrismSectionQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/spaceGeometry/sections/areaOfSphereSection.d.ts

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

package/lib/exercises/math/spaceGeometry/sections/areaOfSphereSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areaOfSphereSection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/areaOfSphereSection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAgErC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuPF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/spaceGeometry/sections/areaOfSphereSection.js

@@ -0,0 +1,272 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueLight, greenMain, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { SpacePoint } from "../../../../math/geometry/spacePoint.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getSpacePointP = (radius, height) => {
+    const nodeWidth = sqrt(substract(power(radius, 2), power(height, 2)));
+    return new SpacePoint("P", nodeWidth, (0).toTree(), height.toTree());
+};
+const sphereSectionGGBCommands = (radius, height, isShowSectionPlane) => {
+    const spacePointP = getSpacePointP(radius, height);
+    const width = spacePointP.x.evaluate();
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //sphere
+        `Sph = Sphere((0,0,0), 0.99 * ${radius})`,
+        `SetColor(Sph, "#d3dde6ff")`,
+        `SetFilling(Sph, 0.36)`,
+        `SetLineThickness(Sph, 1)`,
+        //plane
+        ...(isShowSectionPlane
+            ? [
+                `Pl = Plane((${width}, 0, ${height}), (0, ${width}, ${height}), (${-width}, 0, ${height}))`,
+                `SetColor(Pl, "${blueLight}")`,
+                `SetFilling(Pl, 0.23)`,
+            ]
+            : []),
+        //circles and arcs
+        //section
+        `d = Circle((${width}, 0, ${height}), (0, ${width}, ${height}), (${-width}, 0, ${height}))`,
+        `SetColor(d, "${red}")`,
+        // `SetFilling(d, 0.36)`,
+        `SetLineThickness(d, 3)`,
+        //points
+        `O = Point({0,0,0})`,
+        `I = Point({0,0,${height}})`,
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { radius, isDiameterGiven, height } = identifiers;
+    return `Soit $\\mathcal{S}$ une sphère de centre $O$ et de ${isDiameterGiven ? "diamètre" : "rayon"} $${isDiameterGiven ? 2 * radius : radius} \\ \\textrm{cm}$. 
+
+Un plan coupe $\\mathcal{S}$ en un cercle $\\mathcal{C}$ de centre $I$ tel que $OI = ${height.frenchify()}\\ \\textrm{cm}$.
+
+Quelle est l'aire du cercle $\\mathcal{C}$ en $\\textrm{cm}^2$ ?
+On donnera le résultat sous forme arrondie à deux décimales.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { radius, height } = identifiers;
+    const nodeWidth = sqrt(substract(power(radius, 2), power(height, 2)));
+    const nodeArea = multiply(PiNode, power(nodeWidth, 2));
+    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+    return nodeAreaRounded;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Trouve un moyen de calculer le rayon de $\\mathcal{S}$.
+
+Tu peux peut-être isoler un triangle particulier dont tu pourrais calculer la longueur d'un des côtés.`;
+};
+const getCorrection = (identifiers) => {
+    const { radius, height } = identifiers;
+    return `On nomme $P$ un point du cercle $\\mathcal{C}$. 
+  
+Le triangle $OPI$ est un triangle rectangle.
+
+Le point $P$ est un point de la sphère $\\mathcal{S}$ donc $OP=${radius} \\ \\textrm{cm}$.
+
+D'après le théorème de Pythagore : 
+
+$$
+{OP}^2={IO}^2+{IP}^2
+$$
+
+$$
+{IP}^2={OP}^2-{IO}^2
+$$
+
+$$
+{IP}^2={${radius}}^2-{${height}}^2
+$$
+
+L'aire du cercle est donc :
+
+$$
+\\mathcal{A}_{\\mathcal{C}} = \\pi \\times {IP}^2
+$$
+
+$$
+\\mathcal{A}_{\\mathcal{C}} \\approx ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { radius, height } = identifiers;
+    const spacePointP = getSpacePointP(radius, height);
+    const commands = [
+        ...sphereSectionGGBCommands(radius, height, false),
+        `SetFilling(d, 0.36)`,
+        //point
+        `P = Point({${spacePointP.x.evaluate()},${spacePointP.y.evaluate()},${spacePointP.z.evaluate()}})`,
+        //segments
+        `S_PI = Segment(P,I)`,
+        `SetColor(S_PI, "${greenMain}")`,
+        `SetCaption(S_PI,"$\\sqrt{${radius}^2-${height}^2}$")`,
+        `ShowLabel(S_PI,true)`,
+        `S_IO = Segment(I,O)`,
+        `SetCaption(S_IO,"${height}")`,
+        `ShowLabel(S_IO,true)`,
+        `S_OP = Segment(O,P)`,
+        `SetCaption(S_OP,"${radius}")`,
+        `ShowLabel(S_OP,true)`,
+        //angle
+        `a_OIP = Angle(O,I,P)`,
+        `ShowLabel(a_OIP,false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+    });
+    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 getGGBOptions = (identifiers) => {
+    const { radius, height } = identifiers;
+    const commands = [...sphereSectionGGBCommands(radius, height, true)];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+    });
+    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 }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+    catch (e) {
+        return handleVEAError(e);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { radius, height } = identifiers;
+    const propositions = [];
+    const nodeWidth = sqrt(substract(power(radius, 2), power(height, 2)));
+    const nodeArea = multiply(PiNode, power(nodeWidth, 2));
+    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+    addValidProp(propositions, nodeAreaRounded.toTex());
+    const nodeWidthRounded = round(nodeWidth.evaluate(), 2).toTree();
+    //stops at step1
+    {
+        tryToAddWrongProp(propositions, nodeWidthRounded.toTex());
+    }
+    //rounds before last step
+    {
+        const nodeArea = multiply(PiNode, power(nodeWidthRounded, 2));
+        const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+        tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+    }
+    //wrong application of pythagore
+    {
+        const nodeWidth = sqrt(add(power(radius, 2), power(height, 2)));
+        const nodeArea = multiply(PiNode, power(nodeWidth, 2));
+        const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+        tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+    }
+    //wrong formula: circumference
+    {
+        const nodeCircumference = multiply(multiply(2, PiNode), nodeWidth);
+        const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+        tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+    }
+    //wrong formula: sphere area
+    {
+        const nodeCircumference = multiply(multiply(4, PiNode), power(nodeWidth, 2));
+        const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+        tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAreaOfSphereSectionQuestion = () => {
+    const isDiameterGiven = probaFlip(0.23);
+    const radius = randint(5, 21);
+    const height = randint(1, radius);
+    const identifiers = { radius, isDiameterGiven, height };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        keys: getKeys(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+export const areaOfSphereSection = {
+    id: "areaOfSphereSection",
+    connector: "=",
+    label: "Calculer l'aire d'une section plane de sphère",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getAreaOfSphereSectionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,9 @@
+export * from "./recognizeSectionsOfSphereOrBall.js";
+export * from "./recognizeSectionsOfCylinder.js";
+export * from "./recognizeSectionsOfCone.js";
+export * from "./recognizeSectionsOfRectangularPrism.js";
+export * from "./areaOfSphereSection.js";
+export * from "./areaOfCylinderSection.js";
+export * from "./areaOfConeSection.js";
+export * from "./areaOfRectangularPrismSection.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0CAA0C,CAAC;AACzD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC"}

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

@@ -0,0 +1,8 @@
+export * from "./recognizeSectionsOfSphereOrBall.js";
+export * from "./recognizeSectionsOfCylinder.js";
+export * from "./recognizeSectionsOfCone.js";
+export * from "./recognizeSectionsOfRectangularPrism.js";
+export * from "./areaOfSphereSection.js";
+export * from "./areaOfCylinderSection.js";
+export * from "./areaOfConeSection.js";
+export * from "./areaOfRectangularPrismSection.js";

package/lib/exercises/math/spaceGeometry/sections/recognizeSectionsOfCone.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+};
+export declare const recognizeSectionsOfCone: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeSectionsOfCone.d.ts.map

package/lib/exercises/math/spaceGeometry/sections/recognizeSectionsOfCone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeSectionsOfCone.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/recognizeSectionsOfCone.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAiTF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}