math-exercises 3.0.199 → 3.0.201

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"spaceCoordinatesOfVectorInCubeCoordSystem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceCoordinatesOfVectorInCubeCoordSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AA+N3C,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;IACrD,2BAA2B,EAAE,qBAAqB,CAAC;CACpD,CAAC;AA8kBF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAqBzE,CAAC"}

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

@@ -0,0 +1,546 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, colorWithOpacity, greenLight, orange, red, } 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 { substract } from "../../../../tree/nodes/operators/substractNode.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";
+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, spacePointIdsStartWrtBaseVecs, spacePointIdsEndWrtBaseVecs, } = identifiers;
+    const [spacePointCubeOrigin, spacePointStartWrtBaseVecs, spacePointEndWrtBaseVecs,] = [
+        spacePointIdsCubeOrigin,
+        spacePointIdsStartWrtBaseVecs,
+        spacePointIdsEndWrtBaseVecs,
+    ].map((pointIds) => SpacePointConstructor.fromIdentifiers(pointIds));
+    const [arrCubeVec, arrBaseVec] = [
+        spacePointIdsCubeVecsEndPoint,
+        spacePointIdsBaseVecsEndPoint,
+    ].map((arr) => arr.map((pointIds) => SpaceVectorConstructor.fromPoints(spacePointCubeOrigin, SpacePointConstructor.fromIdentifiers(pointIds))));
+    const spacePointStart = getSpacePointForRelativeCoords(spacePointCubeOrigin, [
+        spacePointStartWrtBaseVecs.x,
+        spacePointStartWrtBaseVecs.y,
+        spacePointStartWrtBaseVecs.z,
+    ].map((node) => node.evaluate()), arrBaseVec);
+    const arrConstructionOfSpacePointEnd = zip([
+        substract(spacePointEndWrtBaseVecs.x, spacePointStartWrtBaseVecs.x),
+        substract(spacePointEndWrtBaseVecs.y, spacePointStartWrtBaseVecs.y),
+        substract(spacePointEndWrtBaseVecs.z, spacePointStartWrtBaseVecs.z),
+    ], arrBaseVec).reduce((acc, [nodeFactor, vec]) => {
+        const [spacePointLatest] = acc.slice(-1);
+        const vecScaled = vec.times(nodeFactor);
+        const spacePoint = vecScaled.getEndPoint(spacePointLatest);
+        return [...acc, spacePoint];
+    }, [spacePointStart]);
+    const arrConstructionVec = zip(arrConstructionOfSpacePointEnd.slice(0, -1), arrConstructionOfSpacePointEnd.slice(1)).map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd));
+    return {
+        spacePointCubeOrigin,
+        arrCubeVec,
+        arrBaseVec,
+        spacePointStart,
+        arrConstructionOfSpacePointEnd,
+        arrConstructionVec,
+    };
+};
+const getSpaceVectorABWrtBaseVecs = (identifiers) => {
+    const { spacePointIdsStartWrtBaseVecs, spacePointIdsEndWrtBaseVecs } = identifiers;
+    const [spacePointStartWrtBaseVecs, spacePointEndWrtBaseVecs] = [
+        spacePointIdsStartWrtBaseVecs,
+        spacePointIdsEndWrtBaseVecs,
+    ].map((pointIds) => SpacePointConstructor.fromIdentifiers(pointIds));
+    const spaceVectorABWrtBaseVecs = SpaceVectorConstructor.fromScalars([
+        substract(spacePointEndWrtBaseVecs.x, spacePointStartWrtBaseVecs.x).evaluate(),
+        substract(spacePointEndWrtBaseVecs.y, spacePointStartWrtBaseVecs.y).evaluate(),
+        substract(spacePointEndWrtBaseVecs.z, spacePointStartWrtBaseVecs.z).evaluate(),
+    ]);
+    return spaceVectorABWrtBaseVecs;
+};
+const getInstruction = () => {
+    return `Déterminer les coordonnées du vecteur $\\overrightarrow{AB}$ 
+dans le repère $(O;\\overrightarrow{i};\\overrightarrow{j};\\overrightarrow{k})$ ci-dessous.
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getAnswer = (identifiers) => {
+    const spaceVectorABWrtBaseVecs = getSpaceVectorABWrtBaseVecs(identifiers);
+    return spaceVectorABWrtBaseVecs.toInlineCoordsTex();
+};
+const getHint = () => {
+    return `Pour trouver les coordonnées de $\\overrightarrow{AB}$, 
+pars du point $A$ et rejoins le point $B$ en utilisant un vecteur colinéaire à $\\overrightarrow{i}$ 
+puis en utilisant un vecteur colinéaire à $\\overrightarrow{j}$ 
+et enfin en utilisant un vecteur colinéaire à $\\overrightarrow{k}$.`;
+};
+const getCorrection = (identifiers) => {
+    return `On part du point $A$ et on rejoint le point $B$ en utilisant un vecteur colinéaire à $\\overrightarrow{i}$ 
+puis en utilisant un vecteur colinéaire à $\\overrightarrow{j}$ 
+et enfin en utilisant un vecteur colinéaire à $\\overrightarrow{k}$.
+On trouve les coordonnées $${getAnswer(identifiers)}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { spacePointCubeOrigin, arrCubeVec, arrBaseVec, arrConstructionOfSpacePointEnd, } = 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 [spacePointStart] = arrConstructionOfSpacePointEnd.slice(0, 1);
+    spacePointStart.name = "A";
+    const [spacePointEnd] = arrConstructionOfSpacePointEnd.slice(-1);
+    spacePointEnd.name = "B";
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...[spacePointCubeOrigin, spacePointStart, spacePointEnd].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)`,
+            ]),
+            //correction vecs
+            ...zip(arrConstructionOfSpacePointEnd.slice(0, -1), arrConstructionOfSpacePointEnd.slice(1)).flatMap(([pointStart, pointEnd], i) => [
+                `vc${i} = Vector(${pointStart.toMathString()},${pointEnd.toMathString()})`,
+                `SetColor(vc${i}, "${colorWithOpacity(orange, 10)}")`,
+                `SetLineThickness(S_${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, arrBaseVec, arrConstructionOfSpacePointEnd, } = 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 [spacePointStart] = arrConstructionOfSpacePointEnd.slice(0, 1);
+    spacePointStart.name = "A";
+    const [spacePointEnd] = arrConstructionOfSpacePointEnd.slice(-1);
+    spacePointEnd.name = "B";
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...[spacePointCubeOrigin, spacePointStart, spacePointEnd].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 }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const spaceVectorABWrtBaseVecs = getSpaceVectorABWrtBaseVecs(identifiers);
+    const arrNodeAnswer = [
+        spaceVectorABWrtBaseVecs.x,
+        spaceVectorABWrtBaseVecs.y,
+        spaceVectorABWrtBaseVecs.z,
+    ];
+    permute(arrNodeAnswer).forEach((arrNodeAnswerWrong) => {
+        const spacePointWrong = SpacePointConstructor.fromScalars(arrNodeAnswerWrong.map((node) => node.evaluate()));
+        tryToAddWrongProp(propositions, spacePointWrong.toCoords());
+    });
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const spaceVectorABWrtBaseVecs = getSpaceVectorABWrtBaseVecs(identifiers);
+    const arrNodeAnswer = [
+        spaceVectorABWrtBaseVecs.x,
+        spaceVectorABWrtBaseVecs.y,
+        spaceVectorABWrtBaseVecs.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) => {
+    const spacePointStart = createRandomSpacePointAskedWrtBaseVecs(arrFactorBaseWrtCube);
+    let spacePointEnd;
+    let isFound = false;
+    while (!isFound) {
+        const spacePointEndCandidate = createRandomSpacePointAskedWrtBaseVecs(arrFactorBaseWrtCube);
+        isFound = zip([
+            spacePointEndCandidate.x,
+            spacePointEndCandidate.y,
+            spacePointEndCandidate.z,
+        ], [spacePointStart.x, spacePointStart.y, spacePointStart.z]).some(([node1, node2]) => !NodeComparator.isEqualViaSub(node1, node2));
+        if (isFound) {
+            spacePointEnd = spacePointEndCandidate;
+            isFound = true;
+        }
+    }
+    return [spacePointStart, spacePointEnd];
+};
+const createRandomIdentifiers = () => {
+    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 [spacePointStartWrtBaseVecs, spacePointEndWrtBaseVecs] = createArrRandomSpacePointWrtBaseVecs(arrFactorBaseWrtCube);
+    const identifiers = {
+        spacePointIdsCubeOrigin: spacePointCubeOrigin.toIdentifiers(),
+        spacePointIdsCubeVecsEndPoint: arrCubeVecEndPoint.map((point) => point.toIdentifiers()),
+        spacePointIdsBaseVecsEndPoint: arrBaseVecEndPoint.map((point) => point.toIdentifiers()),
+        spacePointIdsStartWrtBaseVecs: spacePointStartWrtBaseVecs.toIdentifiers(),
+        spacePointIdsEndWrtBaseVecs: spacePointEndWrtBaseVecs.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getSpaceCoordinatesOfVectorInCubeCoordSystemQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    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;
+};
+export const spaceCoordinatesOfVectorInCubeCoordSystem = {
+    id: "spaceCoordinatesOfVectorInCubeCoordSystem",
+    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(() => getSpaceCoordinatesOfVectorInCubeCoordSystemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { SpacePointIdentifiers } from "../../../../math/geometry/spacePoint.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    spacePointIdsVecs: SpacePointIdentifiers[];
+    nodeIdsLinearCombination: NodeIdentifiers;
+};
+type Options = {
+    isAllowRationalFactors: boolean;
+};
+export declare const spaceVectorLinearCombinationFromCoords: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=spaceVectorLinearCombinationFromCoords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spaceVectorLinearCombinationFromCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/basis/spaceVectorLinearCombinationFromCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAM3C,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,qBAAqB,EAAE,CAAC;IAC3C,wBAAwB,EAAE,eAAe,CAAC;CAC3C,CAAC;AAoSF,KAAK,OAAO,GAAG;IACb,sBAAsB,EAAE,OAAO,CAAC;CACjC,CAAC;AAcF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAqBR,CAAC"}