math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.js

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { GeneralSystemConstructor, } from "../../../math/systems/generalSystem.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, MatrixConstructor.random(2, 2).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const matrix = system.getMatrix();
+    return matrix.toTex();
+};
+const getInstruction = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    return `On considère le système $(S)$ suivant :
+
+$$
+${system.toTex()}
+$$
+
+On cherche à écrire ce système sous forme matricielle : 
+
+$$
+AX = B
+$$
+
+avec $X = \\begin{pmatrix}x\\\\ y\\end{pmatrix}$ et $B = \\begin{pmatrix}${system.coeffs[0][2].toTex()}\\\\ ${system.coeffs[1][2].toTex()}\\end{pmatrix}$.
+
+
+Écrire $A$.`;
+};
+const getHint = () => {
+    return `En faisant le produit de $A$ par $X$, on doit obtenir la partie gauche du système.`;
+};
+const getCorrection = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const coeffs = system.coeffs.map((row) => row.slice(0, 2));
+    const matrix = new Matrix(coeffs).toTex();
+    return `En posant $X = \\begin{pmatrix}x\\\\ y\\end{pmatrix}$, $B = \\begin{pmatrix}${system.coeffs[0][2].toTex()}\\\\ ${system.coeffs[1][2].toTex()}\\end{pmatrix}$ et :
+  
+$$
+A = ${matrix}
+$$
+
+on obtient bien $(S)\\iff AX=B$.`;
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getWriteMatrixAssociatedToSystemQuestion = () => {
+    const sys = GeneralSystemConstructor.random();
+    const identifiers = {
+        systemIds: sys.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const writeMatrixAssociatedToSystem = {
+    id: "writeMatrixAssociatedToSystem",
+    connector: "=",
+    label: "Écrire la matrice associée à un système d'équations linéaires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWriteMatrixAssociatedToSystemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -6,4 +6,5 @@ export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
 export * from "./spaceVectorLinearCombinationFromCoords.js";
 export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
 export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";
+export * from "./spaceSegmentLengthInRectangularPrism.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AACzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,0DAA0D,CAAC;AACzE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,oDAAoD,CAAC;AACnE,cAAc,2CAA2C,CAAC"}

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

@@ -6,3 +6,4 @@ export * from "./spaceCoordinatesOfPointInCubeCoordSystemFromVecPath.js";
 export * from "./spaceVectorLinearCombinationFromCoords.js";
 export * from "./lineLineRelativePositionsFromCubeOuterPoints.js";
 export * from "./linePlaneRelativePositionsFromCubeOuterPoints.js";
+export * from "./spaceSegmentLengthInRectangularPrism.js";

package/lib/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+/**********/
+type Identifiers = {
+    rectangularPrismOrigin: SpacePointIdentifiers;
+    L: number;
+    l: number;
+    h: number;
+    arrSegmentSpacePointIds: SpacePointIdentifiers[];
+    acceptedInputType: string;
+};
+type Options = {
+    acceptedInputType: string;
+    nbComponents: string;
+};
+export declare const spaceSegmentLengthInRectangularPrism: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=spaceSegmentLengthInRectangularPrism.d.ts.map

package/lib/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceSegmentLengthInRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AA2N3C,YAAY;AAEZ,KAAK,WAAW,GAAG;IAEjB,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IAEV,uBAAuB,EAAE,qBAAqB,EAAE,CAAC;IACjD,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAojBF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAmCF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAsBR,CAAC"}

package/lib/exercises/math/spaceGeometry/basis/spaceSegmentLengthInRectangularPrism.js

@@ -0,0 +1,538 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { blueMain, colorWithOpacity, greenMain, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getCoordsForFrame = (spacePointStart, spacePointEnd) => {
+    const [arrAxisMin, arrAxisMax] = [Math.min, Math.max].map((funcMinMax) => {
+        return ["x", "y", "z"].map((axis) => {
+            const [vAxisStart, vAxisEnd] = [spacePointStart, spacePointEnd]
+                .map((spacePoint) => spacePoint[axis])
+                .map((node) => node.evaluate());
+            return funcMinMax(vAxisStart, vAxisEnd);
+        });
+    });
+    const [xMin, yMin, zMin] = arrAxisMin;
+    const [xMax, yMax, zMax] = arrAxisMax;
+    return [xMin, xMax, yMin, yMax, zMin, zMax];
+};
+const createArrSpacePointBoundingBox = (spacePointStart, spacePointEnd) => {
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    const arrSpacePoint = getCartesiansProducts([
+        [xMin, xMax],
+        [yMin, yMax],
+        [zMin, zMax],
+    ]).map(([x, y, z], i) => {
+        return SpacePointConstructor.fromScalars([x, y, z], `PBB${i}`);
+    });
+    return arrSpacePoint;
+};
+const getAcceptedInputTypesSentence = (acceptedInputType) => {
+    return `Donner le résultat
+${(() => {
+        switch (acceptedInputType) {
+            case "exact":
+                return "sous forme exacte";
+            default:
+            case "arrondi au centième":
+                return "arrondie au centième";
+        }
+    })()}.`;
+};
+const getFormattedNode = (node, acceptedInputType) => {
+    switch (acceptedInputType) {
+        case "exact":
+            return node;
+        default:
+        case "arrondi au centième":
+            return round(node.evaluate(), 2).toTree();
+    }
+};
+/**********/
+function* genFuncNamePretty() {
+    const arrLetter = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+    yield* arrLetter;
+    return "Done";
+}
+const getRectangularPrismPoints = (rectangularPrismOriginSpacePoint, L, l, h) => {
+    const [x1, y1, z1] = [
+        rectangularPrismOriginSpacePoint.x,
+        rectangularPrismOriginSpacePoint.y,
+        rectangularPrismOriginSpacePoint.z,
+    ].map((node) => node.evaluate());
+    const [x2, y2, z2] = [x1, y1, z1].map((t, i) => add(t, [L, l, h][i]).evaluate());
+    return [
+        //bottom
+        SpacePointConstructor.fromScalars([x1, y1, z1]),
+        SpacePointConstructor.fromScalars([x1, y2, z1]),
+        SpacePointConstructor.fromScalars([x2, y2, z1]),
+        SpacePointConstructor.fromScalars([x2, y1, z1]),
+        //top
+        SpacePointConstructor.fromScalars([x1, y1, z2]),
+        SpacePointConstructor.fromScalars([x1, y2, z2]),
+        SpacePointConstructor.fromScalars([x2, y2, z2]),
+        SpacePointConstructor.fromScalars([x2, y1, z2]),
+    ];
+};
+const createPointMeshForSide = (spacePointOrigin, u, v, nbH, nbW) => {
+    return [...Array(nbH + 1).keys()].map((i) => [...Array(nbW + 1).keys()].map((j) => {
+        const spaceVec = u.times(i.toTree()).add(v.times(j.toTree()));
+        const spacePointIJ = spaceVec.getEndPoint(spacePointOrigin);
+        return spacePointIJ;
+    }));
+};
+const createSegmentMeshForPointMesh = (pointMesh) => {
+    //horiz
+    const arrSegmentHoriz = pointMesh.map((rowOfPoints) => {
+        return [rowOfPoints[0], rowOfPoints[rowOfPoints.length - 1]];
+    });
+    //vert
+    const arrSegmentVert = transpose(pointMesh).map((columnOfPoints) => {
+        return [columnOfPoints[0], columnOfPoints[columnOfPoints.length - 1]];
+    });
+    return [...arrSegmentHoriz, ...arrSegmentVert];
+};
+const getAllPointMeshes = (rectangularPrismOriginSpacePoint, L, l, h) => {
+    return [
+        //z-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 1, 0]), L, l),
+        //z+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([0, 0, h]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 1, 0]), L, l),
+        //y-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), L, h),
+        //y+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([0, l, 0]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), L, h),
+        //x-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([0, 1, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), l, h),
+        //x+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([L, 0, 0]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([0, 1, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), l, h),
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { L, l, h, arrSegmentSpacePointIds, acceptedInputType } = identifiers;
+    const arrSegmentSpacePoint = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    return `Le pavé droit affiché a les dimensions suivantes : 
+- longueur : $${L.frenchify()}$
+- largeur : $${l.frenchify()}$
+- hauteur : $${h.frenchify()}$
+
+Quelle est la longueur du segment $${texSegment}$ ?
+${getAcceptedInputTypesSentence(acceptedInputType)}
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const createNodeSumOfSquares = (identifiers, isShouldFilterOutZeros = true) => {
+    const { arrSegmentSpacePointIds } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSubNode = ["x", "y", "z"]
+        .map((axis) => square(abs(substract(spacePointEnd[axis], spacePointStart[axis])).simplify({ towardsDistribute: true })))
+        .filter((node) => isShouldFilterOutZeros
+        ? !NodeComparator.isEqualViaSub(node, (0).toTree())
+        : true);
+    const nodeSumOfSquares = operatorComposition(AddNode, arrSubNode);
+    return nodeSumOfSquares;
+};
+const getAnswerNode = (identifiers, isShouldFilterOutZeros = true) => {
+    const nodeSumOfSquares = createNodeSumOfSquares(identifiers, isShouldFilterOutZeros);
+    const nodeAnswerRaw = sqrt(nodeSumOfSquares);
+    return nodeAnswerRaw;
+};
+const getAnswer = (identifiers) => {
+    const { acceptedInputType } = identifiers;
+    return getFormattedNode(getAnswerNode(identifiers), acceptedInputType)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { arrSegmentSpacePointIds } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    const texVec = `\\overrightarrow{${spacePointStart.name}${spacePointEnd.name}}`;
+    return `La longueur du segment $${texSegment}$ est la norme du vecteur $\\overrightarrow{v} = ${texVec}$. 
+Détermine les $3$ composantes $v_x$, $v_y$, $v_z$ 
+et utilise la formule (qui découle d'une double application du théorème de Pythagore) : 
+
+$$
+\\lVert \\overrightarrow v \\rVert = \\sqrt{ {v_x}^2 + {v_y}^2 + {v_z}^2 }
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { arrSegmentSpacePointIds, acceptedInputType } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const texLength = `${spacePointStart.name}${spacePointEnd.name}`;
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    const texVec = `\\overrightarrow{${spacePointStart.name}${spacePointEnd.name}}`;
+    const nodeAnswer = getAnswerNode(identifiers, false);
+    return `La longueur du segment $${texSegment}$ est la norme du vecteur $${texVec}$. 
+On détermine les $3$ composantes $v_x$, $v_y$, $v_z$ :
+et utilise la formule (qui découle d'une double application du théorème de Pythagore) : 
+
+${alignTex([
+        [texLength, "=", `\\lVert ${texVec} \\rVert`],
+        ["", "=", nodeAnswer.toTex()],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+        ...(acceptedInputType === "arrondi au centième"
+            ? [
+                [
+                    "",
+                    "\\approx",
+                    getFormattedNode(nodeAnswer, acceptedInputType).toTex(),
+                ],
+            ]
+            : [[]]),
+    ])}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { rectangularPrismOrigin, L, l, h, arrSegmentSpacePointIds } = identifiers;
+    const spacePointRectangularPrismOrigin = SpacePointConstructor.fromIdentifiers(rectangularPrismOrigin);
+    const rectangularPrismSpacePoints = getRectangularPrismPoints(spacePointRectangularPrismOrigin, L, l, h);
+    const arrSegmentSpacePoint = [...arrSegmentSpacePointIds].map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePoint = [
+        // spacePointRectangularPrismOrigin,
+        ...arrSegmentSpacePoint,
+    ];
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const arrSpacePointBoundingBox = createArrSpacePointBoundingBox(spacePointStart, spacePointEnd);
+    const arrSide = getAllPointMeshes(rectangularPrismSpacePoints[0], L, l, h);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0.1)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePoint.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${rectangularPrismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 14)}")`,
+            `SetLineThickness(Pri, 1)`,
+            //segment meshes
+            ...arrSegment.flatMap(([spacePointStart, spacePointEnd], i) => {
+                return [
+                    `S_${i} = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+                    `SetColor(S_${i}, "${colorWithOpacity("#BBBBBB", 37)}")`, //opacity is ignored
+                    `SetLineThickness(S_${i}, 1)`,
+                ];
+            }),
+        ],
+        //segment
+        `segInstruction = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+        `SetLineThickness(segInstruction, 4)`,
+        `SetColor(segInstruction, "${blueMain}")`,
+        //boundingBox of segment
+        `polyBoundinBox = Polygon(${[
+            arrSpacePointBoundingBox[0],
+            arrSpacePointBoundingBox[1],
+            arrSpacePointBoundingBox[3],
+            arrSpacePointBoundingBox[2],
+        ]
+            .map((p) => p.toMathString())
+            .join(",")})`,
+        `priBoundingBox = Prism(polyBoundinBox, ${arrSpacePointBoundingBox[4].toMathString()})`,
+        `SetColor(priBoundingBox, "${colorWithOpacity(`${greenMain}`, 69)}")`,
+        `SetLineThickness(priBoundingBox, 2)`,
+        // `RunUpdateScript()`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.5, -1, -1],
+    });
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2, zMin - 2, zMax + 2],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { rectangularPrismOrigin, L, l, h, arrSegmentSpacePointIds } = identifiers;
+    const spacePointRectangularPrismOrigin = SpacePointConstructor.fromIdentifiers(rectangularPrismOrigin);
+    const rectangularPrismSpacePoints = getRectangularPrismPoints(spacePointRectangularPrismOrigin, L, l, h);
+    const arrSegmentSpacePoint = [...arrSegmentSpacePointIds].map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePoint = [
+        // spacePointRectangularPrismOrigin,
+        ...arrSegmentSpacePoint,
+    ];
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const arrSide = getAllPointMeshes(rectangularPrismSpacePoints[0], L, l, h);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0.1)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePoint.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${rectangularPrismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 14)}")`,
+            `SetLineThickness(Pri, 1)`,
+            //segment meshes
+            ...arrSegment.flatMap(([spacePointStart, spacePointEnd], i) => {
+                return [
+                    `S_${i} = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+                    `SetColor(S_${i}, "${colorWithOpacity("#BBBBBB", 37)}")`, //opacity is ignored
+                    `SetLineThickness(S_${i}, 1)`,
+                ];
+            }),
+        ],
+        //segment
+        `segInstruction = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+        `SetLineThickness(segInstruction, 4)`,
+        `SetColor(segInstruction, "${blueMain}")`,
+        // `RunUpdateScript()`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.5, -1, -1],
+    });
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2, zMin - 2, zMax + 2],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        nbComponents: random(arrayedOpts.nbComponents),
+    };
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { acceptedInputType } = identifiers;
+    const createNodeSum = (identifiers, isShouldFilterOutZeros = true) => {
+        const { arrSegmentSpacePointIds } = identifiers;
+        const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+        const arrSubNode = ["x", "y", "z"]
+            .map((axis) => abs(substract(spacePointEnd[axis], spacePointStart[axis])).simplify({ towardsDistribute: true }))
+            .filter((node) => isShouldFilterOutZeros
+            ? !NodeComparator.isEqualViaSub(node, (0).toTree())
+            : true);
+        const nodeSumOfSquares = operatorComposition(AddNode, arrSubNode);
+        return nodeSumOfSquares;
+    };
+    //student: forgets squares
+    {
+        const nodeWrong = getFormattedNode(sqrt(createNodeSum(identifiers, true)).simplify({
+            towardsDistribute: true,
+        }), acceptedInputType);
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    if (coinFlip()) {
+        //student: forgets sqrt
+        {
+            const nodeWrong = getFormattedNode(createNodeSumOfSquares(identifiers, true).simplify({
+                towardsDistribute: true,
+            }), acceptedInputType);
+            tryToAddWrongProp(propositions, nodeWrong.toTex());
+        }
+    }
+    else {
+        //student: forgets sqrt and squares
+        {
+            const nodeWrong = getFormattedNode(createNodeSum(identifiers, true).simplify({
+                towardsDistribute: true,
+            }), acceptedInputType);
+            tryToAddWrongProp(propositions, nodeWrong.toTex());
+        }
+    }
+    //student: l'âge du capitaine
+    {
+        const { L, l, h } = identifiers;
+        const nodeWrong = getFormattedNode(sqrt(operatorComposition(AddNode, [L, l, h].map((v) => square(v)))), acceptedInputType).simplify({
+            towardsDistribute: true,
+        });
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }, _optsIn) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (_) {
+        return false;
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const L = randint(3, 7);
+    const l = randint(3, 7);
+    const h = randint(3, 7);
+    const genNamePretty = genFuncNamePretty();
+    const rectangularPrismOriginSpacePoint = SpacePointConstructor.fromScalars([0, 0, 0], genNamePretty.next().value);
+    function createSpacePointWithPrettyName(spacePoint) {
+        const namePretty = genNamePretty.next().value;
+        const spacePointWithPrettyName = SpacePointConstructor.fromIdentifiers(Object.assign({}, spacePoint.toIdentifiers(), {
+            name: namePretty,
+        }));
+        return spacePointWithPrettyName;
+    }
+    const arrSide = getAllPointMeshes(rectangularPrismOriginSpacePoint, L, l, h).map((arrArrSpacePoint) => arrArrSpacePoint.flat());
+    function getNbShared(spacePoint1, spacePoint2) {
+        return zip([spacePoint1.x, spacePoint1.y, spacePoint1.z], [spacePoint2.x, spacePoint2.y, spacePoint2.z]).reduce((acc, [nodeSpacePoint1Axis, nodeSpacePoint2Axis]) => {
+            return (acc +
+                (NodeComparator.isEqualViaSub(nodeSpacePoint1Axis, nodeSpacePoint2Axis)
+                    ? 1
+                    : 0));
+        }, 0);
+    }
+    function getSpacePoint2(arrSpacePoint, spacePoint1Raw, nbDifferent) {
+        const arrSpacePointCandidate = arrSpacePoint.filter((spacePoint2Raw) => {
+            const nbShared = getNbShared(spacePoint2Raw, spacePoint1Raw);
+            return nbShared === 3 - nbDifferent;
+        });
+        return random(arrSpacePointCandidate);
+    }
+    const arrSegmentSpacePoint = (() => {
+        switch (opts.nbComponents) {
+            case "2": {
+                const arrSpacePoint = random(arrSide);
+                const spacePoint1Raw = random(arrSpacePoint);
+                const spacePoint2Raw = getSpacePoint2(arrSpacePoint, spacePoint1Raw, 2);
+                return [spacePoint1Raw, spacePoint2Raw].map(createSpacePointWithPrettyName);
+            }
+            case "3": {
+                const [arrSpacePoint1, arrSpacePoint2] = randomMany(arrSide, 2);
+                let isFound = false;
+                let spacePoint1Raw;
+                let spacePoint2Raw;
+                while (!isFound) {
+                    spacePoint1Raw = random(arrSpacePoint1);
+                    spacePoint2Raw = getSpacePoint2(arrSpacePoint2, spacePoint1Raw, 3);
+                    isFound = spacePoint2Raw !== undefined;
+                }
+                return [spacePoint1Raw, spacePoint2Raw].map(createSpacePointWithPrettyName);
+            }
+            default:
+                throw new Error("Unsupported opts.nbComponents: " + opts.nbComponents);
+        }
+    })();
+    const identifiers = {
+        rectangularPrismOrigin: rectangularPrismOriginSpacePoint.toIdentifiers(),
+        L,
+        l,
+        h,
+        arrSegmentSpacePointIds: arrSegmentSpacePoint.map((spacePoint) => spacePoint.toIdentifiers()),
+        acceptedInputType: opts.acceptedInputType,
+    };
+    return identifiers;
+};
+const getSpaceSegmentLengthInRectangularPrismQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        nbComponents: random(arrayedOpts.nbComponents),
+    };
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        identifiers,
+        keys: getKeys(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    acceptedInputType: "exact",
+};
+const arrayedOptsDefault = {
+    nbComponents: ["2", "3"],
+};
+const options = [
+    {
+        id: "nbComponents",
+        label: "Nombre de composantes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["2", "3"],
+        defaultValue: arrayedOptsDefault.nbComponents,
+    },
+    {
+        id: "acceptedInputType",
+        label: "Format du résultat",
+        target: GeneratorOptionTarget.vea,
+        type: GeneratorOptionType.select,
+        values: ["exact", "arrondi au centième"],
+        defaultValue: optsDefault.acceptedInputType,
+    },
+];
+export const spaceSegmentLengthInRectangularPrism = {
+    id: "spaceSegmentLengthInRectangularPrism",
+    connector: "=",
+    label: "Longueur d'un segment dans un pavé droit",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSpaceSegmentLengthInRectangularPrismQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+    getPropositions,
+};