math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,753 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, colorWithOpacity, greenLight, red, } 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 { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.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 { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const createRandomArrRotationMatrix = () => {
+    const matX = (() => {
+        // const gamma = randfloat(0, 6.28, 2);
+        const gamma = random([0, 1.57, 3.14, 4.71]);
+        const c = Math.cos(gamma);
+        const s = Math.sin(gamma);
+        return [
+            [1, 0, 0],
+            [0, c, -s],
+            [0, s, c],
+        ];
+    })();
+    const matY = (() => {
+        // const beta = randfloat(0, 6.28, 2);
+        const beta = random([0, 1.57, 3.14]); //rotating more leads to bugs
+        const c = Math.cos(beta);
+        const s = Math.sin(beta);
+        return [
+            [c, 0, s],
+            [0, 1, 0],
+            [-s, 0, c],
+        ];
+    })();
+    const matZ = (() => {
+        // const alpha = randfloat(0, 6.28, 2);
+        const alpha = random([0, 1.57, 3.14]); //rotating more leads to bugs
+        const c = Math.cos(alpha);
+        const s = Math.sin(alpha);
+        return [
+            [c, -s, 0],
+            [s, c, 0],
+            [0, 0, 1],
+        ];
+    })();
+    return [matX, matY, matZ];
+};
+const applyMatrixToVec = (mat, vec) => {
+    return [...Array(vec.length).keys()].map((i) => vec.reduce((acc, _, j) => acc + mat[i][j] * vec[j], 0));
+};
+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, spacePointIdsBaseVecsEndPoint, spacePointIdsWrtBaseVecs, nodeIdsEquationForVecs, } = 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 = zip("FABCD".split(""), arrSpacePointWrtBaseVecs).map(([name, spacePointWrtBaseVecs]) => {
+        const spacePoint = getSpacePointForRelativeCoords(spacePointCubeOrigin, [
+            spacePointWrtBaseVecs.x,
+            spacePointWrtBaseVecs.y,
+            spacePointWrtBaseVecs.z,
+        ].map((node) => node.evaluate()), arrBaseVec);
+        spacePoint.name = name;
+        return spacePoint;
+    });
+    const nodeEquationForVecs = NodeConstructor.fromIdentifiers(nodeIdsEquationForVecs);
+    const [spacePointAskedWrtBaseVecs, arrVecWrtBaseVecs] = (() => {
+        if (isMultiplyNode(nodeEquationForVecs.rightChild)) {
+            // FM = factor1 * vec1
+            const [F, A, B] = arrSpacePointWrtBaseVecs;
+            const [vecF, vecA, vecB] = [F, A, B].map((spacePointWrtBaseVecs) => SpaceVectorConstructor.fromPoints(SpacePointConstructor.fromScalars([0, 0, 0]), spacePointWrtBaseVecs));
+            const nodeFactor1 = nodeEquationForVecs.rightChild
+                .leftChild;
+            const strVec1 = nodeEquationForVecs.rightChild
+                .rightChild.name;
+            const vec1WrtBaseVecs = (() => {
+                switch (strVec1) {
+                    case "\\overrightarrow{AB}": {
+                        const vecRaw = vecB.add(vecA.times((-1).toTree()));
+                        return new SpaceVector("AB", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    case "\\overrightarrow{BA}": {
+                        const vecRaw = vecA.add(vecB.times((-1).toTree()));
+                        return new SpaceVector("BA", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    default:
+                        throw new Error("Unsupported strVec1: " + strVec1);
+                }
+            })();
+            const vecM = vecF.add(vec1WrtBaseVecs.times(nodeFactor1));
+            const [nodeX, nodeY, nodeZ] = [vecM.x, vecM.y, vecM.z];
+            const spacePointAsked = new SpacePoint("M", nodeX, nodeY, nodeZ);
+            return [spacePointAsked, [vecF, vec1WrtBaseVecs]];
+        }
+        else {
+            //FM = factor1 * vec1 + factor2 * vec2
+            const [F, A, B, C, D] = arrSpacePointWrtBaseVecs;
+            const [vecF, vecA, vecB, vecC, vecD] = [F, A, B, C, D].map((spacePointWrtBaseVecs) => SpaceVectorConstructor.fromPoints(SpacePointConstructor.fromScalars([0, 0, 0]), spacePointWrtBaseVecs));
+            const nodeFactor1 = nodeEquationForVecs.rightChild.leftChild.leftChild;
+            const nodeFactor2 = nodeEquationForVecs.rightChild.rightChild.leftChild;
+            const strVec1 = nodeEquationForVecs.rightChild.leftChild
+                .rightChild.name;
+            const strVec2 = nodeEquationForVecs.rightChild.rightChild
+                .rightChild.name;
+            const vec1WrtBaseVecs = (() => {
+                switch (strVec1) {
+                    case "\\overrightarrow{AB}": {
+                        const vecRaw = vecB.add(vecA.times((-1).toTree()));
+                        return new SpaceVector("AB", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    case "\\overrightarrow{BA}": {
+                        const vecRaw = vecA.add(vecB.times((-1).toTree()));
+                        return new SpaceVector("BA", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    default:
+                        throw new Error("Unsupported strVec1: " + strVec1);
+                }
+            })();
+            const vec2WrtBaseVecs = (() => {
+                switch (strVec2) {
+                    case "\\overrightarrow{CD}": {
+                        const vecRaw = vecD.add(vecC.times((-1).toTree()));
+                        return new SpaceVector("CD", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    case "\\overrightarrow{DC}": {
+                        const vecRaw = vecC.add(vecD.times((-1).toTree()));
+                        return new SpaceVector("DC", vecRaw.x, vecRaw.y, vecRaw.z);
+                    }
+                    default:
+                        throw new Error("Unsupported strVec2: " + strVec2);
+                }
+            })();
+            const vecM = vecF.add(vec1WrtBaseVecs
+                .times(nodeFactor1)
+                .add(vec2WrtBaseVecs.times(nodeFactor2)));
+            const [nodeX, nodeY, nodeZ] = [vecM.x, vecM.y, vecM.z];
+            const spacePointAsked = new SpacePoint("M", nodeX, nodeY, nodeZ);
+            return [spacePointAsked, [vecF, vec1WrtBaseVecs, vec2WrtBaseVecs]];
+        }
+    })();
+    return {
+        spacePointCubeOrigin,
+        arrCubeVec,
+        arrBaseVec,
+        arrSpacePointNamed,
+        arrVecWrtBaseVecs,
+        spacePointAskedWrtBaseVecs,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsEquationForVecs } = identifiers;
+    const nodeEquationForVecs = NodeConstructor.fromIdentifiers(nodeIdsEquationForVecs);
+    return `Déterminer les coordonnées du point $M$ 
+dans le repère $(O;\\overrightarrow{i};\\overrightarrow{j};\\overrightarrow{k})$ sachant que :
+
+$$
+${nodeEquationForVecs.toTex()}
+$$
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getAnswer = (identifiers) => {
+    const { spacePointAskedWrtBaseVecs } = getHydrated(identifiers);
+    return spacePointAskedWrtBaseVecs.toCoords();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsEquationForVecs } = identifiers;
+    const nodeEquationForVecs = NodeConstructor.fromIdentifiers(nodeIdsEquationForVecs);
+    return `Le point $M$ est l'image du point $F$ par la translation de vecteur $${nodeEquationForVecs.rightChild.toTex()}$.
+Tu as deux possibilités : 
+- soit tu arrives à visualiser mentalement l'emplacement du point $M$ sur la figure et tu détermines ses coordonnées
+- soit tu détermines les coordonnées de $F$ et celles du vecteur $${nodeEquationForVecs.rightChild.toTex()}$ puis tu les additionne.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsEquationForVecs } = identifiers;
+    const nodeEquationForVecs = NodeConstructor.fromIdentifiers(nodeIdsEquationForVecs);
+    if (isMultiplyNode(nodeEquationForVecs.rightChild)) {
+        const { arrVecWrtBaseVecs } = getHydrated(identifiers);
+        const [vecF, vec1] = arrVecWrtBaseVecs;
+        return `Pour trouver les coordonnées de $M$, on applique une translation de vecteur $${nodeEquationForVecs.rightChild.toTex()}$ au point $F$.
+
+En effet, la relation de Chasles donne $\\overrightarrow{FM} = \\overrightarrow{FO} + \\overrightarrow{OM}$.
+
+D'où :
+
+$$
+\\overrightarrow{OM} = \\overrightarrow{OF} + (${nodeEquationForVecs.rightChild.toTex()})
+$$
+
+Or :
+
+$$
+\\overrightarrow{OF} = ${vecF.toCoordsTex()}
+$$
+
+et 
+
+$$
+${vec1.toTex()} = ${vec1.toCoordsTex()}
+$$
+
+Donc :
+
+${alignTex([
+            [
+                "\\overrightarrow{OM}",
+                "=",
+                `\\overrightarrow{OF} + (${nodeEquationForVecs.rightChild.toTex()})`,
+            ],
+            [
+                "\\overrightarrow{OM}",
+                "=",
+                `${vecF.toCoordsTex()} + (${nodeBySubstitutingVar(nodeEquationForVecs.rightChild, new VariableNode(vec1.toCoordsTex()), //forgive me father
+                new VariableNode(vec1.toTex())).toTex()})`,
+            ],
+            ["", "=", getAnswer(identifiers)],
+        ])}
+
+`;
+    }
+    else {
+        const { arrVecWrtBaseVecs } = getHydrated(identifiers);
+        const [vecF, vec1, vec2] = arrVecWrtBaseVecs;
+        return `Pour trouver les coordonnées de $M$, on applique une translation de vecteur $${nodeEquationForVecs.rightChild.toTex()}$ au point $F$.
+
+En effet, la relation de Chasles donne $\\overrightarrow{FM} = \\overrightarrow{FO} + \\overrightarrow{OM}$.
+
+D'où :
+
+$$
+\\overrightarrow{OM} = \\overrightarrow{OF} + (${nodeEquationForVecs.rightChild.toTex()})
+$$
+
+Or :
+
+$$
+\\overrightarrow{OF} = ${vecF.toCoordsTex()}
+$$
+
+$$
+${vec1.toTex()} = ${vec1.toCoordsTex()}
+$$
+
+et
+
+$$
+${vec2.toTex()} = ${vec2.toCoordsTex()}
+$$
+
+Donc :
+
+${alignTex([
+            [
+                "\\overrightarrow{OM}",
+                "=",
+                `\\overrightarrow{OF} + (${nodeEquationForVecs.rightChild.toTex()})`,
+            ],
+            [
+                "\\overrightarrow{OM}",
+                "=",
+                `${vecF.toCoordsTex()} + (${nodeBySubstitutingVar(nodeBySubstitutingVar(nodeEquationForVecs.rightChild, new VariableNode(vec1.toCoordsTex()), new VariableNode(vec1.toTex())), new VariableNode(vec2.toCoordsTex()), //forgive me father 2
+                new VariableNode(vec2.toTex())).toTex()})`,
+            ],
+            ["", "=", getAnswer(identifiers)],
+        ])}
+
+`;
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrBaseVec, arrSpacePointNamed, spacePointAskedWrtBaseVecs, } = getHydrated(identifiers);
+    const spacePointAsked = getSpacePointForRelativeCoords(spacePointCubeOrigin, [
+        spacePointAskedWrtBaseVecs.x,
+        spacePointAskedWrtBaseVecs.y,
+        spacePointAskedWrtBaseVecs.z,
+    ].map((node) => node.evaluate()), arrBaseVec);
+    spacePointAsked.name = "M";
+    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
+            ...[spacePointCubeOrigin, ...arrSpacePointNamed, spacePointAsked].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)`,
+                ];
+            }),
+            //vec
+            ...arrBaseVec.flatMap((vec, i) => [
+                `v${i} = Vector(Point({${vec.x.toMathString()},${vec.y.toMathString()},${vec.z.toMathString()}}))`,
+                `SetColor(v${i}, ${(() => {
+                    switch (i) {
+                        case 0:
+                            return `"${red}"`;
+                        case 1:
+                            return `"${greenLight}"`;
+                        case 2:
+                            return `"${blueMain}"`;
+                        default:
+                            return "#000000";
+                    }
+                })()})`,
+                `SetCaption(v${i}, ${(() => {
+                    switch (i) {
+                        case 0:
+                            return `"$\\overrightarrow{i}$"`;
+                        case 1:
+                            return `"$\\overrightarrow{j}$"`;
+                        case 2:
+                            return `"$\\overrightarrow{k}$"`;
+                        default:
+                            return "";
+                    }
+                })()})`,
+                `ShowLabel(v${i}, true)`,
+            ]),
+        ],
+    ];
+    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, arrBaseVec, 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
+            ...[spacePointCubeOrigin, ...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)`,
+                ];
+            }),
+            //vec
+            ...arrBaseVec.flatMap((vec, i) => [
+                `v${i} = Vector(Point({${vec.x.toMathString()},${vec.y.toMathString()},${vec.z.toMathString()}}))`,
+                `SetColor(v${i}, ${(() => {
+                    switch (i) {
+                        case 0:
+                            return `"${red}"`;
+                        case 1:
+                            return `"${greenLight}"`;
+                        case 2:
+                            return `"${blueMain}"`;
+                        default:
+                            return "#000000";
+                    }
+                })()})`,
+                `SetCaption(v${i}, ${(() => {
+                    switch (i) {
+                        case 0:
+                            return `"$\\overrightarrow{i}$"`;
+                        case 1:
+                            return `"$\\overrightarrow{j}$"`;
+                        case 2:
+                            return `"$\\overrightarrow{k}$"`;
+                        default:
+                            return "";
+                    }
+                })()})`,
+                `ShowLabel(v${i}, true)`,
+            ]),
+        ],
+    ];
+    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 }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const nbStepsForVecPath = parseInt(opts.nbStepsForVecPath);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { spacePointAskedWrtBaseVecs } = getHydrated(identifiers);
+    const arrNodeAnswer = [
+        spacePointAskedWrtBaseVecs.x,
+        spacePointAskedWrtBaseVecs.y,
+        spacePointAskedWrtBaseVecs.z,
+    ];
+    permute(arrNodeAnswer).forEach((arrNodeAnswerWrong) => {
+        const [nodeX, nodeY, nodeZ] = arrNodeAnswerWrong;
+        const spacePointWrong = new SpacePoint("MWrong", nodeX, nodeY, nodeZ);
+        tryToAddWrongProp(propositions, spacePointWrong.toCoords());
+    });
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(nbStepsForVecPath);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { spacePointAskedWrtBaseVecs } = getHydrated(identifiers);
+    const arrNodeAnswer = [
+        spacePointAskedWrtBaseVecs.x,
+        spacePointAskedWrtBaseVecs.y,
+        spacePointAskedWrtBaseVecs.z,
+    ];
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const arrNodeAns = (() => {
+            const arrKey = [...Array(3).keys()]
+                .map((i) => i + 1)
+                .map((v) => `str${v}`);
+            const strRegex = `^\\\\left\\(${arrKey
+                .map((strKey) => `(?<${strKey}>.*(?!;$))`)
+                .join(";")}\\\\right\\)$`;
+            const regex = new RegExp(strRegex);
+            const ansParts = matchGroups(regex, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const arrNode = Object.entries(ansParts).map(([_key, str]) => parseAlgebraic(str));
+            return arrNode;
+        })();
+        return zip(arrNodeAns, arrNodeAnswer).every(([nodeAns, nodeAnswer]) => NodeComparator.isEqualViaSub(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomSpacePointAskedWrtBaseVecs = (arrFactorBaseWrtCube) => {
+    let spacePoint;
+    let isFound = false;
+    while (!isFound) {
+        const [typeX, typeY, typeZ] = arrFactorBaseWrtCube.map(() => probaLawFlip([
+            ["zero", 0.2],
+            ["mid", 0.4],
+            ["full", 0.4],
+        ]));
+        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("FABCD".split(""), arrSpacePoint).map(([name, spacePoint]) => {
+        spacePoint.name = name;
+        return spacePoint;
+    });
+};
+const createRandomIdentifiers = (nbStepsForVecPath) => {
+    const lengthSideCube = 5;
+    const [coordsVecX, coordsVecY, coordsVecZ] = createRandomArrRotationMatrix().reduce((acc, mat) => acc.map((coordsVec) => applyMatrixToVec(mat, coordsVec), [
+        [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 arrSpacePointWithName = createArrRandomSpacePointWrtBaseVecs(arrFactorBaseWrtCube, 1 + 2 * nbStepsForVecPath);
+    const nodeEquationForVecs = new EqualNode(new VariableNode("\\overrightarrow{FM}"), (() => {
+        switch (nbStepsForVecPath) {
+            case 1: {
+                const nodeFactorVec1 = random([
+                    (-1).toTree(),
+                    (-2).toTree(),
+                    (1).toTree(),
+                    frac(1, 2),
+                    frac(3, 2),
+                    (2).toTree(),
+                ]);
+                const strVec1 = `\\overrightarrow{${random(["AB", "BA"])}}`;
+                const nodeVec1 = new VariableNode(strVec1);
+                return multiply(nodeFactorVec1, nodeVec1);
+            }
+            case 2: {
+                const nodeFactorVec1 = random([
+                    (-1).toTree(),
+                    (-2).toTree(),
+                    (1).toTree(),
+                    frac(1, 2),
+                    frac(3, 2),
+                    (2).toTree(),
+                ]);
+                const strVec1 = `\\overrightarrow{${random(["AB", "BA"])}}`;
+                const nodeVec1 = new VariableNode(strVec1);
+                const nodeFactorVec2 = random([
+                    (-1).toTree(),
+                    (1).toTree(),
+                    (2).toTree(),
+                ]);
+                const strVec2 = `\\overrightarrow{${random(["CD", "DC"])}}`;
+                const nodeVec2 = new VariableNode(strVec2);
+                return add(multiply(nodeFactorVec1, nodeVec1), multiply(nodeFactorVec2, nodeVec2));
+            }
+            default:
+                throw new Error("Unsupported nbStepsForVecPath: " + nbStepsForVecPath);
+        }
+    })());
+    const identifiers = {
+        spacePointIdsCubeOrigin: spacePointCubeOrigin.toIdentifiers(),
+        spacePointIdsCubeVecsEndPoint: arrCubeVecEndPoint.map((point) => point.toIdentifiers()),
+        spacePointIdsBaseVecsEndPoint: arrBaseVecEndPoint.map((point) => point.toIdentifiers()),
+        spacePointIdsWrtBaseVecs: arrSpacePointWithName.map((point) => point.toIdentifiers()),
+        nodeIdsEquationForVecs: nodeEquationForVecs.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getSpaceCoordinatesOfPointInCubeCoordSystemFromVecPathQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const nbStepsForVecPath = parseInt(opts.nbStepsForVecPath);
+    const identifiers = createRandomIdentifiers(nbStepsForVecPath);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    nbStepsForVecPath: "1",
+};
+const options = [
+    {
+        id: "nbStepsForVecPath",
+        label: "Nombre d'étape pour le chemin vectoriel",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["1", "2"],
+        defaultValue: optsDefault.nbStepsForVecPath,
+    },
+];
+export const spaceCoordinatesOfPointInCubeCoordSystemFromVecPath = {
+    id: "spaceCoordinatesOfPointInCubeCoordSystemFromVecPath",
+    label: "À partir d'un cube avec les milieux des arêtes, déterminer les coordonnées d'un vecteur formé par deux points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSpaceCoordinatesOfPointInCubeCoordSystemFromVecPathQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};