math-exercises 3.0.151 → 3.0.153

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

@@ -0,0 +1,1089 @@
+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";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { arrayRotation } from "../../../../utils/arrays/rotation.js";
+const colors = [greenMain, orange, blueMain, pinkMain, purpleMain, red];
+const rectangleGGBCommands = (iRect, coordsTL, lengthTopSide, lengthLeftSide, styles) => {
+    const [x, y] = coordsTL;
+    const pointTL = new Point(`P0_${iRect}`, x, y);
+    const pointTR = new Point(`P1_${iRect}`, add(pointTL.x, lengthTopSide).evaluate(), pointTL.y);
+    const pointBL = new Point(`P2_${iRect}`, pointTL.x, substract(pointTL.y, lengthLeftSide).evaluate());
+    const pointBR = new Point(`P3_${iRect}`, pointTR.x, pointBL.y);
+    const segmentTop = new Segment(pointTL, pointTR);
+    const segmentRight = new Segment(pointTR, pointBR);
+    const segmentBottom = new Segment(pointBR, pointBL);
+    const segmentLeft = new Segment(pointBL, pointTL);
+    const commands = [
+        //create points
+        ...[pointTL, pointTR, pointBR, pointBL].flatMap((point) => {
+            return [
+                `${point.name} = ${point.toMathString()}`,
+                `SetVisibleInView(${point.name}, 1, false)`,
+            ];
+        }),
+        //create segments
+        ...[segmentTop, segmentRight, segmentBottom, segmentLeft].flatMap((segment, i) => [
+            ...segment.toGGBCommands(false, {
+                isFixed: true,
+                showLabel: false,
+                showLength: false,
+                style: styles[i][1] === 1 ? 2 : 0,
+            }),
+            `SetColor(${segment.ggbName}, "${colors[styles[i][0]]}")`,
+        ]),
+    ];
+    return commands;
+};
+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 regularPolygonGGBCommands = (iObj, coordsBase, nbSides, styles) => {
+    const pointA = new Point("A", coordsBase[0][0], coordsBase[0][1]);
+    const pointB = new Point("B", coordsBase[1][0], coordsBase[1][1]);
+    const segmentBase = new Segment(pointA, pointB);
+    const points = regularPolygonPoints(iObj, segmentBase, nbSides);
+    const segments = zip(points, arrayRotation(points, 1)).map(([p1, p2]) => new Segment(p1, p2));
+    const commands = [
+        //create points
+        ...points.flatMap((point) => {
+            return [
+                `${point.name} = ${point.toMathString()}`,
+                `SetVisibleInView(${point.name}, 1, false)`,
+            ];
+        }),
+        //create segments
+        ...segments.flatMap((segment, i) => [
+            ...segment.toGGBCommands(false, {
+                isFixed: true,
+                showLabel: false,
+                showLength: false,
+                style: styles[i][1] === 1 ? 2 : 0,
+            }),
+            `SetColor(${segment.ggbName}, "${colors[styles[i][0]]}")`,
+        ]),
+    ];
+    return commands;
+};
+const trianglePoints = (iObj, segmentBase, height) => {
+    const vecAB = VectorConstructor.fromPoints(segmentBase.pointA, segmentBase.pointB);
+    const vecOrth = vecAB.getOrthogonal();
+    const vecOrthUnit = vecOrth.times(frac(1, vecOrth.getNorm()));
+    const pointTop = vecOrthUnit
+        .times(height.toTree())
+        .getEndPoint(segmentBase.getMidpoint(), `P_${iObj}_2`);
+    const pointTopEvaluated = new Point(pointTop.name, pointTop.x.evaluate(), pointTop.y.evaluate());
+    const points = [segmentBase.pointA, segmentBase.pointB, pointTopEvaluated];
+    return points;
+};
+const triangleGGBCommands = (iObj, coordsBase, height, styles) => {
+    const pointA = new Point(`P_${iObj}_0`, coordsBase[0][0], coordsBase[0][1]);
+    const pointB = new Point(`P_${iObj}_1`, coordsBase[1][0], coordsBase[1][1]);
+    const segmentBase = new Segment(pointA, pointB);
+    const points = trianglePoints(iObj, segmentBase, height);
+    const segments = zip(points, arrayRotation(points, 1)).map(([p1, p2]) => new Segment(p1, p2));
+    const commands = [
+        //create points
+        ...points.flatMap((point) => {
+            return [
+                `${point.name} = ${point.toMathString()}`,
+                `SetVisibleInView(${point.name}, 1, false)`,
+            ];
+        }),
+        //create segments
+        ...segments.flatMap((segment, i) => [
+            ...segment.toGGBCommands(false, {
+                isFixed: true,
+                showLabel: false,
+                showLength: false,
+                style: styles[i][1] === 1 ? 2 : 0,
+            }),
+            `SetColor(${segment.ggbName}, "${colors[styles[i][0]]}")`,
+        ]),
+    ];
+    return commands;
+};
+const ggbCommandRectangularPrismPattern = (indexPattern, L, l, h) => {
+    switch (indexPattern) {
+        case 0:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [2 * L + h, 0], h, L, [
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                        [0, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 1],
+                        [1, 0],
+                        [2, 1],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [2 * L + h, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 1:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [2 * L + h, 0], h, L, [
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                        [0, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 1],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 1],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [L + h, -L - l], L, h, [
+                        [0, 1],
+                        [2, 0],
+                        [0, 0],
+                        [2, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 2:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [2 * L + h, 0], h, L, [
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                        [0, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 1],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 1],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [L, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 3:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [2 * L + h, 0], h, L, [
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                        [0, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 1],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 1],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [0, -L - l], L, h, [
+                        [0, 1],
+                        [2, 0],
+                        [0, 0],
+                        [2, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 4:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 1],
+                        [1, 1],
+                        [0, 1],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 0],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [L + h, -L - l], L, h, [
+                        [0, 1],
+                        [2, 0],
+                        [0, 0],
+                        [2, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 5:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(4, [2 * L + h, -L], h, l, [
+                        [2, 0],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(5, [L, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 0],
+                    ]),
+                ];
+            }
+            break;
+        case 6:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [2 * L + h, 0], h, L, [
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                        [0, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L + h, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [2 * L + h, -L], h, l, [
+                        [2, 1],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(4, [L - l, -L - l], l, L, [
+                        [1, 0],
+                        [0, 1],
+                        [1, 0],
+                        [0, 0],
+                    ]),
+                    ...rectangleGGBCommands(5, [L, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                    ]),
+                ];
+            }
+            break;
+        case 7:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 1],
+                        [1, 0],
+                        [0, 1],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(4, [L + h, -L - l], L, h, [
+                        [0, 1],
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                    ]),
+                    ...rectangleGGBCommands(5, [2 * L + h, -L - l], l, h, [
+                        [1, 0],
+                        [2, 0],
+                        [1, 0],
+                        [2, 1],
+                    ]),
+                ];
+            }
+            break;
+        case 8:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(1, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 1],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(2, [L + h, -L], L, l, [
+                        [0, 1],
+                        [1, 1],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(3, [2 * L + h, -L], h, l, [
+                        [2, 0],
+                        [1, 0],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(4, [L - l, -L - l], l, L, [
+                        [1, 0],
+                        [0, 1],
+                        [1, 0],
+                        [0, 0],
+                    ]),
+                    ...rectangleGGBCommands(5, [L, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                    ]),
+                ];
+            }
+            break;
+        case 9:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 1],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    ...rectangleGGBCommands(1, [2 * L + h, -(L - h)], l, h, [
+                        [1, 0],
+                        [2, 0],
+                        [1, 0],
+                        [2, 1],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(2, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 1],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(3, [L + h, -L], L, l, [
+                        [0, 1],
+                        [1, 0],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    ...rectangleGGBCommands(4, [L - l, -L - l], l, L, [
+                        [1, 0],
+                        [0, 1],
+                        [1, 0],
+                        [0, 0],
+                    ]),
+                    ...rectangleGGBCommands(5, [L, -L - l], h, L, [
+                        [2, 1],
+                        [0, 0],
+                        [2, 0],
+                        [0, 1],
+                    ]),
+                ];
+            }
+            break;
+        case 10:
+            {
+                return [
+                    //top row
+                    ...rectangleGGBCommands(0, [L + h, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 1],
+                        [0, 1],
+                        [2, 0],
+                    ]),
+                    ...rectangleGGBCommands(1, [2 * L + h, -(L - h)], l, h, [
+                        [1, 0],
+                        [2, 1],
+                        [1, 0],
+                        [2, 1],
+                    ]),
+                    ...rectangleGGBCommands(2, [2 * L + h + l, -(L - h)], L, h, [
+                        [0, 0],
+                        [2, 0],
+                        [0, 0],
+                        [2, 1],
+                    ]),
+                    //mid row
+                    ...rectangleGGBCommands(3, [0, -L], L, l, [
+                        [0, 0],
+                        [1, 1],
+                        [0, 0],
+                        [1, 0],
+                    ]),
+                    ...rectangleGGBCommands(4, [L, -L], h, l, [
+                        [2, 0],
+                        [1, 1],
+                        [2, 0],
+                        [1, 1],
+                    ]),
+                    ...rectangleGGBCommands(5, [L + h, -L], L, l, [
+                        [0, 1],
+                        [1, 0],
+                        [0, 0],
+                        [1, 1],
+                    ]),
+                    //bottom row
+                    //nothing
+                ];
+            }
+            break;
+        default:
+            throw new Error("Unsupported indexPattern: " + indexPattern);
+    }
+};
+const boundingCoordsRectangularPrismPattern = (indexPattern, L, l, h) => {
+    switch (indexPattern) {
+        case 0:
+        case 2:
+            return {
+                xMin: 0,
+                yMax: 0,
+                xMax: L + h + L + h,
+                yMin: -(L + l + L),
+            };
+        case 1:
+        case 3:
+            return {
+                xMin: 0,
+                yMax: 0,
+                xMax: L + h + L + h,
+                yMin: -(L + l + h),
+            };
+        case 4:
+            return {
+                xMin: 0,
+                yMax: -(L - h),
+                xMax: L + h + L + h,
+                yMin: -(L + l + h),
+            };
+        case 5:
+            return {
+                xMin: 0,
+                yMax: -(L - h),
+                xMax: L + h + L + h,
+                yMin: -(L + l + L),
+            };
+        case 6:
+            return {
+                xMin: L - l,
+                yMax: 0,
+                xMax: L + h + L + h,
+                yMin: -(L + l + L),
+            };
+        case 7:
+            return {
+                xMin: 0,
+                yMax: -(L - h),
+                xMax: L + h + L + l,
+                yMin: -(L + l + h),
+            };
+        case 8:
+            return {
+                xMin: L - l,
+                yMax: -(L - h),
+                xMax: L + h + L + h,
+                yMin: -(L + l + L),
+            };
+        case 9:
+            return {
+                xMin: L - l,
+                yMax: -(L - h),
+                xMax: L + h + L + l,
+                yMin: -(L + l + L),
+            };
+        case 10:
+            return {
+                xMin: 0,
+                yMax: -(L - h),
+                xMax: L + h + L + l + L,
+                yMin: -(L + l),
+            };
+        default:
+            throw new Error("Unsupported indexPattern: " + indexPattern);
+    }
+};
+const ggbCommandPrismFromRegularPolygonPattern = (
+// indexPattern: number,
+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 [
+        //top row
+        ...regularPolygonGGBCommands(0, [
+            [l + l, -ySpan],
+            [l, -ySpan],
+        ], nbSides, [...[...Array(nbSides - 1).keys()].map(() => [0, 0]), [0, 1]]),
+        //mid row
+        ...rectangleGGBCommands(1, [0, -ySpan], l, h, [
+            [0, 0],
+            [1, 1],
+            [0, 0],
+            [1, 0],
+        ]),
+        ...rectangleGGBCommands(2, [l, -ySpan], l, h, [
+            [0, 1],
+            [1, 1],
+            [0, 0],
+            [1, 1],
+        ]),
+        ...[...Array(nbSides - 3).keys()]
+            .map((i) => i + 3)
+            .flatMap((i) => rectangleGGBCommands(i, [(i - 1) * l, -ySpan], l, h, [
+            [0, 0],
+            [1, 1],
+            [0, 0],
+            [1, 1],
+        ])),
+        ...rectangleGGBCommands(nbSides, [(nbSides - 1) * l, -ySpan], l, h, [
+            [0, 0],
+            [1, 0],
+            [0, 0],
+            [1, 1],
+        ]),
+        //bottom row
+        ...regularPolygonGGBCommands(nbSides + 1, [
+            [l, -ySpan - h],
+            [l + l, -ySpan - h],
+        ], nbSides, [...[...Array(nbSides - 1).keys()].map(() => [0, 0]), [0, 1]]),
+    ];
+};
+const boundingCoordsPrismFromRegularPolygonPattern = (
+// indexPattern: number,
+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: 0,
+        yMax: 0,
+        xMax: nbSides * l,
+        yMin: -(2 * ySpan + h),
+    };
+};
+const ggbCommandPyramidFromRegularPolygonPattern = (
+// indexPattern: number,
+nbSides, l, h) => {
+    return [
+        //center
+        ...regularPolygonGGBCommands(0, [
+            [l + l, 0],
+            [l, 0],
+        ], nbSides, [...Array(nbSides).keys()].map(() => [0, 1])),
+        //ring
+        ...(() => {
+            const pointA = new Point("A", l + l, 0);
+            const pointB = new Point("B", l, 0);
+            const segmentBase = new Segment(pointA, pointB);
+            const points = regularPolygonPoints(0, segmentBase, nbSides);
+            const segments = zip(points, arrayRotation(points, 1)).map(([p1, p2]) => new Segment(p1, p2));
+            return segments.flatMap((segment, i) => {
+                const coordsBase = [segment.pointA, segment.pointB].map((point) => [
+                    point.x.evaluate(),
+                    point.y.evaluate(),
+                ]);
+                return triangleGGBCommands(i + 1, coordsBase, h, [
+                    [0, 1],
+                    [1, 0],
+                    [1, 0],
+                ]);
+            });
+        })(),
+    ];
+};
+const boundingCoordsPyramidFromRegularPolygonPattern = (
+// indexPattern: number,
+nbSides, l, h) => {
+    //ugly
+    const pointA = new Point("A", l + l, 0);
+    const pointB = new Point("B", l, 0);
+    const segmentBase = new Segment(pointA, pointB);
+    const points = regularPolygonPoints(0, segmentBase, nbSides);
+    const segments = zip(points, arrayRotation(points, 1)).map(([p1, p2]) => new Segment(p1, p2));
+    const pointsTriangle = segments.flatMap((segment, i) => {
+        return trianglePoints(i + 1, segment, h);
+    });
+    const arrXSorted = pointsTriangle
+        .map((point) => point.x.evaluate())
+        .toSorted((x1, x2) => x1 - x2);
+    const arrYSorted = pointsTriangle
+        .map((point) => point.y.evaluate())
+        .toSorted((y1, y2) => y1 - y2);
+    return {
+        xMin: arrXSorted[0],
+        xMax: arrXSorted[arrXSorted.length - 1],
+        yMin: arrYSorted[0],
+        yMax: arrYSorted[arrYSorted.length - 1],
+    };
+};
+const ggbCommandCylinderPattern = (
+// indexPattern: number,
+l, h) => {
+    const w = 2 * PiNode.evaluate() * l;
+    return [
+        //top
+        `C_0 = Circle((${w / 2},${-l}),${l})`,
+        `SetColor(C_0, "${colors[0]}")`,
+        //mid
+        ...rectangleGGBCommands(1, [0, -l - l], w, h, [...Array(4).keys()].map((i) => (i % 2 === 0 ? [1, 0] : [2, 0]))),
+        //bottom
+        `C_2 = Circle((${w / 2},${-l - l - h - l}),${l})`,
+        `SetColor(C_2, "${colors[0]}")`,
+    ];
+};
+const boundingCoordsCylinderPattern = (
+// indexPattern: number,
+l, //radius
+h) => {
+    return {
+        xMin: 0,
+        yMax: 0,
+        xMax: 2 * PiNode.evaluate() * l,
+        yMin: -(4 * l + h),
+    };
+};
+const ggbCommandConePattern = (
+// indexPattern: number,
+l, h) => {
+    const a = Math.sqrt(l ** 2 + h ** 2); //apothème du cône
+    const angleSector = (l / a) * 2 * PiNode.evaluate();
+    const angleRest = 2 * PiNode.evaluate() - angleSector;
+    const pointCSCenter = new Point("P_CS_center", l + l / Math.sqrt(2) + a / Math.sqrt(2), -(l + l / Math.sqrt(2) + a / Math.sqrt(2)));
+    const pointCSDiag = new Point("P_CS_diag", pointCSCenter.x.evaluate() + a / Math.sqrt(2), pointCSCenter.y.evaluate() - a / Math.sqrt(2));
+    const pointCS1 = rotatePoint(pointCSDiag, angleRest / 2, pointCSCenter, "P_CS1");
+    const pointCS2 = rotatePoint(pointCSDiag, -angleRest / 2, pointCSCenter, "P_CS2");
+    return [
+        //top
+        `C_0 = Circle((${l},${-l}),${l})`,
+        `SetColor(C_0, "${colors[0]}")`,
+        //mid
+        `CS_1 = CircularSector(${pointCSCenter.toMathString()}, ${pointCS1.toMathString()}, ${pointCS2.toMathString()})`,
+        `SetColor(C_0, "${colors[0]}")`,
+    ];
+};
+const boundingCoordsConePattern = (
+// indexPattern: number,
+l, //radius
+h) => {
+    const a = Math.sqrt(l ** 2 + h ** 2); //apothème du cône
+    return {
+        xMin: 0,
+        yMax: 0,
+        xMax: l + l / Math.sqrt(2) + a / Math.sqrt(2) + a,
+        yMin: -(l + l / Math.sqrt(2) + a / Math.sqrt(2) + a),
+    };
+};
+const patternFamilies = [
+    {
+        str: "un cube",
+        patterns: [...Array(11).keys()].map((indexPattern) => {
+            return {
+                ggbCommandsFunc: (L, l, h) => ggbCommandRectangularPrismPattern(indexPattern, L, l, h),
+                boundingCoordsFunc: (L, l, h) => boundingCoordsRectangularPrismPattern(indexPattern, L, l, h),
+            };
+        }),
+    },
+    {
+        str: "un pavé droit",
+        patterns: [...Array(11).keys()].map((indexPattern) => {
+            return {
+                ggbCommandsFunc: (L, l, h) => ggbCommandRectangularPrismPattern(indexPattern, L, l, h),
+                boundingCoordsFunc: (L, l, h) => boundingCoordsRectangularPrismPattern(indexPattern, L, l, h),
+            };
+        }),
+    },
+    {
+        str: "un prisme droit de polygone régulier",
+        patterns: [...Array(1).keys()].map((_) => {
+            return {
+                ggbCommandsFunc: (nbSides, l, h) => ggbCommandPrismFromRegularPolygonPattern(
+                /*indexPattern,*/ nbSides, l, h),
+                boundingCoordsFunc: (nbSides, l, h) => boundingCoordsPrismFromRegularPolygonPattern(
+                /*indexPattern,*/ nbSides, l, h),
+            };
+        }),
+    },
+    {
+        str: "une pyramide régulière",
+        patterns: [...Array(1).keys()].map((_) => {
+            return {
+                ggbCommandsFunc: (nbSides, l, h) => ggbCommandPyramidFromRegularPolygonPattern(
+                /*indexPattern,*/ nbSides, l, h),
+                boundingCoordsFunc: (nbSides, l, h) => boundingCoordsPyramidFromRegularPolygonPattern(
+                /*indexPattern,*/ nbSides, l, h),
+            };
+        }),
+    },
+    {
+        str: "un cylindre",
+        patterns: [...Array(1).keys()].map((_) => {
+            return {
+                ggbCommandsFunc: (_, l, h) => ggbCommandCylinderPattern(/*indexPattern,*/ l, h),
+                boundingCoordsFunc: (_, l, h) => boundingCoordsCylinderPattern(/*indexPattern,*/ l, h),
+            };
+        }),
+    },
+    {
+        str: "un cône",
+        patterns: [...Array(1).keys()].map((_) => {
+            return {
+                ggbCommandsFunc: (_, l, h) => ggbCommandConePattern(/*indexPattern,*/ l, h),
+                boundingCoordsFunc: (_, l, h) => boundingCoordsConePattern(/*indexPattern,*/ l, h),
+            };
+        }),
+    },
+];
+const getInstruction = () => {
+    return `De quel solide la figure ci-dessous est-elle le patron ?`;
+};
+const getAnswer = (identifiers) => {
+    const { indexFamily } = identifiers;
+    const pattern = patternFamilies[indexFamily];
+    return pattern.str;
+};
+const getHint = () => {
+    return `Les hachures indiquent les endroits où l'on plie le patron.
+Il n'y a pas de languettes sur les patrons en mathématiques.`;
+};
+const getCorrection = (identifiers) => {
+    return `C'est le patron d'${getAnswer(identifiers)}.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { indexFamily, indexPattern, L, l, h } = identifiers;
+    const patternFamily = patternFamilies[indexFamily];
+    const pattern = patternFamily.patterns[indexPattern];
+    const commands = [...pattern.ggbCommandsFunc(L, l, h)];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords(pattern.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"];
+            }
+            break;
+        default:
+            {
+                arrStrWrong = patternFamilies.map((patternFamily) => patternFamily.str);
+            }
+            break;
+    }
+    arrStrWrong.forEach((str) => {
+        tryToAddWrongProp(propositions, str, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSolidFromSolidPatternQuestion = () => {
+    const indexFamily = randint(0, patternFamilies.length);
+    const patternFamily = patternFamilies[indexFamily];
+    const indexPattern = randint(0, patternFamily.patterns.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:
+        case 5:
+            {
+                //L is useless
+                L = 0;
+                [l, h] = randomMany([...Array(20).keys()].map((i) => i + 5), 2);
+            }
+            break;
+        default:
+            throw new Error("Unsupported indexFamily: " + indexFamily);
+    }
+    const identifiers = { indexFamily, indexPattern, L, l, h };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSolidFromSolidPattern = {
+    id: "recognizeSolidFromSolidPattern",
+    connector: "=",
+    label: "Nommer un solide à partir de son patron",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRecognizeSolidFromSolidPatternQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};