math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,595 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { 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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+/**
+  BEGIN CUBE STUFF
+*/
+const getSpacePointForRelativeCoords = (spacePointOrigin, coords, arrVec) => {
+    return zip(coords.map((v) => v.toTree()), arrVec).reduce((acc, [nodeFactor, vec]) => {
+        const vecScaled = vec.times(nodeFactor);
+        return vecScaled.getEndPoint(acc);
+    }, spacePointOrigin);
+};
+const getPrismPoints = (spacePointOrigin, vecX, vecY, vecZ) => {
+    const isRightHanded = vecX.vetorialProduct(vecY).scalarProduct(vecZ).evaluate() > 0;
+    const [vecXRH, vecYRH, vecZRH] = isRightHanded
+        ? [vecX, vecY, vecZ]
+        : [vecY, vecX, vecZ];
+    const arrCoordsWrtCubeVecs = [
+        [0, 0, 0],
+        [0, 1, 0],
+        [1, 1, 0],
+        [1, 0, 0],
+        [0, 0, 1],
+        [0, 1, 1],
+        [1, 1, 1],
+        [1, 0, 1],
+    ];
+    return arrCoordsWrtCubeVecs.map((coords) => getSpacePointForRelativeCoords(spacePointOrigin, coords, [
+        vecXRH,
+        vecYRH,
+        vecZRH,
+    ]));
+};
+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 = (spacePointOrigin, vecX, vecY, vecZ) => {
+    const isRightHanded = vecX.vetorialProduct(vecY).scalarProduct(vecZ).evaluate() > 0;
+    const [vecXRH, vecYRH, vecZRH] = isRightHanded
+        ? [vecX, vecY, vecZ]
+        : [vecY, vecX, vecZ];
+    const nbS = 2;
+    const nodeFactorS = (0.5).toTree();
+    return [
+        //z-
+        createPointMeshForSide(spacePointOrigin, vecXRH.times(nodeFactorS), vecYRH.times(nodeFactorS), nbS, nbS),
+        //z+
+        createPointMeshForSide(vecZRH.getEndPoint(spacePointOrigin, "NoName"), vecXRH.times(nodeFactorS), vecYRH.times(nodeFactorS), 2, 2),
+        //y-
+        createPointMeshForSide(spacePointOrigin, vecXRH.times(nodeFactorS), vecZRH.times(nodeFactorS), nbS, nbS),
+        //y+
+        createPointMeshForSide(vecYRH.getEndPoint(spacePointOrigin, "NoName"), vecXRH.times(nodeFactorS), vecZRH.times(nodeFactorS), 2, 2),
+        //x-
+        createPointMeshForSide(spacePointOrigin, vecYRH.times(nodeFactorS), vecZRH.times(nodeFactorS), nbS, nbS),
+        //x+
+        createPointMeshForSide(vecXRH.getEndPoint(spacePointOrigin, "NoName"), vecYRH.times(nodeFactorS), vecZRH.times(nodeFactorS), 2, 2),
+    ];
+};
+const getArrCoordsFrame = (arrSpacePoint) => {
+    const xMin = arrSpacePoint
+        .map((spacePoint) => spacePoint.x.evaluate())
+        .reduce((acc, x) => Math.min(acc, x));
+    const xMax = arrSpacePoint
+        .map((spacePoint) => spacePoint.x.evaluate())
+        .reduce((acc, x) => Math.max(acc, x));
+    const yMin = arrSpacePoint
+        .map((spacePoint) => spacePoint.y.evaluate())
+        .reduce((acc, x) => Math.min(acc, x));
+    const yMax = arrSpacePoint
+        .map((spacePoint) => spacePoint.y.evaluate())
+        .reduce((acc, x) => Math.max(acc, x));
+    const zMin = arrSpacePoint
+        .map((spacePoint) => spacePoint.z.evaluate())
+        .reduce((acc, x) => Math.min(acc, x));
+    const zMax = arrSpacePoint
+        .map((spacePoint) => spacePoint.z.evaluate())
+        .reduce((acc, x) => Math.max(acc, x));
+    return [xMin, xMax, yMin, yMax, zMin, zMax].map((v) => v * 1.1);
+};
+/**
+  END CUBE STUFF
+*/
+const isLinePlaneParallel = ([P1, P2], [P3, P4, P5]) => {
+    //P1P2 \\cdot (P3P4 \\wedge P3P5) = 0
+    const [vecP1P2, vecP3P4, vecP3P5] = [
+        [P1, P2],
+        [P3, P4],
+        [P3, P5],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    return NodeComparator.isEqualViaSub(vecP1P2.scalarProduct(vecP3P4.vetorialProduct(vecP3P5)), (0).toTree());
+};
+const isLinePlaneCoplanar = ([P1, P2], [P3, P4, P5]) => {
+    const [vecP3P1, vecP3P2, vecP3P4, vecP3P5] = [
+        [P3, P1],
+        [P3, P2],
+        [P3, P4],
+        [P3, P5],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    const vecNormal = vecP3P4.vetorialProduct(vecP3P5);
+    return [vecP3P1, vecP3P2].every((vec) => NodeComparator.isEqualViaSub(vec.scalarProduct(vecNormal), (0).toTree()));
+};
+const isLinePlaneIntersect = ([P1, P2], [P3, P4, P5]) => {
+    return !isLinePlaneParallel([P1, P2], [P3, P4, P5]);
+};
+const isLinePlaneOrthogonal = ([P1, P2], [P3, P4, P5]) => {
+    //P1P2 \\wedge (P3P4 \\wedge P3P5) = vec0
+    const [vecP1P2, vecP3P4, vecP3P5] = [
+        [P1, P2],
+        [P3, P4],
+        [P3, P5],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    const vecProductProduct = vecP1P2.vetorialProduct(vecP3P4.vetorialProduct(vecP3P5));
+    return [vecProductProduct.x, vecProductProduct.y, vecProductProduct.z].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+};
+const createMyPropositions = (identifiers) => {
+    const { arrSpacePointNamed } = getHydrated(identifiers);
+    const [P1, P2, P3, P4, P5] = arrSpacePointNamed;
+    const propositions = [];
+    const isIntersect = isLinePlaneIntersect([P1, P2], [P3, P4, P5]);
+    const isParallel = isLinePlaneParallel([P1, P2], [P3, P4, P5]);
+    const isCoplanar = isLinePlaneCoplanar([P1, P2], [P3, P4, P5]);
+    const isOrthogonal = isLinePlaneOrthogonal([P1, P2], [P3, P4, P5]);
+    //intersect
+    {
+        const str = `$(${P1.name}${P2.name})$ et $\\mathcal{P}$ ont un seul point d'intersection.`;
+        if (isIntersect) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //parallel
+    {
+        const str = `$(${P1.name}${P2.name})$ est parallèle à $\\mathcal{P}$.`;
+        if (isParallel) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //orthogonal
+    {
+        const str = `$(${P1.name}${P2.name})$ est orthogonale à $\\mathcal{P}$.`;
+        if (isOrthogonal) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //coplanar
+    {
+        if (isCoplanar && coinFlip()) {
+            const str = `$(${P1.name}${P2.name})$ est incluse dans $\\mathcal{P}$.`;
+            if (isCoplanar) {
+                addValidProp(propositions, str, "raw");
+            }
+            else {
+                tryToAddWrongProp(propositions, str, "raw");
+            }
+        }
+        else {
+            const str = `$(${P1.name}${P2.name})$ n'est pas incluse dans $\\mathcal{P}$.`;
+            if (!isCoplanar) {
+                addValidProp(propositions, str, "raw");
+            }
+            else {
+                tryToAddWrongProp(propositions, str, "raw");
+            }
+        }
+    }
+    return propositions;
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIdsCubeOrigin, spacePointIdsCubeVecsEndPoint, spacePointIdsBaseVecsEndPoint, spacePointIdsWrtBaseVecs, } = identifiers;
+    const spacePointCubeOrigin = SpacePointConstructor.fromIdentifiers(spacePointIdsCubeOrigin);
+    const [arrCubeVec, arrBaseVec] = [
+        spacePointIdsCubeVecsEndPoint,
+        spacePointIdsBaseVecsEndPoint,
+    ].map((arr) => arr.map((pointIds) => SpaceVectorConstructor.fromPoints(spacePointCubeOrigin, SpacePointConstructor.fromIdentifiers(pointIds))));
+    const arrSpacePointWrtBaseVecs = spacePointIdsWrtBaseVecs.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePointNamed = arrSpacePointWrtBaseVecs.map((spacePointWrtBaseVecs) => {
+        const spacePoint = getSpacePointForRelativeCoords(spacePointCubeOrigin, [
+            spacePointWrtBaseVecs.x,
+            spacePointWrtBaseVecs.y,
+            spacePointWrtBaseVecs.z,
+        ].map((node) => node.evaluate()), arrBaseVec);
+        spacePoint.name = spacePointWrtBaseVecs.name;
+        return spacePoint;
+    });
+    return {
+        spacePointCubeOrigin,
+        arrCubeVec,
+        arrBaseVec,
+        arrSpacePointNamed,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { arrSpacePointNamed } = getHydrated(identifiers);
+    const [P1, P2, P3, P4, P5] = arrSpacePointNamed;
+    return `Donner la position relative des droites $(${P1.name}${P2.name})$ et du plan $\\mathcal{P}$ contenant les points $${P3.name}$,$${P4.name}$ et $${P5.name}$.
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getHint = () => {
+    return `Une droite est orthogonale a un plan quand son vecteur directeur est un vecteur normal de ce plan.
+Une droite est parallèle à un plan quand son vecteur directeur est colinéaire à deux vecteurs non nuls et non colinéaires entre eux de ce plan.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrSpacePointNamed } = getHydrated(identifiers);
+    const [P1, P2, P3, P4, P5] = arrSpacePointNamed;
+    const isIntersect = isLinePlaneIntersect([P1, P2], [P3, P4, P5]);
+    const isParallel = isLinePlaneParallel([P1, P2], [P3, P4, P5]);
+    const isCoplanar = isLinePlaneCoplanar([P1, P2], [P3, P4, P5]);
+    const isOrthogonal = isLinePlaneOrthogonal([P1, P2], [P3, P4, P5]);
+    //parallel
+    const strParallel = (() => {
+        //P1P2 \\cdot (P3P4 \\wedge P3P5) = 0
+        if (isParallel) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+\\overrightarrow{${P1.name}${P2.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}}) = 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $\\mathcal{P}$ sont parallèles.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+\\overrightarrow{${P1.name}${P2.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}}) \\neq 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $\\mathcal{P}$ ne sont pas parallèles.`;
+        }
+    })();
+    //coplanar
+    const strCoplanar = (() => {
+        //vecP3P1 \\cdot vecP3P4.vetorialProduct(vecP3P5) = 0 && vecP3P2 \\cdot vecP3P4.vetorialProduct(vecP3P5) = 0
+        if (isCoplanar) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P3.name}${P1.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) = 0
+$$
+
+et 
+
+$$
+(\\overrightarrow{${P3.name}${P2.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) = 0
+$$
+
+donc $(${P1.name}${P2.name})$ est incluse dans $\\mathcal{P}$.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+    
+soit
+
+$$
+(\\overrightarrow{${P3.name}${P1.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) \\neq 0
+$$
+
+soit 
+
+$$
+(\\overrightarrow{${P3.name}${P2.name}} \\cdot (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) \\neq 0
+$$
+
+donc $(${P1.name}${P2.name})$ n'est pas incluse dans $\\mathcal{P}$.`;
+        }
+    })();
+    //intersect
+    const strIntersect = (() => {
+        if (isIntersect) {
+            return `$(${P1.name}${P2.name})$ n'est ni parallèle à $\\mathcal{P}$ ni incluse dans $\\mathcal{P}$
+donc $(${P1.name}${P2.name})$ et $\\mathcal{P}$ ont un unique point d'intersection.`;
+        }
+        else {
+            if (isCoplanar) {
+                return `$(${P1.name}${P2.name})$ est incluse dans $\\mathcal{P}$
+      
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ont une infinité de points d'intersection.`;
+            }
+            else {
+                return `$(${P1.name}${P2.name})$ est parallèle $\\mathcal{P}$ et n'est pas incluse dans $\\mathcal{P}$
+      
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ n'ont pas de point d'intersection.`;
+            }
+        }
+    })();
+    //orthogonal
+    const strOrthogonal = (() => {
+        if (isOrthogonal) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\wedge (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) = \\overrightarrow{0}
+$$
+
+donc $(${P1.name}${P2.name})$ est orthogonale à $\\mathcal{P}$.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\wedge (\\overrightarrow{${P3.name}${P4.name}} \\wedge \\overrightarrow{${P3.name}${P5.name}})) \\neq \\overrightarrow{0}
+$$
+
+donc $(${P1.name}${P2.name})$ n'est pas orthogonale à $\\mathcal{P}$.`;
+        }
+    })();
+    return [strParallel, strCoplanar, strIntersect, strOrthogonal].join(`
+    
+`);
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrSpacePointNamed } = getHydrated(identifiers);
+    const [vecXCube, vecYCube, vecZCube] = arrCubeVec;
+    const prismSpacePoints = getPrismPoints(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSide = getAllPointMeshes(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const [P1, P2, P3, P4, P5] = arrSpacePointNamed;
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePointNamed.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${prismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 16)}")`,
+            `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)`,
+                ];
+            }),
+            //line
+            `L = Line(${P1.toMathString()}, ${P2.toMathString()})`,
+            `SetColor(L, "${greenMain}")`,
+            `SetLineThickness(L, 2)`,
+            //plane
+            `Pl = Plane(${P3.toMathString()}, ${P4.toMathString()}, ${P5.toMathString()})`,
+            `SetColor(Pl, "${greenMain}")`,
+            `SetLineThickness(Pl, 2)`,
+        ],
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.7, -1, -0.5],
+    });
+    return ggb.getOptions({
+        coords: getArrCoordsFrame(prismSpacePoints),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrSpacePointNamed } = getHydrated(identifiers);
+    const [vecXCube, vecYCube, vecZCube] = arrCubeVec;
+    const prismSpacePoints = getPrismPoints(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSide = getAllPointMeshes(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePointNamed.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${prismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 16)}")`,
+            `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)`,
+                ];
+            }),
+        ],
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.7, -1, -0.5],
+    });
+    return ggb.getOptions({
+        coords: getArrCoordsFrame(prismSpacePoints),
+    });
+};
+const getPropositions = (_n, { answer, ...identifiers }) => {
+    return createMyPropositions(identifiers);
+};
+const createRandomSpacePointAskedWrtBaseVecs = (arrFactorBaseWrtCube) => {
+    let spacePoint;
+    let isFound = false;
+    while (!isFound) {
+        const [typeX, typeY, typeZ] = arrFactorBaseWrtCube.map(() => random(["zero", "mid", "full"]));
+        isFound = !((typeX === "zero" && typeY === "zero" && typeZ === "zero") ||
+            (typeX === "mid" && typeY === "mid" && typeZ === "mid"));
+        if (isFound) {
+            const [x, y, z] = zip([typeX, typeY, typeZ], arrFactorBaseWrtCube).map(([type, factor]) => {
+                const factorPoint = factor === 0.5 ? 2 : 1;
+                return (factorPoint *
+                    (() => {
+                        switch (type) {
+                            case "zero":
+                                return 0;
+                            case "mid":
+                                return 0.5;
+                            case "full":
+                                return 1;
+                            default:
+                                throw new Error("Unsupported type: " + type);
+                        }
+                    })());
+            });
+            spacePoint = SpacePointConstructor.fromScalars([x, y, z]);
+            isFound = true;
+        }
+    }
+    return spacePoint;
+};
+const createArrRandomSpacePointWrtBaseVecs = (arrFactorBaseWrtCube, nb) => {
+    const arrSpacePoint = [];
+    const isSameSpacePoint = (spacePoint1, spacePoint2) => {
+        return zip([spacePoint1.x, spacePoint1.y, spacePoint1.z], [spacePoint2.x, spacePoint2.y, spacePoint2.z]).every(([node1, node2]) => NodeComparator.isEqualViaSub(node1, node2));
+    };
+    while (arrSpacePoint.length < nb) {
+        const spacePointCandidate = createRandomSpacePointAskedWrtBaseVecs(arrFactorBaseWrtCube);
+        const isFound = arrSpacePoint.every((spacePointExisting) => !isSameSpacePoint(spacePointCandidate, spacePointExisting));
+        if (isFound) {
+            const spacePointNew = spacePointCandidate;
+            arrSpacePoint.push(spacePointNew);
+        }
+    }
+    return zip(shuffle("ABCDE".split("")), arrSpacePoint).map(([name, spacePoint]) => {
+        spacePoint.name = name;
+        return spacePoint;
+    });
+};
+const createRandomNamedPointsWithLinePlaneRelativePosition = (arrFactorBaseWrtCube, isIntersectRequired, isParallelRequired, isOrthogonalRequired, isCoplanarRequired) => {
+    let [P1, P2, P3, P4, P5] = [];
+    function isPointsOk([P1, P2, P3, P4]) {
+        const isAlignedP3P4P5 = (() => {
+            const [vecP3P4, vecP3P5] = [
+                [P3, P4],
+                [P3, P5],
+            ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+            const vecProduct = vecP3P4.vetorialProduct(vecP3P5);
+            return [vecProduct.x, vecProduct.y, vecProduct.z].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+        })();
+        if (isAlignedP3P4P5) {
+            return false;
+        }
+        const isIntersectMeasured = isLinePlaneIntersect([P1, P2], [P3, P4, P5]);
+        const isParallelMeasured = isLinePlaneParallel([P1, P2], [P3, P4, P5]);
+        const isCoplanarMeasured = isLinePlaneCoplanar([P1, P2], [P3, P4, P5]);
+        const isOrthogonalMeasured = isLinePlaneOrthogonal([P1, P2], [P3, P4, P5]);
+        return zip([
+            isIntersectMeasured,
+            isParallelMeasured,
+            isOrthogonalMeasured,
+            isCoplanarMeasured,
+        ], [
+            isIntersectRequired,
+            isParallelRequired,
+            isOrthogonalRequired,
+            isCoplanarRequired,
+        ]).every(([isMeasured, isRequired]) => isMeasured === isRequired);
+    }
+    do {
+        [P1, P2, P3, P4, P5] = createArrRandomSpacePointWrtBaseVecs(arrFactorBaseWrtCube, 5);
+    } while (!isPointsOk([P1, P2, P3, P4, P5]));
+    return [P1, P2, P3, P4, P5];
+};
+const createRandomIdentifiers = () => {
+    const lengthSideCube = 5;
+    const [coordsVecX, coordsVecY, coordsVecZ] = [
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ];
+    const [vecXCube, vecYCube, vecZCube] = zip(["vecX", "vecY", "vecZ"], [coordsVecX, coordsVecY, coordsVecZ]).map(([name, arr]) => SpaceVectorConstructor.fromScalars(arr.map((v) => v * lengthSideCube), name));
+    const arrFactorBaseWrtCube = ["x", "y", "z"].map(() => random([0.5, 1]));
+    const [vecXBase, vecYBase, vecZBase] = zip(arrFactorBaseWrtCube, 
+    //right-handed or left-handed orientation
+    coinFlip()
+        ? [vecXCube, vecYCube, vecZCube]
+        : [vecYCube, vecXCube, vecZCube]).map(([factor, vec]) => vec.times(factor.toTree()));
+    const spacePointCubeOrigin = SpacePointConstructor.fromScalars([0, 0, 0], "O");
+    const arrCubeVecEndPoint = [vecXCube, vecYCube, vecZCube].map((vec) => vec.getEndPoint(spacePointCubeOrigin));
+    const arrBaseVecEndPoint = [vecXBase, vecYBase, vecZBase].map((vec) => vec.getEndPoint(spacePointCubeOrigin));
+    const [isIntersect, isParallel, isOrthogonal, isCoplanar] = random([
+        [true, false, false, false],
+        [true, false, true, false],
+        [false, true, false, false],
+        [false, true, false, true],
+    ]);
+    const arrSpacePointWithName = createRandomNamedPointsWithLinePlaneRelativePosition(arrFactorBaseWrtCube, isIntersect, isParallel, isOrthogonal, isCoplanar);
+    const identifiers = {
+        spacePointIdsCubeOrigin: spacePointCubeOrigin.toIdentifiers(),
+        spacePointIdsCubeVecsEndPoint: arrCubeVecEndPoint.map((spacePoint) => spacePoint.toIdentifiers()),
+        spacePointIdsBaseVecsEndPoint: arrBaseVecEndPoint.map((spacePoint) => spacePoint.toIdentifiers()),
+        spacePointIdsWrtBaseVecs: arrSpacePointWithName.map((spacePoint) => spacePoint.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getLinePlaneRelativePositionsFromCubeOuterPointsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const linePlaneRelativePositionsFromCubeOuterPoints = {
+    id: "linePlaneRelativePositionsFromCubeOuterPoints",
+    label: "Déterminer les positions relatives d'une droite et d'un plan formés par des sommets d'un cube",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLinePlaneRelativePositionsFromCubeOuterPointsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCM",
+    isQCM: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+type Identifiers = {
+    spacePointIdsCubeOrigin: SpacePointIdentifiers;
+    spacePointIdsCubeVecsEndPoint: SpacePointIdentifiers[];
+    spacePointIdsBaseVecsEndPoint: SpacePointIdentifiers[];
+    spacePointIdsAskedWrtBaseVecs: SpacePointIdentifiers;
+};
+export declare const spaceCoordinatesOfPointInCubeCoordSystem: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=spaceCoordinatesOfPointInCubeCoordSystem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spaceCoordinatesOfPointInCubeCoordSystem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesOfPointInCubeCoordSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AA8N3C,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,6BAA6B,EAAE,qBAAqB,CAAC;CACtD,CAAC;AAmgBF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAoB1E,CAAC"}