math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/spaceGeometry/scalarProduct/scalarProductFromCubeOuterPoints.js

@@ -0,0 +1,497 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, 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 { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector, SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { isVariableNode, 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 { random, randomMany } 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 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 { spacePointIds, nodeIdsSideLength } = identifiers;
+    const nodeSideLength = NodeConstructor.fromIdentifiers(nodeIdsSideLength);
+    const [A, B, C, D] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const spacePointCubeOrigin = SpacePointConstructor.fromScalars([0, 0, 0], "O");
+    const [vecXCube, vecYCube, vecZCube] = [
+        SpaceVectorConstructor.fromScalars([1, 0, 0], "i"),
+        SpaceVectorConstructor.fromScalars([0, 1, 0], "j"),
+        SpaceVectorConstructor.fromScalars([0, 0, 1], "k"),
+    ];
+    const [vecAB, vecCD] = [
+        [A, B],
+        [C, D],
+    ].map(([spacePointStart, spacePointEnd]) => SpaceVectorConstructor.fromPoints(spacePointStart, spacePointEnd).times(nodeSideLength));
+    return {
+        nodeSideLength,
+        A,
+        B,
+        C,
+        D,
+        spacePointCubeOrigin,
+        vecXCube,
+        vecYCube,
+        vecZCube,
+        vecAB,
+        vecCD,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsSideLength } = identifiers;
+    const nodeSideLength = NodeConstructor.fromIdentifiers(nodeIdsSideLength);
+    return `Le cube représenté ci-dessous a pour côté $${nodeSideLength.toTex()}$.
+
+Calculer $\\overrightarrow{AB} \\cdot \\overrightarrow{CD}$ dans la base $(\\overrightarrow{i},\\overrightarrow{j},\\overrightarrow{k})$.
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const getAnswerNode = (identifiers) => {
+    const { vecAB, vecCD } = getHydrated(identifiers);
+    return vecAB.scalarProduct(vecCD);
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsSideLength } = identifiers;
+    const nodeSideLength = NodeConstructor.fromIdentifiers(nodeIdsSideLength);
+    return getAnswerNode(identifiers)
+        .simplify(isVariableNode(nodeSideLength)
+        ? { decimalToFractions: true }
+        : { towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    return `Si les vecteurs apparaissent manifestement orthogonaux, le produit scalaire sera $0$.
+Sinon, tu peux toujours déterminer les coordonnées de $\\overrightarrow{AB}$ et de $\\overrightarrow{CD}$ puis calculer le produit scalaire à partir des coordonnées.`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecCD } = getHydrated(identifiers);
+    const nodeAnswer = getAnswerNode(identifiers);
+    return `On détermine les coordonnées de $\\overrightarrow{AB}$ et de $\\overrightarrow{CD}$ dans la base $(\\overrightarrow{i},\\overrightarrow{j},\\overrightarrow{k})$ :
+
+${alignTex([vecAB, vecCD].map((vec) => [vec.toTex(), "=", vec.toCoordsTex()]))}
+
+On a donc :
+
+${alignTex([
+        ["\\overrightarrow{AB} \\cdot \\overrightarrow{CD}", "=", nodeAnswer.toTex()],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { A, B, C, D, spacePointCubeOrigin, vecXCube, vecYCube, vecZCube } = getHydrated(identifiers);
+    const prismSpacePoints = getPrismPoints(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSide = getAllPointMeshes(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const arrBaseVec = [vecXCube, vecYCube, vecZCube];
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...[A, B, C, D].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";
+                    }
+                })()})`,
+                // `SetFilling(v${i}, 0.2)`, //not working :(
+                `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)`,
+            ]),
+            ...[
+                [A, B],
+                [C, D],
+            ].flatMap(([spacePointStart, spacePointEnd], i) => [
+                `vP${i} = Vector(${spacePointStart.toMathString()},${spacePointEnd.toMathString()})`,
+                `SetColor(vP${i}, "${orange}")`,
+            ]),
+        ],
+    ];
+    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 { A, B, C, D, spacePointCubeOrigin, vecXCube, vecYCube, vecZCube } = getHydrated(identifiers);
+    const prismSpacePoints = getPrismPoints(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSide = getAllPointMeshes(spacePointCubeOrigin, vecXCube, vecYCube, vecZCube);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const arrBaseVec = [vecXCube, vecYCube, vecZCube];
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //pretty names
+        ...[
+            //points
+            ...[A, B, C, D].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";
+                    }
+                })()})`,
+                // `SetFilling(v${i}, 0.2)`, //not working :(
+                `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 { vecAB, vecCD, nodeSideLength } = getHydrated(identifiers);
+    const [arrVec1, arrVec2] = [
+        [vecAB.x, vecAB.y, vecAB.z],
+        [vecCD.x, vecCD.y, vecCD.z],
+    ];
+    //student: error wrt vector coords order
+    {
+        zip(permute(arrVec1), permute(arrVec2)).forEach(([arrNodeVec1Wrong, arrNodeVec2Wrong]) => {
+            const [vec1Wrong, vec2Wrong] = [arrNodeVec1Wrong, arrNodeVec2Wrong].map(([nodeX, nodeY, nodeZ]) => new SpaceVector("vecWrong", nodeX, nodeY, nodeZ));
+            const nodeAnswerWrong = vec1Wrong
+                .scalarProduct(vec2Wrong)
+                .simplify({ towardsDistribute: true });
+            tryToAddWrongProp(propositions, nodeAnswerWrong.toTex());
+        });
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(coinFlip(), nodeSideLength);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsSideLength } = identifiers;
+    const nodeSideLength = NodeConstructor.fromIdentifiers(nodeIdsSideLength);
+    if (isVariableNode(nodeSideLength)) {
+        return [nodeSideLength.name];
+    }
+    else {
+        return [];
+    }
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const nodeAnswer = getAnswerNode(identifiers);
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (isIncludeMidpoints, nodeSideLength) => {
+    const arrSpacePointCubeVertex = [
+        //floor
+        [0, 0, 0],
+        [0, 1, 0],
+        [1, 1, 0],
+        [1, 0, 0],
+        //ceiling
+        [0, 0, 1],
+        [0, 1, 1],
+        [1, 1, 1],
+        [1, 0, 1],
+    ].map(([x, y, z], i) => {
+        const [nodeX, nodeY, nodeZ] = [x, y, z].map((v) => v.toTree());
+        return new SpacePoint(`P${i}`, nodeX, nodeY, nodeZ);
+    });
+    const [A, B, C, D] = zip("ABCD".split(""), randomMany([
+        ...arrSpacePointCubeVertex,
+        ...(isIncludeMidpoints
+            ? (() => {
+                const nodeZero = (0).toTree();
+                const nodeHalf = frac(1, 2);
+                const nodeOne = (1).toTree();
+                const arrSpacePointCubeMidpoint = [
+                    //floor
+                    [nodeZero, nodeHalf, nodeZero],
+                    [nodeHalf, nodeOne, nodeZero],
+                    [nodeOne, nodeHalf, nodeZero],
+                    [nodeHalf, nodeZero, nodeZero],
+                    //ceiling
+                    [nodeZero, nodeHalf, nodeOne],
+                    [nodeHalf, nodeOne, nodeOne],
+                    [nodeOne, nodeHalf, nodeOne],
+                    [nodeHalf, nodeZero, nodeOne],
+                ].map(([nodeX, nodeY, nodeZ], i) => new SpacePoint(`P${i}`, nodeX, nodeY, nodeZ));
+                return arrSpacePointCubeMidpoint;
+            })()
+            : []),
+    ], 4)).map(([name, spacePointRaw]) => new SpacePoint(name, spacePointRaw.x, spacePointRaw.y, spacePointRaw.z));
+    const identifiers = {
+        spacePointIds: [A, B, C, D].map((spacePoint) => spacePoint.toIdentifiers()),
+        nodeIdsSideLength: nodeSideLength.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getScalarProductFromCubeOuterPointsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const isIncludeMidpoints = opts.isIncludeMidpoints;
+    const typeSideLength = opts.typeSideLength;
+    const nodeSideLength = (() => {
+        switch (typeSideLength) {
+            case "entier":
+                return (2 * randint(1, 6)).toTree();
+            case "variable": {
+                const letter = random(["a", "b", "c"]);
+                return new VariableNode(letter);
+            }
+            default:
+                throw new Error("Unsupported typeSideLength: " + typeSideLength);
+        }
+    })();
+    const identifiers = createRandomIdentifiers(isIncludeMidpoints, nodeSideLength);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    typeSideLength: "entier",
+    isIncludeMidpoints: true,
+};
+const options = [
+    {
+        id: "typeSideLength",
+        label: "Type de longueur pour le côté du cube",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["entier", "variable"],
+        defaultValue: optsDefault.typeSideLength,
+    },
+    {
+        id: "isIncludeMidpoints",
+        label: "inclure les milieux des arêtes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isIncludeMidpoints,
+    },
+];
+export const scalarProductFromCubeOuterPoints = {
+    id: "scalarProductFromCubeOuterPoints",
+    label: "Calculer un produit scalaire, à partir des points d'un cube de côté donné",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductFromCubeOuterPointsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/spaceGeometry/scalarProduct/scalarProductFromSpacePointCoords.d.ts

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

package/lib/exercises/math/spaceGeometry/scalarProduct/scalarProductFromSpacePointCoords.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalarProductFromSpacePointCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/scalarProduct/scalarProductFromSpacePointCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,qBAAqB,EACtB,MAAM,mCAAmC,CAAC;AAkC3C,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,qBAAqB,EAAE,CAAC;CACxC,CAAC;AAkNF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAmBnE,CAAC"}

package/lib/exercises/math/spaceGeometry/scalarProduct/scalarProductFromSpacePointCoords.js

@@ -0,0 +1,173 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SpacePoint, SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVector } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.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 { zip } from "../../../../utils/arrays/arrayZip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const spaceVectorFromPointsRaw = (spacePointStart, spacePointEnd) => {
+    return new SpaceVector(`${spacePointStart.name}${spacePointEnd.name}`, substract(spacePointEnd.x, spacePointStart.x), substract(spacePointEnd.y, spacePointStart.y), substract(spacePointEnd.z, spacePointStart.z));
+};
+const simplifySpaceVector = (vec, opts = {}) => {
+    return new SpaceVector(vec.name, vec.x.simplify(opts), vec.y.simplify(opts), vec.z.simplify(opts));
+};
+const getHydrated = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B, C] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [vecAB, vecAC] = [
+        [A, B],
+        [A, C],
+    ].map(([spacePointStart, spacePointEnd]) => spaceVectorFromPointsRaw(spacePointStart, spacePointEnd));
+    const [vecABSimplified, vecACSimplified] = [vecAB, vecAC].map((vec) => simplifySpaceVector(vec, { towardsDistribute: true }));
+    return {
+        A,
+        B,
+        C,
+        vecAB,
+        vecABSimplified,
+        vecAC,
+        vecACSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { spacePointIds } = identifiers;
+    const [A, B, C] = spacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    return `Soient trois points $A$,$B$ et $C$ de coordonnées : 
+
+${alignTex([A, B, C].map((spacePoint) => [spacePoint.toTexWithCoords()]))}
+  
+Calculer $\\overrightarrow{AB} \\cdot \\overrightarrow{AC}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { vecABSimplified, vecACSimplified } = getHydrated(identifiers);
+    return vecABSimplified.scalarProduct(vecACSimplified);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    const vecU = new SpaceVector("u", new VariableNode("u_{x}"), new VariableNode("u_{y}"), new VariableNode("u_{z}"));
+    const vecV = new SpaceVector("v", new VariableNode("v_{x}"), new VariableNode("v_{y}"), new VariableNode("v_{z}"));
+    return `Soit $${vecU.toTex()}$ et $${vecV.toTex()}$ deux vecteurs tels que : 
+  
+${alignTex([vecU, vecV].map((vec) => [vec.toTexWithCoords()]))}
+
+alors
+
+$$
+\\overrightarrow{AB} \\cdot \\overrightarrow{AC} = ${vecU
+        .scalarProduct(vecV)
+        .toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { vecAB, vecAC, vecABSimplified, vecACSimplified } = getHydrated(identifiers);
+    const nodeAnswer = getAnswerNode(identifiers);
+    return `On a : 
+  
+${alignTex([
+        [vecAB, vecABSimplified],
+        [vecAC, vecACSimplified],
+    ].flatMap(([vec, vecSimplified]) => [
+        [vec.toTex(), "=", vec.toCoordsTex()],
+        ["", "=", vecSimplified.toCoordsTex()],
+    ]))}
+
+Par conséquent :
+
+${alignTex([
+        [
+            "\\overrightarrow{AB} \\cdot \\overrightarrow{AC}",
+            "=",
+            nodeAnswer.toTex({ forceNoSimplification: true, forceTimesSign: true }),
+        ],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"]; //pas gentil
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const nodeAnswer = getAnswerNode(identifiers);
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const funcRand1 = () => randint(-3, 4, coinFlip() ? [0] : []).toTree();
+    const funcRand2 = () => randint(-6, 7, coinFlip() ? [0] : []).toTree();
+    const funcRand3 = () => randint(-9, 10, coinFlip() ? [0] : []).toTree();
+    const [vecU, vecV] = zip(["u", "v"], [
+        [funcRand1, funcRand2, funcRand3],
+        [funcRand3, funcRand2, funcRand1],
+    ]).map(([name, [funcRandX, funcRandY, funcRandZ]]) => new SpaceVector(name, funcRandX(), funcRandY(), funcRandZ()));
+    const A = new SpacePoint("A", randint(-5, 6).toTree(), randint(-5, 6).toTree(), randint(-5, 6).toTree());
+    const [B, C] = [
+        ["B", vecU],
+        ["C", vecV],
+    ].map(([name, vec]) => {
+        const spacePointRaw = vec.getEndPoint(A);
+        return new SpacePoint(name, spacePointRaw.x, spacePointRaw.y, spacePointRaw.z);
+    });
+    const identifiers = {
+        spacePointIds: [A, B, C].map((vec) => new SpacePoint(vec.name, vec.x, vec.y, vec.z).toIdentifiers()),
+    };
+    return identifiers;
+};
+const getScalarProductFromSpacePointCoordsQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, _opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const scalarProductFromSpacePointCoords = {
+    id: "scalarProductFromSpacePointCoords",
+    label: "Calculer un produit scalaire $\\overrightarrow{AB} \\cdot \\overrightarrow{AC}$, à partir des coordonnées de $A$, $B$ et $C$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getScalarProductFromSpacePointCoordsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};