math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,576 @@
+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 isLineLineParallel = ([P1, P2], [P3, P4]) => {
+    //(P1P2 \\wedge P3P4) = vec0
+    const [vecP1P2, vecP3P4] = [
+        [P1, P2],
+        [P3, P4],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    const vecProductP1P2P3P4 = vecP1P2.vetorialProduct(vecP3P4);
+    return [
+        vecProductP1P2P3P4.x,
+        vecProductP1P2P3P4.y,
+        vecProductP1P2P3P4.z,
+    ].every((node) => NodeComparator.isEqualViaSub(node, (0).toTree()));
+};
+const isLineLineCoplanar = ([P1, P2], [P3, P4]) => {
+    //(P1P3) \\cdot (P1P2 \\wedge P3P4) = 0
+    const [vecP1P3, vecP1P2, vecP3P4] = [
+        [P1, P3],
+        [P1, P2],
+        [P3, P4],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    return NodeComparator.isEqualViaSub(vecP1P3.scalarProduct(vecP1P2.vetorialProduct(vecP3P4)), (0).toTree());
+};
+const isLineLineIntersect = ([P1, P2], [P3, P4]) => {
+    return (isLineLineCoplanar([P1, P2], [P3, P4]) &&
+        !isLineLineParallel([P1, P2], [P3, P4]));
+};
+const isLineLineOrthogonal = ([P1, P2], [P3, P4]) => {
+    //(P1P2 \\cdot P3P4) = 0
+    const [vecP1P2, vecP3P4] = [
+        [P1, P2],
+        [P3, P4],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    const nodeScalarProductP1P2P3P4 = vecP1P2.scalarProduct(vecP3P4);
+    return NodeComparator.isEqualViaSub(nodeScalarProductP1P2P3P4, (0).toTree());
+};
+const createMyPropositions = (identifiers) => {
+    const { arrSpacePointNamed } = getHydrated(identifiers);
+    const [P1, P2, P3, P4] = arrSpacePointNamed;
+    const propositions = [];
+    const isIntersect = isLineLineIntersect([P1, P2], [P3, P4]);
+    const isParallel = isLineLineParallel([P1, P2], [P3, P4]);
+    const isCoplanar = isIntersect || isParallel;
+    const isOrthogonal = isLineLineOrthogonal([P1, P2], [P3, P4]);
+    //lines intersect
+    {
+        const str = `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ont un point d'intersection.`;
+        if (isIntersect) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //lines are parallel
+    {
+        const str = `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont parallèles.`;
+        if (isParallel) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //lines are orthogonal
+    {
+        const str = `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont orthogonales.`;
+        if (isOrthogonal) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    }
+    //lines are coplanar / non-coplanar
+    {
+        if (isCoplanar && coinFlip()) {
+            const str = `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont coplanaires.`;
+            if (isCoplanar) {
+                addValidProp(propositions, str, "raw");
+            }
+            else {
+                tryToAddWrongProp(propositions, str, "raw");
+            }
+        }
+        else {
+            const str = `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont non coplanaires.`;
+            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] = arrSpacePointNamed;
+    return `Donner la position relative des droites $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$.
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getHint = () => {
+    return `Deux droites coplanaires sont soit sécantes soit parallèles.
+  
+Deux droites orthogonales ne sont pas forcément coplanaires car ce sont simplement leurs vecteurs directeurs qui sont orthogonaux.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrSpacePointNamed } = getHydrated(identifiers);
+    const [P1, P2, P3, P4] = arrSpacePointNamed;
+    const isIntersect = isLineLineIntersect([P1, P2], [P3, P4]);
+    const isParallel = isLineLineParallel([P1, P2], [P3, P4]);
+    const isCoplanar = isIntersect || isParallel;
+    const isOrthogonal = isLineLineOrthogonal([P1, P2], [P3, P4]);
+    //lines are coplanar
+    const strCoplanar = (() => {
+        //(P1P3) \\cdot (P1P2 \\wedge P3P4) = 0
+        if (isCoplanar) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+\\overrightarrow{${P1.name}${P3.name}} \\cdot (\\overrightarrow{${P1.name}${P2.name}} \\wedge \\overrightarrow{${P3.name}${P4.name}}) = 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont coplanaires.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+\\overrightarrow{${P1.name}${P3.name}} \\cdot (\\overrightarrow{${P1.name}${P2.name}} \\wedge \\overrightarrow{${P3.name}${P4.name}}) \\neq 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ne sont pas coplanaires.`;
+        }
+    })();
+    //lines are parallel
+    const strParallel = (() => {
+        if (isParallel) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\wedge \\overrightarrow{${P3.name}${P4.name}}) = \\overrightarrow{0}
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont parallèles.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\wedge \\overrightarrow{${P3.name}${P4.name}}) \\neq \\overrightarrow{0}
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ne sont pas parallèles.`;
+        }
+    })();
+    //lines intersect
+    const strIntersect = (() => {
+        if (isIntersect) {
+            return `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont coplanaires mais ne sont pas parallèles,
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ont un point d'intersection.`;
+        }
+        else {
+            if (isCoplanar) {
+                return `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont parallèles
+      
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ n'ont pas de point d'intersection.`;
+            }
+            else {
+                return `$(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont ne pas coplanaires
+      
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ n'ont pas de point d'intersection.`;
+            }
+        }
+    })();
+    const strOrthogonal = (() => {
+        if (isOrthogonal) {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\cdot \\overrightarrow{${P3.name}${P4.name}}) = 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ sont orthogonales.`;
+        }
+        else {
+            return `Si l'on fait le calcul, on remarque que: 
+
+$$
+(\\overrightarrow{${P1.name}${P2.name}} \\cdot \\overrightarrow{${P3.name}${P4.name}}) \\neq 0
+$$
+
+donc $(${P1.name}${P2.name})$ et $(${P3.name}${P4.name})$ ne sont pas orthogonales.`;
+        }
+    })();
+    return [strCoplanar, strParallel, 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] = 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)`,
+                ];
+            }),
+            //lines
+            ...[
+                [P1, P2],
+                [P3, P4],
+            ].flatMap(([spacePointStart, spacePointEnd], i) => {
+                return [
+                    `L_${i} = Line(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+                    `SetColor(L_${i}, "${greenMain}")`,
+                    `SetLineThickness(L_${i}, 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("ABCD".split("")), arrSpacePoint).map(([name, spacePoint]) => {
+        spacePoint.name = name;
+        return spacePoint;
+    });
+};
+const createRandomNamedPointsWithLineLineRelativePosition = (arrFactorBaseWrtCube, isIntersectRequired, isParallelRequired, isOrthogonalRequired, isCoplanarRequired) => {
+    let [P1, P2, P3, P4] = [];
+    function isPointsOk([P1, P2, P3, P4]) {
+        const isIntersectMeasured = isLineLineIntersect([P1, P2], [P3, P4]);
+        const isParallelMeasured = isLineLineParallel([P1, P2], [P3, P4]);
+        const isCoplanarMeasured = isIntersectMeasured || isParallelMeasured;
+        const isOrthogonalMeasured = isLineLineOrthogonal([P1, P2], [P3, P4]);
+        return zip([
+            isIntersectMeasured,
+            isParallelMeasured,
+            isOrthogonalMeasured,
+            isCoplanarMeasured,
+        ], [
+            isIntersectRequired,
+            isParallelRequired,
+            isOrthogonalRequired,
+            isCoplanarRequired,
+        ]).every(([isMeasured, isRequired]) => isMeasured === isRequired);
+    }
+    do {
+        [P1, P2, P3, P4] = createArrRandomSpacePointWrtBaseVecs(arrFactorBaseWrtCube, 4);
+    } while (!isPointsOk([P1, P2, P3, P4]));
+    return [P1, P2, P3, P4];
+};
+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, true],
+        [true, false, true, true],
+        [false, true, false, true],
+        [false, false, true, false],
+        [false, false, false, false],
+    ]);
+    const arrSpacePointWithName = createRandomNamedPointsWithLineLineRelativePosition(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 getLineLineRelativePositionsFromCubeOuterPointsQuestion = () => {
+    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 lineLineRelativePositionsFromCubeOuterPoints = {
+    id: "lineLineRelativePositionsFromCubeOuterPoints",
+    label: "Déterminer les positions relatives de deux droites formées par des sommets d'un cube",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLineLineRelativePositionsFromCubeOuterPointsQuestion(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/linePlaneRelativePositionsFromCubeOuterPoints.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[];
+    spacePointIdsWrtBaseVecs: SpacePointIdentifiers[];
+};
+export declare const linePlaneRelativePositionsFromCubeOuterPoints: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=linePlaneRelativePositionsFromCubeOuterPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linePlaneRelativePositionsFromCubeOuterPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/linePlaneRelativePositionsFromCubeOuterPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAuT3C,KAAK,WAAW,GAAG;IACjB,uBAAuB,EAAE,qBAAqB,CAAC;IAC/C,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,6BAA6B,EAAE,qBAAqB,EAAE,CAAC;IACvD,wBAAwB,EAAE,qBAAqB,EAAE,CAAC;CACnD,CAAC;AAkjBF,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAsB7E,CAAC"}