math-exercises 3.0.150 → 3.0.151

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

@@ -0,0 +1,439 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, propWhile, } 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 { 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 { frac } from "../../../../tree/nodes/operators/fractionNode.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 cylinderSectionGGBCommands = (radius, height, offset, isShowSectionPlane, planeType) => {
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //cone
+        `Con = Cone((0,0,0), (0,0,${height}), ${radius})`,
+        `SetColor(Con, "#d3dde6ff")`,
+        `SetFilling(Con, 0.36)`,
+        `SetLineThickness(Con, 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;
+                    default:
+                        throw new Error("unsupported planeType: " + planeType);
+                }
+            })()
+            : []),
+        //section
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                    {
+                        return [
+                            `s = Polygon((0, ${-radius}, 0), (0, ${radius}, 0), (0, 0, ${height}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                        const width = nodeHalfWidth.evaluate();
+                        return [
+                            `s = Circle((${width}, 0, ${offset}), (0, ${width}, ${offset}), (${-width}, 0, ${offset}))`,
+                            `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)`,
+        `I = Point({0,0,${offset}})`,
+        `ShowLabel(I,true)`,
+        `H = Point({0,0,${height}})`,
+        `ShowLabel(H,true)`,
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { radius, height, isDiameterGiven, offset, planeType } = identifiers;
+    return `Soit $\\mathcal{K}$ un cône ayant pour base le cercle $\\mathcal{C}$ de centre $O$ et de ${isDiameterGiven ? "diamètre" : "rayon"} $${isDiameterGiven ? 2 * radius : radius} \\ \\textrm{cm}$ et pour hauteur $${height.frenchify()} \\ \\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;
+            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 frac(multiply(radius, height), 2);
+                }
+                break;
+            case "perpendiculaire à l'axe de révolution":
+                {
+                    const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                    return multiply(PiNode, power(nodeHalfWidth, 2));
+                }
+                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 triangle.`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `Trouve un moyen de calculer le rayon du cercle section puis utilise la formule qui donne l'aire d'un cercle.`;
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { radius, height, planeType, offset } = identifiers;
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                return `La section est un triangle de hauteur $${height} \\ \\textrm{cm}$ et de base $${2 * radius} \\ \\textrm{cm}$.
+Son aire vaut :
+
+$$
+\\mathcal{A}_{\\text{triangle}} = \\frac{${height} \\times ${2 * radius}}{2} = ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `La section est un cercle dont on peut calculer le rayon.
+        
+En effet, on peut exhiber une configuration de Thalès en plaçant le point $P$, sur la section, 
+et le point $B$ sur la base du cône $\\mathcal{K}$ de manière à ce que $H$, $P$ et $B$ soient alignés.
+D'après le théorème de Thalès, on a :
+
+$$
+\\frac{PI}{BO} = \\frac{HI}{HO}
+$$
+
+$$
+\\frac{PI}{BO} = \\frac{HO - OI}{HO}
+$$
+
+$$
+PI = BO \\times \\frac{HO - OI}{HO}
+$$
+
+$$
+PI = ${radius} \\times \\frac{${height} - ${offset}}{${height}}
+$$
+
+L'aire du cercle section vaut donc :
+
+$$
+\\mathcal{A}_{\\text{cercle}} = \\pi \\times {PI}^2 \\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":
+                    {
+                        return [];
+                    }
+                    break;
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                        const width = nodeHalfWidth.evaluate();
+                        return [
+                            `P = Point({0,${-width},${offset}})`,
+                            `ShowLabel(P, true)`,
+                            `B = Point({0,${-radius},0})`,
+                            `ShowLabel(B, true)`,
+                        ];
+                    }
+                    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, offset, planeType } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                //wrong formula: height * base instead of (height * base)/2
+                {
+                    const nodeArea = multiply(height, 2 * radius);
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+                //wrong formula: perimeter
+                {
+                    const nodeLength = sqrt(add(power(height, 2), power(radius, 2)));
+                    const nodePerimeter = add(2 * radius, multiply(2, nodeLength));
+                    const nodePerimeterRounded = round(nodePerimeter.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodePerimeterRounded.toTex());
+                }
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                //wrong formula: circumference
+                {
+                    const nodeCircumference = multiply(multiply(2, PiNode), nodeHalfWidth);
+                    const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+                }
+                //wrong formula: 2*radius instead of radius
+                {
+                    const nodeArea = multiply(PiNode, power(multiply(2, nodeHalfWidth), 2));
+                    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 getAreaOfConeSectionQuestion = (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",
+        ],
+        defaultValue: optsDefault.planeTypes,
+    },
+];
+export const areaOfConeSection = {
+    id: "areaOfConeSection",
+    connector: "=",
+    label: "Calculer l'aire d'une section plane de cône",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreaOfConeSectionQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: opts?.planeTypes.length > 0,
+            message: "Veuillez choisir un type de section.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+};
+type Options = {
+    planeTypes: string[];
+};
+export declare const areaOfCylinderSection: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=areaOfCylinderSection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"areaOfCylinderSection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/areaOfCylinderSection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4JrC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqcF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAwBF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}