math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/spaceGeometry/collinearity/checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.js

@@ -0,0 +1,511 @@
+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 { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector, SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.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 { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.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";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const isAligned = ([K, L, M]) => {
+    const [vecKL, vecKM] = [
+        [K, L],
+        [K, M],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    return vecKL
+        .vetorialProduct(vecKM)
+        .equals(new SpaceVector("0", (0).toTree(), (0).toTree(), (0).toTree()));
+};
+const createSpaceVecNamed = (name, dictSpacePoints) => {
+    const [nameP1, nameP2] = name.split("");
+    const [P1, P2] = [nameP1, nameP2].map((name) => dictSpacePoints[name]);
+    return SpaceVectorConstructor.fromPoints(P1, P2);
+};
+const createSpaceVecFromVecFormula = (nodeVecFormula, dictSpacePoints) => {
+    if (isOperatorNode(nodeVecFormula)) {
+        switch (nodeVecFormula.id) {
+            case OperatorIds.add: {
+                const [vecLhs, vecRhs] = [
+                    nodeVecFormula.leftChild,
+                    nodeVecFormula.rightChild,
+                ].map((nodeVecFormulaChild) => createSpaceVecFromVecFormula(nodeVecFormulaChild, dictSpacePoints));
+                return vecLhs.add(vecRhs);
+            }
+            case OperatorIds.substract: {
+                const [vecLhs, vecRhs] = [
+                    nodeVecFormula.leftChild,
+                    nodeVecFormula.rightChild,
+                ].map((nodeVecFormulaChild) => createSpaceVecFromVecFormula(nodeVecFormulaChild, dictSpacePoints));
+                return vecLhs.add(vecRhs.times((-1).toTree()));
+            }
+            case OperatorIds.multiply: {
+                const nodeLhs = nodeVecFormula.leftChild;
+                const [vecRhs] = [nodeVecFormula.rightChild].map((nodeVecFormulaChild) => createSpaceVecFromVecFormula(nodeVecFormulaChild, dictSpacePoints));
+                return vecRhs.times(nodeLhs);
+            }
+            case OperatorIds.fraction: {
+                const nodeDen = nodeVecFormula.rightChild;
+                const [vecNum] = [nodeVecFormula.leftChild].map((nodeVecFormulaChild) => createSpaceVecFromVecFormula(nodeVecFormulaChild, dictSpacePoints));
+                return vecNum.times(frac(1, nodeDen));
+            }
+            default:
+                throw new Error("Unsupported nodeVecFormula.id: " + nodeVecFormula.id);
+        }
+    }
+    else if (isVariableNode(nodeVecFormula)) {
+        const name = nodeVecFormula.name
+            .replace("\\overrightarrow{", "")
+            .replace("}", ""); //flemme de faire une regexp pour ça
+        return createSpaceVecNamed(name, dictSpacePoints);
+    }
+    else {
+        throw new Error("Unsupported nodeVecFormula: " + nodeVecFormula.toTex());
+    }
+};
+const createSpacePointFromNodeVecEquation = (nodeVecEquation, arrSpacePointSrc) => {
+    const dictSpacePoints = arrSpacePointSrc.reduce((acc, spacePoint) => {
+        acc[spacePoint.name] = spacePoint;
+        return acc;
+    }, {});
+    dictSpacePoints["O"] = SpacePointConstructor.fromScalars([0, 0, 0], "O");
+    const nameLhs = nodeVecEquation.leftChild.name
+        .replace("\\overrightarrow{", "")
+        .replace("}", ""); //flemme de faire une regexp pour ça
+    const [nameFrom, nameTarget] = nameLhs.split("");
+    const vecOffset = SpaceVectorConstructor.fromPoints(dictSpacePoints["O"], dictSpacePoints[nameFrom]);
+    return vecOffset
+        .add(createSpaceVecFromVecFormula(nodeVecEquation.rightChild, dictSpacePoints))
+        .getEndPoint(dictSpacePoints["O"], nameTarget);
+};
+/**
+  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);
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIdsCubeOrigin, spacePointIdsCubeVecsEndPoint, spacePointIdsWrtBaseVecs, nodeIdsVecEquation, } = identifiers;
+    const spacePointCubeOrigin = SpacePointConstructor.fromIdentifiers(spacePointIdsCubeOrigin);
+    const [arrCubeVec] = [spacePointIdsCubeVecsEndPoint].map((arr) => arr.map((pointIds) => SpaceVectorConstructor.fromPoints(spacePointCubeOrigin, SpacePointConstructor.fromIdentifiers(pointIds))));
+    const arrSpacePointWrtBaseVecs = spacePointIdsWrtBaseVecs.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePointNamedCube = arrSpacePointWrtBaseVecs.map((spacePointWrtBaseVecs) => {
+        const spacePoint = getSpacePointForRelativeCoords(spacePointCubeOrigin, [
+            spacePointWrtBaseVecs.x,
+            spacePointWrtBaseVecs.y,
+            spacePointWrtBaseVecs.z,
+        ].map((node) => node.evaluate()), arrCubeVec);
+        spacePoint.name = spacePointWrtBaseVecs.name;
+        return spacePoint;
+    });
+    const arrNodeVecEquation = nodeIdsVecEquation.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [K, L, M] = arrNodeVecEquation.map((nodeVecEquation) => createSpacePointFromNodeVecEquation(nodeVecEquation, arrSpacePointNamedCube));
+    const isAlignedKLM = isAligned([K, L, M]);
+    const arrNodeVecEquationOriginToTarget = arrNodeVecEquation.map((nodeVecEquation) => {
+        const nameLhs = nodeVecEquation.leftChild.name
+            .replace("\\overrightarrow{", "")
+            .replace("}", ""); //flemme de faire une regexp pour ça
+        const [nameFrom, nameTarget] = nameLhs.split("");
+        if (nameFrom === "A") {
+            return nodeVecEquation;
+        }
+        else {
+            return new EqualNode(new VariableNode(`\\overrightarrow{A${nameTarget}}`), add(new VariableNode(`\\overrightarrow{A${nameFrom}}`), nodeVecEquation.rightChild));
+        }
+    });
+    const [nodeVecEquationOriginToK] = arrNodeVecEquationOriginToTarget;
+    const [nodeVecEquationKL, nodeVecEquationKM] = zip(["KL", "KM"], arrNodeVecEquationOriginToTarget.slice(1)).map(([nameVec, nodeVecEquationOriginToTarget]) => {
+        return new EqualNode(new VariableNode(`\\overrightarrow{${nameVec}}`), substract(nodeVecEquationOriginToTarget.rightChild, nodeVecEquationOriginToK.rightChild));
+    });
+    return {
+        spacePointCubeOrigin,
+        arrCubeVec,
+        arrSpacePointNamedCube,
+        arrNodeVecEquation,
+        arrSpacePointNamedAsked: [K, L, M],
+        isAlignedKLM,
+        arrNodeVecEquationOriginToTarget,
+        nodeVecEquationKL,
+        nodeVecEquationKM,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { arrNodeVecEquation } = getHydrated(identifiers);
+    return `Un cube $ABCDEFGH$ est affiché ci-dessous. On définit les points $K$, $L$ et $M$ par :
+ 
+${alignTex(arrNodeVecEquation.map((nodeVecEquation) => [nodeVecEquation.toTex()]))}
+  
+Les points $K$, $L$ et $M$ sont-ils alignés ?
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getAnswer = (identifiers) => {
+    const { isAlignedKLM } = getHydrated(identifiers);
+    return isAlignedKLM ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `$P$, $Q$ et $R$ sont alignés si et seulement si $\\overrightarrow{PQ}$ et $\\overrightarrow{PR}$ sont colinéaires.
+Pour montrer que $\\overrightarrow{PQ}$ et $\\overrightarrow{PR}$ sont colinéaires, on peut, entre autres : 
+- montrer par le calcul que $\\overrightarrow{PQ} \\wedge \\overrightarrow{PR} = \\overrightarrow{0}$
+- trouver un réel $k$ tel que $\\overrightarrow{PQ} = k \\overrightarrow{PR}$`;
+};
+const getCorrection = (identifiers) => {
+    const { isAlignedKLM, nodeVecEquationKL, nodeVecEquationKM, arrNodeVecEquationOriginToTarget, } = getHydrated(identifiers);
+    return `$K$, $L$ et $M$ sont alignés si et seulement si $\\overrightarrow{KL}$ et $\\overrightarrow{KM}$ sont colinéaires.
+
+On a :
+
+${alignTex(arrNodeVecEquationOriginToTarget.map((nodeVecEquation) => [
+        nodeVecEquation.toTex(),
+    ]))}
+
+Donc : 
+
+${alignTex([nodeVecEquationKL, nodeVecEquationKM].map((nodeVecEquation) => [
+        nodeVecEquation.toTex(),
+    ]))}
+
+${(() => {
+        if (isAlignedKLM) {
+            return `On a : 
+
+$$
+\\overrightarrow{KL} \\wedge \\overrightarrow{KM} = \\overrightarrow{0} 
+$$
+
+Donc les points $K$,$L$ et $M$ sont alignés.`;
+        }
+        else {
+            return `On a : 
+
+$$
+\\overrightarrow{KL} \\wedge \\overrightarrow{KM} \\neq \\overrightarrow{0} 
+$$
+
+Donc les points $K$,$L$ et $M$ ne sont pas alignés.`;
+        }
+    })()}
+  
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrSpacePointNamedCube, arrSpacePointNamedAsked, isAlignedKLM, } = 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 [K, L] = arrSpacePointNamedAsked;
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...[...arrSpacePointNamedCube].flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+            ...[...arrSpacePointNamedAsked].flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+                color: greenMain,
+            })),
+        ],
+        //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
+            ...(isAlignedKLM
+                ? [
+                    `Li = Line(${K.toMathString()}, ${L.toMathString()})`,
+                    `ShowLabel(Li, false)`,
+                    `SetColor(Li, "${greenMain}")`,
+                    `SetLineThickness(Li, 1)`,
+                ]
+                : []),
+        ],
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.7, -1, -0.45],
+    });
+    return ggb.getOptions({
+        coords: getArrCoordsFrame([
+            ...prismSpacePoints,
+            ...arrSpacePointNamedAsked,
+        ]),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrSpacePointNamedCube } = 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
+            ...arrSpacePointNamedCube.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.45],
+    });
+    return ggb.getOptions({
+        coords: getArrCoordsFrame(prismSpacePoints),
+    });
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomArrNodeVecEquationAndCorrespondingArrSpacePoint = (arrSpacePointSrc, isAlignedRequired) => {
+    function randomVectorStrFromPoints(arrSpacePoint) {
+        const [P1, P2] = shuffle(arrSpacePoint);
+        return `\\overrightarrow{${P1.name}${P2.name}}`;
+    }
+    const arrNameTarget = ["K", "L", "M"];
+    let [K, L, M] = [];
+    let arrNodeVecEquation = [];
+    let isDistinctPoints;
+    do {
+        arrNodeVecEquation = arrNameTarget.map((name) => {
+            const spacePointStart = random(arrSpacePointSrc);
+            const nbStepsForVecPath = 1;
+            const nodeVecEquation = new EqualNode(new VariableNode(`\\overrightarrow{${spacePointStart.name}${name}}`), [...Array(nbStepsForVecPath).keys()].reduce((acc, _i) => {
+                const nodeFactorVec1 = random([
+                    (-1).toTree(),
+                    (-2).toTree(),
+                    (1).toTree(),
+                    frac(1, 2),
+                    frac(3, 2),
+                    (2).toTree(),
+                ]);
+                const strVec1 = randomVectorStrFromPoints(arrSpacePointSrc);
+                const nodeVec1 = new VariableNode(strVec1);
+                const nodeVec1Scaled = multiply(nodeFactorVec1, nodeVec1);
+                return add(acc, nodeVec1Scaled).simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                });
+            }, (0).toTree()));
+            return nodeVecEquation;
+        });
+        [K, L, M] = arrNodeVecEquation.map((nodeVecEquation) => createSpacePointFromNodeVecEquation(nodeVecEquation, arrSpacePointSrc));
+        const nbDistinctPoints = [
+            ...new Set([K, L, M].map((spacePoint) => spacePoint.toCoords())),
+        ].length;
+        isDistinctPoints = nbDistinctPoints === 3;
+    } while (!isDistinctPoints || isAligned([K, L, M]) !== isAlignedRequired);
+    return [arrNodeVecEquation, [K, L, M]];
+};
+const createRandomIdentifiers = () => {
+    const lengthSideCube = 5;
+    const [coordsVecX, coordsVecY, coordsVecZ] = [
+        [1, 0, 0],
+        [0, 1, 0],
+        [0, 0, 1],
+    ];
+    const [vecXCube, vecYCube, vecZCube] = zip(coinFlip() ? ["vecX", "vecY", "vecZ"] : ["vecY", "vecX", "vecZ"], [coordsVecX, coordsVecY, coordsVecZ]).map(([name, arr]) => SpaceVectorConstructor.fromScalars(arr.map((v) => v * lengthSideCube), name));
+    const spacePointCubeOrigin = SpacePointConstructor.fromScalars([0, 0, 0], "O");
+    const arrCubeVecEndPoint = [vecXCube, vecYCube, vecZCube].map((vec) => vec.getEndPoint(spacePointCubeOrigin));
+    const arrCubePoints = zip("ABCDEFGH".split(""), [
+        [0, 0, 0],
+        [0, 1, 0],
+        [1, 1, 0],
+        [1, 0, 0],
+        [0, 0, 1],
+        [0, 1, 1],
+        [1, 1, 1],
+        [1, 0, 1],
+    ]).map(([name, [x, y, z]]) => new SpacePoint(name, x.toTree(), y.toTree(), z.toTree()));
+    const isAligned = coinFlip();
+    const [arrNodeVecEquation, _arrSpacePoint] = createRandomArrNodeVecEquationAndCorrespondingArrSpacePoint(arrCubePoints, isAligned);
+    const arrSpacePointWithName = [...arrCubePoints];
+    const identifiers = {
+        spacePointIdsCubeOrigin: spacePointCubeOrigin.toIdentifiers(),
+        spacePointIdsCubeVecsEndPoint: arrCubeVecEndPoint.map((spacePoint) => spacePoint.toIdentifiers()),
+        spacePointIdsWrtBaseVecs: arrSpacePointWithName.map((spacePoint) => spacePoint.toIdentifiers()),
+        nodeIdsVecEquation: arrNodeVecEquation.map((nodeVecEquation) => nodeVecEquation.toIdentifiers()),
+    };
+    return identifiers;
+};
+const getCheckAlignedSpacePointsFromVecPathsFromCubeOuterPointsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints = {
+    id: "checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints",
+    label: "Déterminer si $3$ points définis par des égalités vectorielles sont alignés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckAlignedSpacePointsFromVecPathsFromCubeOuterPointsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,3 @@
+export * from "./checkAlignedSpacePointsFromCoords.js";
+export * from "./checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/collinearity/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,6DAA6D,CAAC"}

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

@@ -0,0 +1,2 @@
+export * from "./checkAlignedSpacePointsFromCoords.js";
+export * from "./checkAlignedSpacePointsFromVecPathsFromCubeOuterPoints.js";

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

@@ -1,6 +1,11 @@
 export * from "./vectors/index.js";
 export * from "./basis/index.js";
+export * from "./planes/index.js";
 export * from "./sections/index.js";
 export * from "./sphere/index.js";
 export * from "./solids/index.js";
+export * from "./collinearity/index.js";
+export * from "./scalarProduct/index.js";
+export * from "./orthogonalProjection/index.js";
+export * from "./parametricLine/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,2BAA2B,CAAC"}

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

@@ -1,6 +1,10 @@
 export * from "./vectors/index.js";
 export * from "./basis/index.js";
-// export * from "./planes/index.js";
+export * from "./planes/index.js";
 export * from "./sections/index.js";
 export * from "./sphere/index.js";
 export * from "./solids/index.js";
+export * from "./collinearity/index.js";
+export * from "./scalarProduct/index.js";
+export * from "./orthogonalProjection/index.js";
+export * from "./parametricLine/index.js";

package/lib/exercises/math/spaceGeometry/orthogonalProjection/findOrthogonalProjectionOfPointOnPlane.d.ts

@@ -0,0 +1,22 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorIdentifiers } from "../../../../math/geometry/spaceVector.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type PlaneIds = {
+    spacePointIdsContained: SpacePointIdentifiers;
+    spaceVectorIdsNormal: SpaceVectorIdentifiers;
+    nodeIdsPlaneEquation: NodeIdentifiers;
+    typeDefinitionData: string;
+    texName: string;
+};
+type Identifiers = {
+    idsP: PlaneIds;
+    spacePointIdsA: SpacePointIdentifiers;
+    spacePointIdsProposed: SpacePointIdentifiers[];
+};
+type Options = {
+    typeDataForPlane: string;
+};
+export declare const findOrthogonalProjectionOfPointOnPlane: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=findOrthogonalProjectionOfPointOnPlane.d.ts.map

package/lib/exercises/math/spaceGeometry/orthogonalProjection/findOrthogonalProjectionOfPointOnPlane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findOrthogonalProjectionOfPointOnPlane.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/orthogonalProjection/findOrthogonalProjectionOfPointOnPlane.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAS5C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA0G7C,KAAK,QAAQ,GAAG;IACd,sBAAsB,EAAE,qBAAqB,CAAC;IAC9C,oBAAoB,EAAE,sBAAsB,CAAC;IAC7C,oBAAoB,EAAE,eAAe,CAAC;IACtC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,QAAQ,CAAC;IACf,cAAc,EAAE,qBAAqB,CAAC;IACtC,qBAAqB,EAAE,qBAAqB,EAAE,CAAC;CAChD,CAAC;AA0ZF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAqBF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAqBR,CAAC"}