math-exercises 3.0.151 → 3.0.153

package/lib/exercises/math/spaceGeometry/solids/recognizeSolidFrom3D.js

@@ -0,0 +1,440 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange, pinkMain, purpleMain, red, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { Segment } from "../../../../math/geometry/segment.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { tan } from "../../../../tree/nodes/functions/tanNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const colors = [greenMain, orange, blueMain, pinkMain, purpleMain, red];
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = vSrc.rotate(angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const regularPolygonPoints = (iObj, segmentBase, nbSides) => {
+    const nodeApotheme = frac(segmentBase.getLength(), multiply(2, tan(frac(PiNode, nbSides))));
+    const vecAB = VectorConstructor.fromPoints(segmentBase.pointA, segmentBase.pointB);
+    const vecOrth = vecAB.getOrthogonal();
+    const vecOrthUnit = vecOrth.times(frac(1, vecOrth.getNorm()));
+    const pointCenter = vecOrthUnit
+        .times(nodeApotheme)
+        .getEndPoint(segmentBase.getMidpoint());
+    const angleBase = frac(multiply(2, PiNode), nbSides).evaluate();
+    const points = [...Array(nbSides).keys()].map((i) => {
+        return rotatePoint(segmentBase.pointA, i * angleBase, pointCenter, `P_${iObj}_${i}`, 5);
+    });
+    return points;
+};
+const ggbCommandRectangularPrism = (indexColor, L, l, h) => {
+    return [
+        //points
+        `A = Point({${L},${l},${h}})`,
+        `B = Point({${L},0,${h}})`,
+        `C = Point({0,0,${h}})`,
+        `D = Point({0,${l},${h}})`,
+        `E = Point({${L},${l},0})`,
+        //prism
+        `Pri = Prism(A,B,C,D,E)`,
+        `SetColor(Pri, "${colors[indexColor]}")`,
+        `SetFilling(Pri, 0.36)`,
+        `SetLineThickness(Pri, 1)`,
+        //hide points
+        `SetVisibleInView(A,-1, false)`,
+        `SetVisibleInView(B,-1, false)`,
+        `SetVisibleInView(C,-1, false)`,
+        `SetVisibleInView(D,-1, false)`,
+        `SetVisibleInView(E,-1, false)`,
+        `SetVisibleInView(F,-1, false)`,
+        `SetVisibleInView(G,-1, false)`,
+        `SetVisibleInView(H,-1, false)`,
+    ];
+};
+const boundingCoordsRectangularPrism = (L, l, h) => {
+    return {
+        xMin: 0,
+        yMin: 0,
+        zMin: 0,
+        xMax: L,
+        yMax: l,
+        zMax: h,
+    };
+};
+const ggbCommandPrismFromRegularPolygon = (indexColor, nbSides, l, h) => {
+    return [
+        //polygon
+        `PolBase = Polygon((${-l / 2.0}, 0), (${l / 2.0}, 0), ${nbSides})`,
+        //prism
+        `Pri = Prism(PolBase, ${h})`,
+        `SetColor(Pri, "${colors[indexColor]}")`,
+        `SetFilling(Pri, 0.36)`,
+        `SetLineThickness(Pri, 1)`,
+        `SetFixed(Pri, false, true)`,
+    ];
+};
+const boundingCoordsPrismFromRegularPolygon = (nbSides, l, h) => {
+    const ySpan = (() => {
+        const pointA = new Point("A", l, 0);
+        const pointB = new Point("B", 0, 0);
+        const segmentBase = new Segment(pointA, pointB);
+        const points = regularPolygonPoints(0, segmentBase, nbSides);
+        const ySpan = Math.max(...points.map((point) => point.y.evaluate()));
+        return ySpan;
+    })();
+    return {
+        xMin: -ySpan / 2,
+        yMin: 0,
+        zMin: 0,
+        xMax: ySpan / 2,
+        yMax: ySpan,
+        zMax: h,
+    };
+};
+const ggbCommandPyramidFromRegularPolygon = (indexColor, nbSides, l, h) => {
+    return [
+        //polygon
+        `PolBase = Polygon((${-l / 2.0}, 0), (${l / 2.0}, 0), ${nbSides})`,
+        //prism
+        `Pyr = Pyramid(PolBase, ${h})`,
+        `SetColor(Pyr, "${colors[indexColor]}")`,
+        `SetFilling(Pyr, 0.36)`,
+        `SetLineThickness(Pyr, 1)`,
+        `SetFixed(Pyr, false, true)`,
+    ];
+};
+const boundingCoordsPyramidFromRegularPolygon = (nbSides, l, h) => {
+    const ySpan = (() => {
+        const pointA = new Point("A", l, 0);
+        const pointB = new Point("B", 0, 0);
+        const segmentBase = new Segment(pointA, pointB);
+        const points = regularPolygonPoints(0, segmentBase, nbSides);
+        const ySpan = Math.max(...points.map((point) => point.y.evaluate()));
+        return ySpan;
+    })();
+    return {
+        xMin: -ySpan / 2,
+        yMin: 0,
+        zMin: 0,
+        xMax: ySpan / 2,
+        yMax: ySpan,
+        zMax: h,
+    };
+};
+const ggbCommandCylinder = (indexColor, l, h) => {
+    return [
+        //cylinder
+        `Cyl = Cylinder((0,0,${-h / 2.0}), (0,0,${h / 2.0}), ${l})`,
+        `SetColor(Cyl, "${colors[indexColor]}")`,
+        `SetFilling(Cyl, 0.36)`,
+        `SetLineThickness(Cyl, 1)`,
+    ];
+};
+const boundingCoordsCylinder = (l, //radius
+h) => {
+    return {
+        xMin: -l,
+        yMin: -l,
+        zMin: -h / 2,
+        xMax: l,
+        yMax: l,
+        zMax: h / 2,
+    };
+};
+const ggbCommandCone = (indexColor, l, h) => {
+    return [
+        //cone
+        `Con = Cone((0,0,0), (0,0,${h}), ${l})`,
+        `SetColor(Con, "${colors[indexColor]}")`,
+        `SetFilling(Con, 0.36)`,
+        `SetLineThickness(Con, 1)`,
+    ];
+};
+const boundingCoordsCone = (l, //radius
+h) => {
+    return {
+        xMin: -l,
+        yMin: -l,
+        zMin: 0,
+        xMax: l,
+        yMax: l,
+        zMax: h,
+    };
+};
+const ggbCommandSphere = (indexColor, l, _) => {
+    return [
+        //sphere
+        `Sph = Sphere((0,0,0), ${l})`,
+        `SetColor(Sph, "${colors[indexColor]}")`,
+        `SetFilling(Sph, 0.36)`,
+        `SetLineThickness(Sph, 1)`,
+    ];
+};
+const boundingCoordsSphere = (l, //radius
+_) => {
+    return {
+        xMin: -l,
+        yMin: -l,
+        zMin: -l,
+        xMax: l,
+        yMax: l,
+        zMax: l,
+    };
+};
+const solidFamilies = [
+    {
+        str: "un cube",
+        ggbCommandsFunc: (indexColor, L, l, h) => ggbCommandRectangularPrism(indexColor, L, l, h),
+        boundingCoordsFunc: (L, l, h) => boundingCoordsRectangularPrism(L, l, h),
+    },
+    {
+        str: "un pavé droit",
+        ggbCommandsFunc: (indexColor, L, l, h) => ggbCommandRectangularPrism(indexColor, L, l, h),
+        boundingCoordsFunc: (L, l, h) => boundingCoordsRectangularPrism(L, l, h),
+    },
+    {
+        str: "un prisme droit de polygone régulier",
+        ggbCommandsFunc: (indexColor, nbSides, l, h) => ggbCommandPrismFromRegularPolygon(indexColor, nbSides, l, h),
+        boundingCoordsFunc: (L, l, h) => boundingCoordsPrismFromRegularPolygon(L, l, h),
+    },
+    {
+        str: "une pyramide régulière",
+        ggbCommandsFunc: (indexColor, nbSides, l, h) => ggbCommandPyramidFromRegularPolygon(indexColor, nbSides, l, h),
+        boundingCoordsFunc: (nbSides, l, h) => boundingCoordsPyramidFromRegularPolygon(/*index,*/ nbSides, l, h),
+    },
+    {
+        str: "un cylindre",
+        ggbCommandsFunc: (indexColor, _, l, h) => ggbCommandCylinder(indexColor, l, h),
+        boundingCoordsFunc: (_, l, h) => boundingCoordsCylinder(l, h),
+    },
+    {
+        str: "un cône",
+        ggbCommandsFunc: (indexColor, _, l, h) => ggbCommandCone(indexColor, l, h),
+        boundingCoordsFunc: (_, l, h) => boundingCoordsCone(l, h),
+    },
+    {
+        str: "une sphère",
+        ggbCommandsFunc: (indexColor, _, l, h) => ggbCommandSphere(indexColor, l, h),
+        boundingCoordsFunc: (_, l, h) => boundingCoordsSphere(l, h),
+    },
+];
+const getInstruction = (_, opts) => {
+    return `Quel solide est ici représenté ${(() => {
+        switch (opts?.projection) {
+            case "1":
+                return "en $3$D";
+            case "3":
+                return "en perspective cavalière";
+            default:
+                return "";
+        }
+    })()} ?
+
+${(() => {
+        switch (opts?.projection) {
+            case "1":
+                return "*On pourra tourner la fenêtre graphique.*";
+            default:
+                return "";
+        }
+    })()}`;
+};
+const getAnswer = (identifiers) => {
+    const { indexFamily } = identifiers;
+    const solidFamily = solidFamilies[indexFamily];
+    return solidFamily.str;
+};
+const getHint = () => {
+    return `Est-ce un solide de révolution ? Est-ce un prisme ?`;
+};
+const getCorrection = (identifiers) => {
+    return `C'est ${getAnswer(identifiers)}.`;
+};
+const getGGBOptions = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { indexFamily, L, l, h, indexColor } = identifiers;
+    const solidFamily = solidFamilies[indexFamily];
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        ...solidFamily.ggbCommandsFunc(indexColor, L, l, h),
+    ];
+    const projection = +opts.projection;
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: projection === 0,
+        is3D: true,
+        projection,
+        projectionParam: projection === 1 ? 500 : undefined,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords(solidFamily.boundingCoordsFunc(L, l, h)),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    let arrStrWrong;
+    const { indexFamily } = identifiers;
+    switch (indexFamily) {
+        //avoid multiple possible answers
+        case 0:
+        case 1:
+            {
+                arrStrWrong = [
+                    "une pyramide régulière",
+                    "un cylindre",
+                    "un cône",
+                    "une sphère",
+                ];
+            }
+            break;
+        default:
+            {
+                arrStrWrong = solidFamilies.map((Family) => Family.str);
+            }
+            break;
+    }
+    arrStrWrong.forEach((str) => {
+        tryToAddWrongProp(propositions, str, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSolidFrom3DQuestion = (opts) => {
+    const indexFamily = randint(0, solidFamilies.length);
+    let L;
+    let l;
+    let h;
+    switch (indexFamily) {
+        case 0:
+            {
+                L = 5;
+                l = 5;
+                h = 5;
+            }
+            break;
+        case 1:
+            {
+                [L, l, h] = randomMany([...Array(20).keys()].map((i) => i + 5), 3);
+            }
+            break;
+        case 2:
+            {
+                //L is nbSides
+                L = random([3, 5, 6, 7, 8]);
+                [l, h] = randomMany([...Array(20).keys()].map((i) => i + 5), 2);
+            }
+            break;
+        case 3:
+            {
+                //L is nbSides
+                L = random([3, 5, 6, 7, 8]);
+                l = random([...Array(20).keys()].map((i) => i + 5));
+                const nodeApotheme = frac(l, multiply(2, tan(frac(PiNode, L))));
+                const minHAsIntegerSharp = Math.ceil(nodeApotheme.evaluate());
+                const minHAsIntegerForEye = Math.ceil(1.5 * minHAsIntegerSharp);
+                h = randint(minHAsIntegerForEye, 2 * minHAsIntegerForEye);
+            }
+            break;
+        case 4:
+            {
+                //L is useless
+                L = 0;
+                [l, h] = randomMany([...Array(20).keys()].map((i) => i + 5), 2);
+            }
+            break;
+        case 5:
+            {
+                //L is useless
+                L = 0;
+                [l, h] = randomMany([...Array(20).keys()].map((i) => i + 5), 2);
+                h = h + 10;
+            }
+            break;
+        case 6:
+            {
+                L = 0;
+                h = 0;
+                l = 5;
+            }
+            break;
+        default:
+            throw new Error("Unsupported indexFamily: " + indexFamily);
+    }
+    const indexColor = randint(0, colors.length);
+    const identifiers = { indexFamily, L, l, h, indexColor };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    projection: "3",
+};
+export const recognizeSolidFromCavalierPerspective = {
+    id: "recognizeSolidFromCavalierPerspective",
+    connector: "=",
+    label: "Nommer un solide à partir de sa représentation en perspective cavalière",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeSolidFrom3DQuestion({ projection: "3" }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};
+export const recognizeSolidFrom3D = {
+    id: "recognizeSolidFrom3D",
+    connector: "=",
+    label: "Nommer un solide à partir de sa représentation $3$D",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getRecognizeSolidFrom3DQuestion({ projection: "1" }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/spaceGeometry/solids/recognizeSolidFromSolidPattern.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    indexFamily: number;
+    indexPattern: number;
+    L: number;
+    l: number;
+    h: number;
+};
+export declare const recognizeSolidFromSolidPattern: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeSolidFromSolidPattern.d.ts.map

package/lib/exercises/math/spaceGeometry/solids/recognizeSolidFromSolidPattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeSolidFromSolidPattern.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/solids/recognizeSolidFromSolidPattern.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AA8qCrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA0JF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAiBhE,CAAC"}