math-exercises 3.0.213 → 3.0.215

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

@@ -0,0 +1,538 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { blueMain, colorWithOpacity, greenMain, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { SpacePointConstructor, } from "../../../../math/geometry/spacePoint.js";
+import { SpaceVectorConstructor, } from "../../../../math/geometry/spaceVector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { transpose } from "../../../../utils/arrays/transpose.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getCoordsForFrame = (spacePointStart, spacePointEnd) => {
+    const [arrAxisMin, arrAxisMax] = [Math.min, Math.max].map((funcMinMax) => {
+        return ["x", "y", "z"].map((axis) => {
+            const [vAxisStart, vAxisEnd] = [spacePointStart, spacePointEnd]
+                .map((spacePoint) => spacePoint[axis])
+                .map((node) => node.evaluate());
+            return funcMinMax(vAxisStart, vAxisEnd);
+        });
+    });
+    const [xMin, yMin, zMin] = arrAxisMin;
+    const [xMax, yMax, zMax] = arrAxisMax;
+    return [xMin, xMax, yMin, yMax, zMin, zMax];
+};
+const createArrSpacePointBoundingBox = (spacePointStart, spacePointEnd) => {
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    const arrSpacePoint = getCartesiansProducts([
+        [xMin, xMax],
+        [yMin, yMax],
+        [zMin, zMax],
+    ]).map(([x, y, z], i) => {
+        return SpacePointConstructor.fromScalars([x, y, z], `PBB${i}`);
+    });
+    return arrSpacePoint;
+};
+const getAcceptedInputTypesSentence = (acceptedInputType) => {
+    return `Donner le résultat
+${(() => {
+        switch (acceptedInputType) {
+            case "exact":
+                return "sous forme exacte";
+            default:
+            case "arrondi au centième":
+                return "arrondie au centième";
+        }
+    })()}.`;
+};
+const getFormattedNode = (node, acceptedInputType) => {
+    switch (acceptedInputType) {
+        case "exact":
+            return node;
+        default:
+        case "arrondi au centième":
+            return round(node.evaluate(), 2).toTree();
+    }
+};
+/**********/
+function* genFuncNamePretty() {
+    const arrLetter = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+    yield* arrLetter;
+    return "Done";
+}
+const getRectangularPrismPoints = (rectangularPrismOriginSpacePoint, L, l, h) => {
+    const [x1, y1, z1] = [
+        rectangularPrismOriginSpacePoint.x,
+        rectangularPrismOriginSpacePoint.y,
+        rectangularPrismOriginSpacePoint.z,
+    ].map((node) => node.evaluate());
+    const [x2, y2, z2] = [x1, y1, z1].map((t, i) => add(t, [L, l, h][i]).evaluate());
+    return [
+        //bottom
+        SpacePointConstructor.fromScalars([x1, y1, z1]),
+        SpacePointConstructor.fromScalars([x1, y2, z1]),
+        SpacePointConstructor.fromScalars([x2, y2, z1]),
+        SpacePointConstructor.fromScalars([x2, y1, z1]),
+        //top
+        SpacePointConstructor.fromScalars([x1, y1, z2]),
+        SpacePointConstructor.fromScalars([x1, y2, z2]),
+        SpacePointConstructor.fromScalars([x2, y2, z2]),
+        SpacePointConstructor.fromScalars([x2, y1, z2]),
+    ];
+};
+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 = (rectangularPrismOriginSpacePoint, L, l, h) => {
+    return [
+        //z-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 1, 0]), L, l),
+        //z+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([0, 0, h]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 1, 0]), L, l),
+        //y-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), L, h),
+        //y+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([0, l, 0]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([1, 0, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), L, h),
+        //x-
+        createPointMeshForSide(rectangularPrismOriginSpacePoint, SpaceVectorConstructor.fromScalars([0, 1, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), l, h),
+        //x+
+        createPointMeshForSide(SpaceVectorConstructor.fromScalars([L, 0, 0]).getEndPoint(rectangularPrismOriginSpacePoint, "NoName"), SpaceVectorConstructor.fromScalars([0, 1, 0]), SpaceVectorConstructor.fromScalars([0, 0, 1]), l, h),
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { L, l, h, arrSegmentSpacePointIds, acceptedInputType } = identifiers;
+    const arrSegmentSpacePoint = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    return `Le pavé droit affiché a les dimensions suivantes : 
+- longueur : $${L.frenchify()}$
+- largeur : $${l.frenchify()}$
+- hauteur : $${h.frenchify()}$
+
+Quelle est la longueur du segment $${texSegment}$ ?
+${getAcceptedInputTypesSentence(acceptedInputType)}
+
+*On pourra tourner la fenêtre graphique.*`;
+};
+const createNodeSumOfSquares = (identifiers, isShouldFilterOutZeros = true) => {
+    const { arrSegmentSpacePointIds } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSubNode = ["x", "y", "z"]
+        .map((axis) => square(abs(substract(spacePointEnd[axis], spacePointStart[axis])).simplify({ towardsDistribute: true })))
+        .filter((node) => isShouldFilterOutZeros
+        ? !NodeComparator.isEqualViaSub(node, (0).toTree())
+        : true);
+    const nodeSumOfSquares = operatorComposition(AddNode, arrSubNode);
+    return nodeSumOfSquares;
+};
+const getAnswerNode = (identifiers, isShouldFilterOutZeros = true) => {
+    const nodeSumOfSquares = createNodeSumOfSquares(identifiers, isShouldFilterOutZeros);
+    const nodeAnswerRaw = sqrt(nodeSumOfSquares);
+    return nodeAnswerRaw;
+};
+const getAnswer = (identifiers) => {
+    const { acceptedInputType } = identifiers;
+    return getFormattedNode(getAnswerNode(identifiers), acceptedInputType)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { arrSegmentSpacePointIds } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    const texVec = `\\overrightarrow{${spacePointStart.name}${spacePointEnd.name}}`;
+    return `La longueur du segment $${texSegment}$ est la norme du vecteur $\\overrightarrow{v} = ${texVec}$. 
+Détermine les $3$ composantes $v_x$, $v_y$, $v_z$ 
+et utilise la formule (qui découle d'une double application du théorème de Pythagore) : 
+
+$$
+\\lVert \\overrightarrow v \\rVert = \\sqrt{ {v_x}^2 + {v_y}^2 + {v_z}^2 }
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { arrSegmentSpacePointIds, acceptedInputType } = identifiers;
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const texLength = `${spacePointStart.name}${spacePointEnd.name}`;
+    const texSegment = `[${spacePointStart.name}${spacePointEnd.name}]`;
+    const texVec = `\\overrightarrow{${spacePointStart.name}${spacePointEnd.name}}`;
+    const nodeAnswer = getAnswerNode(identifiers, false);
+    return `La longueur du segment $${texSegment}$ est la norme du vecteur $${texVec}$. 
+On détermine les $3$ composantes $v_x$, $v_y$, $v_z$ :
+et utilise la formule (qui découle d'une double application du théorème de Pythagore) : 
+
+${alignTex([
+        [texLength, "=", `\\lVert ${texVec} \\rVert`],
+        ["", "=", nodeAnswer.toTex()],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+        ...(acceptedInputType === "arrondi au centième"
+            ? [
+                [
+                    "",
+                    "\\approx",
+                    getFormattedNode(nodeAnswer, acceptedInputType).toTex(),
+                ],
+            ]
+            : [[]]),
+    ])}
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { rectangularPrismOrigin, L, l, h, arrSegmentSpacePointIds } = identifiers;
+    const spacePointRectangularPrismOrigin = SpacePointConstructor.fromIdentifiers(rectangularPrismOrigin);
+    const rectangularPrismSpacePoints = getRectangularPrismPoints(spacePointRectangularPrismOrigin, L, l, h);
+    const arrSegmentSpacePoint = [...arrSegmentSpacePointIds].map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePoint = [
+        // spacePointRectangularPrismOrigin,
+        ...arrSegmentSpacePoint,
+    ];
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const arrSpacePointBoundingBox = createArrSpacePointBoundingBox(spacePointStart, spacePointEnd);
+    const arrSide = getAllPointMeshes(rectangularPrismSpacePoints[0], L, l, h);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0.1)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePoint.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${rectangularPrismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 14)}")`,
+            `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)`,
+                ];
+            }),
+        ],
+        //segment
+        `segInstruction = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+        `SetLineThickness(segInstruction, 4)`,
+        `SetColor(segInstruction, "${blueMain}")`,
+        //boundingBox of segment
+        `polyBoundinBox = Polygon(${[
+            arrSpacePointBoundingBox[0],
+            arrSpacePointBoundingBox[1],
+            arrSpacePointBoundingBox[3],
+            arrSpacePointBoundingBox[2],
+        ]
+            .map((p) => p.toMathString())
+            .join(",")})`,
+        `priBoundingBox = Prism(polyBoundinBox, ${arrSpacePointBoundingBox[4].toMathString()})`,
+        `SetColor(priBoundingBox, "${colorWithOpacity(`${greenMain}`, 69)}")`,
+        `SetLineThickness(priBoundingBox, 2)`,
+        // `RunUpdateScript()`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.5, -1, -1],
+    });
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2, zMin - 2, zMax + 2],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { rectangularPrismOrigin, L, l, h, arrSegmentSpacePointIds } = identifiers;
+    const spacePointRectangularPrismOrigin = SpacePointConstructor.fromIdentifiers(rectangularPrismOrigin);
+    const rectangularPrismSpacePoints = getRectangularPrismPoints(spacePointRectangularPrismOrigin, L, l, h);
+    const arrSegmentSpacePoint = [...arrSegmentSpacePointIds].map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+    const arrSpacePoint = [
+        // spacePointRectangularPrismOrigin,
+        ...arrSegmentSpacePoint,
+    ];
+    const [spacePointStart, spacePointEnd] = arrSegmentSpacePoint;
+    const arrSide = getAllPointMeshes(rectangularPrismSpacePoints[0], L, l, h);
+    const arrSegment = arrSide.flatMap(createSegmentMeshForPointMesh);
+    const commands = [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0.1)`,
+        //pretty names
+        ...[
+            //points
+            ...arrSpacePoint.flatMap((spacePoint) => spacePoint.toGGBCommand({
+                isFixed: true,
+                showLabel: true,
+            })),
+        ],
+        //no names
+        ...[
+            //prism
+            `Pri = Prism(${rectangularPrismSpacePoints
+                .slice(0, 5)
+                .map((p) => p.toMathString())
+                .join(",")})`,
+            `SetColor(Pri, "${colorWithOpacity("#000000", 14)}")`,
+            `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)`,
+                ];
+            }),
+        ],
+        //segment
+        `segInstruction = Segment(${spacePointStart.toMathString()}, ${spacePointEnd.toMathString()})`,
+        `SetLineThickness(segInstruction, 4)`,
+        `SetColor(segInstruction, "${blueMain}")`,
+        // `RunUpdateScript()`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        hideAxes: true,
+        viewDirectionVector: [-0.5, -1, -1],
+    });
+    const [xMin, xMax, yMin, yMax, zMin, zMax] = getCoordsForFrame(spacePointStart, spacePointEnd);
+    return ggb.getOptions({
+        coords: [xMin - 2, xMax + 2, yMin - 2, yMax + 2, zMin - 2, zMax + 2],
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        nbComponents: random(arrayedOpts.nbComponents),
+    };
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { acceptedInputType } = identifiers;
+    const createNodeSum = (identifiers, isShouldFilterOutZeros = true) => {
+        const { arrSegmentSpacePointIds } = identifiers;
+        const [spacePointStart, spacePointEnd] = arrSegmentSpacePointIds.map((spacePointIds) => SpacePointConstructor.fromIdentifiers(spacePointIds));
+        const arrSubNode = ["x", "y", "z"]
+            .map((axis) => abs(substract(spacePointEnd[axis], spacePointStart[axis])).simplify({ towardsDistribute: true }))
+            .filter((node) => isShouldFilterOutZeros
+            ? !NodeComparator.isEqualViaSub(node, (0).toTree())
+            : true);
+        const nodeSumOfSquares = operatorComposition(AddNode, arrSubNode);
+        return nodeSumOfSquares;
+    };
+    //student: forgets squares
+    {
+        const nodeWrong = getFormattedNode(sqrt(createNodeSum(identifiers, true)).simplify({
+            towardsDistribute: true,
+        }), acceptedInputType);
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    if (coinFlip()) {
+        //student: forgets sqrt
+        {
+            const nodeWrong = getFormattedNode(createNodeSumOfSquares(identifiers, true).simplify({
+                towardsDistribute: true,
+            }), acceptedInputType);
+            tryToAddWrongProp(propositions, nodeWrong.toTex());
+        }
+    }
+    else {
+        //student: forgets sqrt and squares
+        {
+            const nodeWrong = getFormattedNode(createNodeSum(identifiers, true).simplify({
+                towardsDistribute: true,
+            }), acceptedInputType);
+            tryToAddWrongProp(propositions, nodeWrong.toTex());
+        }
+    }
+    //student: l'âge du capitaine
+    {
+        const { L, l, h } = identifiers;
+        const nodeWrong = getFormattedNode(sqrt(operatorComposition(AddNode, [L, l, h].map((v) => square(v)))), acceptedInputType).simplify({
+            towardsDistribute: true,
+        });
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong, opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }, _optsIn) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (_) {
+        return false;
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const L = randint(3, 7);
+    const l = randint(3, 7);
+    const h = randint(3, 7);
+    const genNamePretty = genFuncNamePretty();
+    const rectangularPrismOriginSpacePoint = SpacePointConstructor.fromScalars([0, 0, 0], genNamePretty.next().value);
+    function createSpacePointWithPrettyName(spacePoint) {
+        const namePretty = genNamePretty.next().value;
+        const spacePointWithPrettyName = SpacePointConstructor.fromIdentifiers(Object.assign({}, spacePoint.toIdentifiers(), {
+            name: namePretty,
+        }));
+        return spacePointWithPrettyName;
+    }
+    const arrSide = getAllPointMeshes(rectangularPrismOriginSpacePoint, L, l, h).map((arrArrSpacePoint) => arrArrSpacePoint.flat());
+    function getNbShared(spacePoint1, spacePoint2) {
+        return zip([spacePoint1.x, spacePoint1.y, spacePoint1.z], [spacePoint2.x, spacePoint2.y, spacePoint2.z]).reduce((acc, [nodeSpacePoint1Axis, nodeSpacePoint2Axis]) => {
+            return (acc +
+                (NodeComparator.isEqualViaSub(nodeSpacePoint1Axis, nodeSpacePoint2Axis)
+                    ? 1
+                    : 0));
+        }, 0);
+    }
+    function getSpacePoint2(arrSpacePoint, spacePoint1Raw, nbDifferent) {
+        const arrSpacePointCandidate = arrSpacePoint.filter((spacePoint2Raw) => {
+            const nbShared = getNbShared(spacePoint2Raw, spacePoint1Raw);
+            return nbShared === 3 - nbDifferent;
+        });
+        return random(arrSpacePointCandidate);
+    }
+    const arrSegmentSpacePoint = (() => {
+        switch (opts.nbComponents) {
+            case "2": {
+                const arrSpacePoint = random(arrSide);
+                const spacePoint1Raw = random(arrSpacePoint);
+                const spacePoint2Raw = getSpacePoint2(arrSpacePoint, spacePoint1Raw, 2);
+                return [spacePoint1Raw, spacePoint2Raw].map(createSpacePointWithPrettyName);
+            }
+            case "3": {
+                const [arrSpacePoint1, arrSpacePoint2] = randomMany(arrSide, 2);
+                let isFound = false;
+                let spacePoint1Raw;
+                let spacePoint2Raw;
+                while (!isFound) {
+                    spacePoint1Raw = random(arrSpacePoint1);
+                    spacePoint2Raw = getSpacePoint2(arrSpacePoint2, spacePoint1Raw, 3);
+                    isFound = spacePoint2Raw !== undefined;
+                }
+                return [spacePoint1Raw, spacePoint2Raw].map(createSpacePointWithPrettyName);
+            }
+            default:
+                throw new Error("Unsupported opts.nbComponents: " + opts.nbComponents);
+        }
+    })();
+    const identifiers = {
+        rectangularPrismOrigin: rectangularPrismOriginSpacePoint.toIdentifiers(),
+        L,
+        l,
+        h,
+        arrSegmentSpacePointIds: arrSegmentSpacePoint.map((spacePoint) => spacePoint.toIdentifiers()),
+        acceptedInputType: opts.acceptedInputType,
+    };
+    return identifiers;
+};
+const getSpaceSegmentLengthInRectangularPrismQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        nbComponents: random(arrayedOpts.nbComponents),
+    };
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        identifiers,
+        keys: getKeys(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    acceptedInputType: "exact",
+};
+const arrayedOptsDefault = {
+    nbComponents: ["2", "3"],
+};
+const options = [
+    {
+        id: "nbComponents",
+        label: "Nombre de composantes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["2", "3"],
+        defaultValue: arrayedOptsDefault.nbComponents,
+    },
+    {
+        id: "acceptedInputType",
+        label: "Format du résultat",
+        target: GeneratorOptionTarget.vea,
+        type: GeneratorOptionType.select,
+        values: ["exact", "arrondi au centième"],
+        defaultValue: optsDefault.acceptedInputType,
+    },
+];
+export const spaceSegmentLengthInRectangularPrism = {
+    id: "spaceSegmentLengthInRectangularPrism",
+    connector: "=",
+    label: "Longueur d'un segment dans un pavé droit",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSpaceSegmentLengthInRectangularPrismQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+    getPropositions,
+};

package/lib/exercises/math/trigonometry/formulas/trigoAdditionFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigoAdditionFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/formulas/trigoAdditionFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA2NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAwB3D,CAAC"}
+{"version":3,"file":"trigoAdditionFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/formulas/trigoAdditionFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA4NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAwB3D,CAAC"}

package/lib/exercises/math/trigonometry/formulas/trigoAdditionFormulaUsage.js

@@ -92,7 +92,8 @@ const getCorrection = (identifiers) => {
     const angle = frac(multiply(k, PiNode), 12);
     const [a, b] = getDecompCoeffs(identifiers);
     const absB = b.evaluate() > 0 ? b : opposite(b).simplify();
-    const formula = getFormula(isCos, b.evaluate() > 0).rightChild;
+    const formula = getFormula(isCos, b.evaluate() > 0);
+    const formulaRight = formula.rightChild;
     const start = fct(angle).toTex();
     return `On remarque que :
   
@@ -113,7 +114,7 @@ ${alignTex([
         [
             "",
             "=",
-            formula
+            formulaRight
                 .toDetailedEvaluation({
                 a: a,
                 b: absB,
@@ -123,7 +124,7 @@ ${alignTex([
         [
             "",
             "=",
-            formula
+            formulaRight
                 .toDetailedEvaluation({
                 a: a,
                 b: abs(b),
@@ -137,7 +138,7 @@ ${alignTex([
         [
             "",
             "=",
-            formula
+            formulaRight
                 .toDetailedEvaluation({
                 a: a,
                 b: abs(b),
@@ -150,7 +151,7 @@ ${alignTex([
         [
             "",
             "=",
-            formula
+            formulaRight
                 .toDetailedEvaluation({
                 a: a,
                 b: absB,

package/lib/exercises/math/trigonometry/triangle/trigonometrySohcahtoaCalcul.js

@@ -91,7 +91,7 @@ ${triangle.sides.map((side) => `- $${side.toLengthTex()}\\ \\textrm{cm}$`)
   
 `)} 
     
-Calculer ${trigoFunc.strFrenchThe} de l'angle $${texAngle}$.
+Calculer ${trigoFunc.strFrenchThe} de l'angle $${texAngle}$ 
 ${getAcceptedInputTypesSentence(opts.acceptedInputType)}.`;
 };
 const getAnswerNode = (identifiers) => {

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -13,5 +13,6 @@ export declare const toolBarConstructor: (options: {
     erase?: boolean;
     centralSymetric?: boolean;
     lineSymetric?: boolean;
+    midpoint?: boolean;
 }) => string;
 //# sourceMappingURL=toolBarConstructor.d.ts.map

package/lib/exercises/utils/geogebra/toolBarConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,WAkBA,CAAC"}
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,GAAI,SAAS;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,WAoBA,CAAC"}

package/lib/exercises/utils/geogebra/toolBarConstructor.js

@@ -28,5 +28,7 @@ export const toolBarConstructor = (options) => {
         customToolBar += "||29";
     if (options.lineSymetric)
         customToolBar += "||30";
+    if (options.midpoint)
+        customToolBar += "||19";
     return customToolBar;
 };

package/lib/geogebra/parsers/geogebraParser.d.ts

@@ -8,5 +8,8 @@ export declare class GeogebraParser {
         [k: string]: string;
     };
     static pointNamesForLineObj(lineObj: string): string[];
+    static pointNamesForCircleObj(lineObj: string): string[];
+    static argNamesForOrthogonalLineObj(lineObj: string): string[];
+    static argNamesForVectorObj(lineObj: string): string[];
 }
 //# sourceMappingURL=geogebraParser.d.ts.map

package/lib/geogebra/parsers/geogebraParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;IAyCP,uBAAuB;IAsCvB,UAAU;;;IAWV,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;CAS5C"}
+{"version":3,"file":"geogebraParser.d.ts","sourceRoot":"","sources":["../../../src/geogebra/parsers/geogebraParser.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAc;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACP,eAAe,EAAE,MAAM,EAAE;IAIrC,WAAW,CAAC,IAAI,EAAE,MAAM;IAWxB,OAAO;IAyCP,uBAAuB;IAsCvB,UAAU;;;IAWV,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;IAU3C,MAAM,CAAC,sBAAsB,CAAC,OAAO,EAAE,MAAM;IAU7C,MAAM,CAAC,4BAA4B,CAAC,OAAO,EAAE,MAAM;IAUnD,MAAM,CAAC,oBAAoB,CAAC,OAAO,EAAE,MAAM;CAS5C"}

package/lib/geogebra/parsers/geogebraParser.js

@@ -111,4 +111,31 @@ export class GeogebraParser {
         const [, nameA, nameB] = match;
         return [nameA, nameB];
     }
+    static pointNamesForCircleObj(lineObj) {
+        const reLine = /^Circle\[\s*([^,\]]+)\s*,\s*([^,\]]+)\s*\]$/;
+        const match = lineObj.match(reLine);
+        if (!match) {
+            return [];
+        }
+        const [, nameA, nameB] = match;
+        return [nameA, nameB];
+    }
+    static argNamesForOrthogonalLineObj(lineObj) {
+        const reLine = /^OrthogonalLine\[\s*([^,\]]+)\s*,\s*([^,\]]+)\s*\]$/;
+        const match = lineObj.match(reLine);
+        if (!match) {
+            return [];
+        }
+        const [, nameA, nameB] = match;
+        return [nameA, nameB];
+    }
+    static argNamesForVectorObj(lineObj) {
+        const reLine = /^Vector\[\s*([^,\]]+)\s*,\s*([^,\]]+)\s*\]$/;
+        const match = lineObj.match(reLine);
+        if (!match) {
+            return [];
+        }
+        const [, nameA, nameB] = match;
+        return [nameA, nameB];
+    }
 }