math-exercises 3.0.150 → 3.0.152

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

@@ -0,0 +1,548 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, propWhile, } 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 { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getSpacePointP = (radius, offset) => {
+    const nodeHalfWidth = sqrt(substract(power(radius, 2), power(offset, 2)));
+    return new SpacePoint("P", (-offset).toTree(), nodeHalfWidth, (0).toTree());
+};
+const cylinderSectionGGBCommands = (radius, height, offset, isShowSectionPlane, planeType) => {
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //cylinder
+        `Cyl = Cylinder((0,0,${-height / 2.0}), (0,0,${height / 2.0}), ${radius})`,
+        `SetColor(Cyl, "#d3dde6ff")`,
+        `SetFilling(Cyl, 0.36)`,
+        `SetLineThickness(Cyl, 1)`,
+        //plane
+        ...(isShowSectionPlane
+            ? (() => {
+                switch (planeType) {
+                    case "contenant l'axe de révolution":
+                        {
+                            return [
+                                `Pl = Plane((0,0,0), (0,1,0), (0,1,1))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    case "perpendiculaire à l'axe de révolution":
+                        {
+                            return [
+                                `Pl = Plane((${1}, 0, ${offset}), (0, ${1}, ${offset}), (${-1}, 0, ${offset}))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    case "parallèle à l'axe de révolution":
+                        {
+                            return [
+                                `Pl = Plane((${-offset},0,0), (${-offset},1,0), (${-offset},1,1))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    default:
+                        throw new Error("unsupported planeType: " + planeType);
+                }
+            })()
+            : []),
+        //section
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                    {
+                        return [
+                            `s = Polygon((0, ${-radius}, ${height / 2.0}), (0, ${radius}, ${height / 2.0}), (0, ${radius}, ${-height / 2.0}), (0, ${-radius}, ${-height / 2.0}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        return [
+                            `s = Circle((${radius}, 0, ${offset}), (0, ${radius}, ${offset}), (${-radius}, 0, ${offset}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "parallèle à l'axe de révolution":
+                    {
+                        const nodeWidthHalf = sqrt(substract(power(radius, 2), power(offset, 2)));
+                        const widthHalf = nodeWidthHalf.evaluate();
+                        return [
+                            `s = Polygon((${-offset}, ${-widthHalf}, ${height / 2.0}),(${-offset}, ${widthHalf}, ${height / 2.0}), (${-offset}, ${widthHalf}, ${-height / 2.0}), (${-offset}, ${-widthHalf}, ${-height / 2.0}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+        //points
+        `O = Point({0,0,0})`,
+        `ShowLabel(O,true)`,
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        return [`I = Point({0,0,${offset}})`, `ShowLabel(I,true)`];
+                    }
+                    break;
+                case "parallèle à l'axe de révolution":
+                    {
+                        return [`I = Point({${-offset},0,0})`, `ShowLabel(I,true)`];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { radius, height, isDiameterGiven, offset, planeType } = identifiers;
+    return `Soit $\\mathcal{K}$ un cylindre de centre $O$, de hauteur $${height.frenchify()} \\ \\textrm{cm}$ et de ${isDiameterGiven ? "diamètre" : "rayon"} $${isDiameterGiven ? 2 * radius : radius} \\ \\textrm{cm}$.
+
+${(() => {
+        switch (planeType) {
+            case "contenant l'axe de révolution":
+                {
+                    return `Un plan contenant l'axe de révolution coupe $\\mathcal{K}$ en une section telle que $OI = ${offset.frenchify()}\\ \\textrm{cm}$.`;
+                }
+                break;
+            case "perpendiculaire à l'axe de révolution":
+                {
+                    return `Un plan perpendiculaire à l'axe de révolution coupe $\\mathcal{K}$ en une section telle que $OI = ${offset.frenchify()}\\ \\textrm{cm}$.`;
+                }
+                break;
+            case "parallèle à l'axe de révolution":
+                {
+                    return `Un plan parallèle à l'axe de révolution coupe $\\mathcal{K}$ en une section telle que $OI = ${offset.frenchify()}\\ \\textrm{cm}$.`;
+                }
+                break;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })()}
+
+Quelle est l'aire de la section plane en $\\textrm{cm}^2$ ?
+On donnera le résultat sous forme arrondie à deux décimales.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const nodeArea = (() => {
+        switch (planeType) {
+            case "contenant l'axe de révolution":
+                {
+                    return multiply(2 * radius, height);
+                }
+                break;
+            case "perpendiculaire à l'axe de révolution":
+                {
+                    return multiply(PiNode, power(radius, 2));
+                }
+                break;
+            case "parallèle à l'axe de révolution":
+                {
+                    return multiply(multiply(2, sqrt(substract(power(radius, 2), power(offset, 2)))), height);
+                }
+                break;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })();
+    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+    return nodeAreaRounded;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { planeType } = identifiers;
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                return `Utilise la formule qui donne l'aire d'un rectangle.`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `Utilise la formule qui donne l'aire d'un cercle.`;
+            }
+            break;
+        case "parallèle à l'axe de révolution":
+            {
+                return `Trouve un moyen de calculer la longueur qui te manque pour calculer l'aire.
+
+Tu peux peut-être isoler un triangle particulier dont tu pourrais calculer la longueur d'un des côtés.`;
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { radius, height, planeType } = identifiers;
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                const longueur = Math.max(2 * radius, height);
+                const largeur = Math.min(2 * radius, height);
+                return `La section est un rectangle de longueur $${longueur} \\ \\textrm{cm}$ et de largeur $${largeur} \\ \\textrm{cm}$.
+Son aire vaut :
+
+$$
+\\mathcal{A}_{\\text{rectangle}} = ${longueur} \\times ${largeur} \\approx ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `La section est un cercle de rayon $${radius} \\ \\textrm{cm}$.
+Son aire vaut :
+
+$$
+\\mathcal{A}_{\\text{cercle}} = \\pi \\times ${radius}^2 \\approx ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+            }
+            break;
+        case "parallèle à l'axe de révolution":
+            {
+                const { offset } = identifiers;
+                const spacePointP = getSpacePointP(radius, offset);
+                const nodeWidthHalf = spacePointP.y;
+                const widthHalf = nodeWidthHalf.evaluate();
+                const isLongueurKnown = height > 2 * widthHalf;
+                return `La section est un rectangle dont la ${isLongueurKnown ? "longueur" : "largeur"} vaut $${height} \\ \\textrm{cm}$.
+
+Pour trouver sa ${!isLongueurKnown ? "longueur" : "largeur"}, on va utiliser un point $P$ qui est sur le même plan que $O$ et $I$, et qui appartient au rectangle section.
+        
+Le triangle $OPI$ est un triangle rectangle.
+
+Le point $P$ est un point du cylindre $\\mathcal{K}$ 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-{${offset}}^2
+$$
+
+$$
+{IP}=\\sqrt{{${radius}}^2-{${offset}}^2}
+$$
+
+L'aire du rectangle section vaut donc :
+
+$$
+\\mathcal{A}_{\\text{rectangle}} = ${height} \\times IP \\approx ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+`;
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const commands = [
+        ...cylinderSectionGGBCommands(radius, height, offset, false, planeType),
+        `SetFilling(s, 0.36)`,
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        return [];
+                    }
+                    break;
+                case "parallèle à l'axe de révolution":
+                    {
+                        const spacePointP = getSpacePointP(radius, offset);
+                        return [
+                            `P = Point({${spacePointP.x.evaluate()},${spacePointP.y.evaluate()},${spacePointP.z.evaluate()}})`,
+                            `ShowLabel(P,true)`,
+                            //segments
+                            `S_PI = Segment(P,I)`,
+                            `SetColor(S_PI, "${greenMain}")`,
+                            `SetCaption(S_PI,"$\\sqrt{${radius}^2-${offset}^2}$")`,
+                            `ShowLabel(S_PI,true)`,
+                            `S_IO = Segment(I,O)`,
+                            `SetCaption(S_IO,"${offset}")`,
+                            `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)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: false,
+        },
+    });
+    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, offset, planeType } = identifiers;
+    const commands = [
+        ...cylinderSectionGGBCommands(radius, height, offset, true, planeType),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: false,
+        },
+    });
+    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, planeType } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                //wrong formula: radius instead of 2*radius
+                {
+                    const nodeArea = multiply(height, radius);
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+                //wrong formula: perimeter
+                {
+                    const nodeCircumference = multiply(2, add(height, 2 * radius));
+                    const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+                }
+                //wrong formula: perimeter with radius instead of 2*radius
+                {
+                    const nodeCircumference = multiply(2, add(height, radius));
+                    const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+                }
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                //wrong formula: circumference
+                {
+                    const nodeCircumference = multiply(multiply(2, PiNode), radius);
+                    const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+                }
+                //wrong formula: 2*radius instead of radius
+                {
+                    const nodeArea = multiply(PiNode, power(2 * radius, 2));
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+            }
+            break;
+        case "parallèle à l'axe de révolution":
+            {
+                const { offset } = identifiers;
+                const nodeWidthHalf = sqrt(substract(power(radius, 2), power(offset, 2)));
+                const nodeWidthHalfRounded = round(nodeWidthHalf.evaluate(), 2).toTree();
+                //stops at step1
+                {
+                    tryToAddWrongProp(propositions, nodeWidthHalfRounded.toTex());
+                }
+                //wrong application of pythagore
+                {
+                    const nodeWidthHalf = sqrt(add(power(radius, 2), power(offset, 2)));
+                    const nodeArea = multiply(multiply(2, nodeWidthHalf), height);
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+                //rounds before last step
+                {
+                    const nodeArea = multiply(multiply(2, nodeWidthHalfRounded), height);
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = (() => {
+            const isDiameterGiven = probaFlip(0.23);
+            const radius = randint(5, 21);
+            const height = randint(5, 21);
+            const offset = randint(2, Math.min(radius, height / 2.0));
+            const identifiers = {
+                radius,
+                height,
+                isDiameterGiven,
+                offset,
+                planeType,
+            };
+            return {
+                planeType: identifiers.planeType,
+                isDiameterGiven,
+                radius,
+                height,
+                offset,
+            };
+        })();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAreaOfCylinderSectionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const planeType = random(opts.planeTypes);
+    const isDiameterGiven = probaFlip(0.23);
+    const radius = randint(5, 21);
+    const height = randint(5, 21);
+    const offset = randint(2, Math.min(radius, height / 2.0));
+    const identifiers = { radius, height, isDiameterGiven, offset, planeType };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    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,
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    planeTypes: [
+        "contenant l'axe de révolution",
+        "perpendiculaire à l'axe de révolution",
+    ],
+};
+const options = [
+    {
+        id: "planeTypes",
+        label: "Type de plan pour la section",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [
+            "contenant l'axe de révolution",
+            "perpendiculaire à l'axe de révolution",
+            "parallèle à l'axe de révolution",
+        ],
+        defaultValue: optsDefault.planeTypes,
+    },
+];
+export const areaOfCylinderSection = {
+    id: "areaOfCylinderSection",
+    connector: "=",
+    label: "Calculer l'aire d'une section plane de cylindre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreaOfCylinderSectionQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    AB: number;
+    AD: number;
+    AE: number;
+    offset: number;
+    planeType: string;
+};
+export declare const areaOfRectangularPrismSection: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=areaOfRectangularPrismSection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"areaOfRectangularPrismSection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/areaOfRectangularPrismSection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AA+KrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4OF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}