math-exercises 3.0.214 → 3.0.215

package/lib/exercises/math/geometry/triangles/traceHeightInTriangle.js

@@ -0,0 +1,271 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+const degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const getHydrated = (identifiers) => {
+    const { triangleIds } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
+    const [point] = triangle.points;
+    const [segment] = triangle.sides;
+    return {
+        triangle,
+        point,
+        segment,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { strNameTriangle } = identifiers;
+    const { point } = getHydrated(identifiers);
+    return `Avec les outils disponibles, construire la hauteur de $${strNameTriangle}$ issue de $${point.name}$.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { triangle, point, segment } = getHydrated(identifiers);
+    const ggbAnswer = [
+        ...getStudentGGBCommands(triangle),
+        `lPer = PerpendicularLine(${point.name},${segment.ggbName})`,
+        `SetColor(lPer, "${greenMain}")`,
+        `ang = Angle(${segment.ggbName}, lPer)`,
+        `lDashed = Line(${segment.pointA.name}, ${segment.pointB.name})`,
+        `SetLineStyle(lDashed, 2)`,
+    ];
+    return ggbAnswer;
+};
+const getHint = (identifiers) => {
+    const { point, segment } = getHydrated(identifiers);
+    return `Sélectionne l'outil Perpendiculaire dans Geogebra puis clique sur le segment $${segment.toTex()}$ puis sur le point $${point.name}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { point, segment } = getHydrated(identifiers);
+    return `On sélectionne l'outil Perpendiculaire dans Geogebra puis on clique sur le segment $${segment.toTex()}$ puis sur le point $${point.name}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: [...getGGBAnswer(identifiers)],
+        hideGrid: true,
+        hideAxes: true,
+        isGridSimple: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({ coords: [-10, 10, -10, 10] });
+};
+const getStudentGGBCommands = (triangle) => {
+    const [point] = triangle.points;
+    const [segment] = triangle.sides;
+    return [
+        ...triangle.points.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: true,
+        })),
+        ...triangle.sides.flatMap((segment) => segment.toGGBCommands(false, { isFixed: true, isSelectionnable: true })),
+        //force display of right angle (if needed)
+        ...(() => {
+            const [angleRightAngle] = triangle.angles.filter((angle) => Math.abs(angle.evaluate(false) - 90) < 0.3);
+            if (angleRightAngle !== undefined) {
+                if (angleRightAngle.evaluate() === 90) {
+                    //display is already ok
+                    return [
+                        ...angleRightAngle.toCommands({
+                            pointsAreNotBuilt: false,
+                            showValue: false,
+                        }),
+                    ];
+                }
+                else {
+                    if (angleRightAngle !== undefined) {
+                        const [pointRightAngle1, pointRightAngle2, pointRightAngle3] = angleRightAngle.points;
+                        return [
+                            `lPer = PerpendicularLine(${pointRightAngle2.name},${segment.ggbName})`,
+                            `SetVisibleInView(lPer, 1, false)`,
+                            `lPer2 = PerpendicularLine(${point.name},lPer)`,
+                            `SetVisibleInView(lPer2, 1, false)`,
+                            `prjct = Intersect(lPer, lPer2)`,
+                            `SetVisibleInView(prjct, 1, false)`,
+                            //horror?
+                            `ang1 = Angle(${pointRightAngle1.name},${pointRightAngle2.name}, prjct)`,
+                            `ShowLabel(ang1, false)`,
+                            `ang2 = Angle(prjct,${pointRightAngle2.name},${pointRightAngle1.name})`,
+                            `ShowLabel(ang2, false)`,
+                            `SetVisibleInView(ang1, 1, ang1<ang2)`,
+                            `SetVisibleInView(ang2, 1, ang2<ang1)`,
+                            `ang3 = Angle(${pointRightAngle3.name},${pointRightAngle2.name}, prjct)`,
+                            `ShowLabel(ang3, false)`,
+                            `ang4 = Angle(prjct,${pointRightAngle2.name},${pointRightAngle3.name})`,
+                            `ShowLabel(ang4, false)`,
+                            `SetVisibleInView(ang3, 1, ang3<ang4)`,
+                            `SetVisibleInView(ang4, 1, ang4<ang3)`,
+                        ];
+                    }
+                    else {
+                        return [];
+                    }
+                }
+            }
+            else {
+                return [];
+            }
+        })(),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { triangle } = getHydrated(identifiers);
+    const commands = getStudentGGBCommands(triangle);
+    const studentGGB = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        hideAxes: true,
+        customToolBar: toolBarConstructor({
+            orthogonal: true,
+        }),
+    });
+    return studentGGB.getOptions({
+        coords: studentGGB.getCoordsForPoints([...triangle.points]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { point, segment } = getHydrated(identifiers);
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const arrStrOrthogonalLine = Object.entries(objectDict)
+        .filter(([_, strObj]) => strObj.startsWith("OrthogonalLine"))
+        .map(([_, strObj]) => strObj);
+    //required: only one orthogonal line
+    if (arrStrOrthogonalLine.length !== 1) {
+        return false;
+    }
+    const [strOrthogonalLine] = arrStrOrthogonalLine;
+    const [namePointAns, nameLineAns] = GeogebraParser.argNamesForOrthogonalLineObj(strOrthogonalLine);
+    return zip([namePointAns, nameLineAns], [point.name, segment.ggbName]).every(([strAns, strAnswer]) => strAns === strAnswer);
+};
+const getTraceHeightInTriangleQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        heightType: random(arrayedOpts.heightType),
+    };
+    const [nameA, nameB, nameC] = shuffle(["A", "B", "C"]);
+    const [pointARaw, pointBRaw, pointCRaw] = (() => {
+        const a = -randint(4, 12);
+        const b = +randint(4, 12);
+        const pointA = PointConstructor.fromCoords([a, 0], nameA);
+        const pointB = PointConstructor.fromCoords([b, 0], nameB);
+        switch (opts.heightType) {
+            case "intérieure": {
+                const c = randint(a + 1, b);
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            case "sur un cathète": {
+                const isLeftSide = coinFlip();
+                const c = isLeftSide ? a : b;
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            case "extérieure": {
+                const isLeftSide = coinFlip();
+                const c = isLeftSide ? a - randint(2, 8) : b + randint(2, 8);
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            default:
+                throw new Error("Unsupported heightType: " + opts.heightType);
+        }
+    })();
+    const [pointA, pointB, pointC] = (() => {
+        const pointOrigin = new Point("O", 0, 0);
+        const angleInDegrees = randint(0, 360);
+        return [pointARaw, pointBRaw, pointCRaw].map((point) => rotatePoint(point, degreesToRadians(angleInDegrees, 5), pointOrigin, point.name));
+    })();
+    const triangle = new Triangle([pointC, pointB, pointA]);
+    const strNameTriangle = shuffle(triangle.name.split("")).join("");
+    const identifiers = {
+        triangleIds: triangle.toIdentifiers(),
+        strNameTriangle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    heightType: ["intérieure"],
+};
+const options = [
+    {
+        id: "heightType",
+        label: "Type de hauteur",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["intérieure", "sur un cathète", "extérieure"],
+        defaultValue: arrayedOptsDefault.heightType,
+    },
+];
+export const traceHeightInTriangle = {
+    id: "traceHeightInTriangle",
+    connector: "=",
+    label: "Tracer une hauteur d'un triangle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceHeightInTriangleQuestion(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getStudentGGBOptions,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.d.ts

@@ -1,2 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangles/triangle.js";
+/************/
+type Identifiers = {
+    triangleIds: TriangleIdentifiers;
+    strNameTriangle: string;
+};
+export declare const traceMedianInTriangle: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=traceMedianInTriangle.d.ts.map

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traceMedianInTriangle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/traceMedianInTriangle.ts"],"names":[],"mappings":""}
+{"version":3,"file":"traceMedianInTriangle.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/traceMedianInTriangle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAuEnD,cAAc;AAEd,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,mBAAmB,CAAC;IACjC,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAqSF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

package/lib/exercises/math/geometry/triangles/traceMedianInTriangle.js

@@ -1,53 +1,284 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   GGBVEA,
-//   addValidProp,
-//   shuffleProps,
-//   tryToAddWrongProp,
-// } from '../../../../exercises/exercise.js';
-// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
-export {};
-// type Identifiers = {
-// };
-// const getTraceMedianInTriangleQuestion: QuestionGenerator<Identifiers>  = ()=>{
-//   const question: Question<Identifiers> = {
-//     answer,
-//     instruction: ``,
-//     keys: [],
-//     answerFormat: 'tex',
-//     identifiers : {}
-//   };
-//   return question;
-// }
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   propWhile(propositions, n, () => {
-//     throw Error("QCM not implemented")
-//   }
-//   return shuffleProps(propositions, n);
-// };
-// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
-//   throw Error("VEA not implemented")
-// }
-// const isGGBAnswerValid: GGBVEA<Identifiers> = (ans, {ggbAnswer}) => {
-//   throw Error("GGBVea not implemented")
-// }
-// export const traceMedianInTriangle: Exercise<Identifiers> = {
-//   id: 'traceMedianInTriangle',
-//   connector: "",
-//   label: "",
-//   isSingleStep: true,
-//   generator: (nb: number) => getDistinctQuestions(getTraceMedianInTriangleQuestion, nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   isGGBAnswerValid,
-//   subject: "Mathématiques"
-// };
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point, PointConstructor } from "../../../../math/geometry/point.js";
+import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const degreesToRadians = (angleInDegrees, precision) => {
+    const oneOver180 = 0.00555555555555555;
+    return round(multiply(multiply(angleInDegrees, PiNode), oneOver180).evaluate(), precision);
+};
+const rotateVector = (vec, angle, name) => {
+    //x' = cos(t)*x -sin(t)*y
+    //y' = sin(t)*x + cos(t)*y
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Vector(name, substract(multiply(cos, vec.x), multiply(sin, vec.y)).evaluate().toTree(), add(multiply(sin, vec.x), multiply(cos, vec.y)).evaluate().toTree());
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = rotateVector(vSrc, angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const getHydrated = (identifiers) => {
+    const { triangleIds } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIds);
+    const [point] = triangle.points;
+    const [segment] = triangle.sides;
+    return {
+        triangle,
+        point,
+        segment,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { strNameTriangle } = identifiers;
+    const { point } = getHydrated(identifiers);
+    return `Avec les outils disponibles, construire la médiane de $${strNameTriangle}$ issue de $${point.name}$.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { triangle, point, segment } = getHydrated(identifiers);
+    const ggbAnswer = [
+        ...getStudentGGBCommands(triangle),
+        `M = Midpoint(${segment.pointA.name}, ${segment.pointB.name})`,
+        `lMed = Line(${point.name},M)`,
+        `SetColor(lMed, "${greenMain}")`,
+    ];
+    return ggbAnswer;
+};
+const getHint = (identifiers) => {
+    const { point } = getHydrated(identifiers);
+    return `La médiane issue du point $${point.name}$ est la droite qui relie $${point.name}$ avec le milieu du côté opposé à $${point.name}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { point, segment } = getHydrated(identifiers);
+    return `On sélectionne l'outil Milieu dans Geogebra puis on clique sur le segment $${segment.toTex()}$. On sélectionne ensuite l'outil Droite pour relier le milieu qui vient d'être créé avec le point $${point.name}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: [...getGGBAnswer(identifiers)],
+        hideGrid: true,
+        hideAxes: true,
+        isGridSimple: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({ coords: [-10, 10, -10, 10] });
+};
+const getStudentGGBCommands = (triangle) => {
+    const [point] = triangle.points;
+    const [segment] = triangle.sides;
+    return [
+        ...triangle.points.flatMap((point) => point.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: true,
+            showLabel: true,
+        })),
+        ...triangle.sides.flatMap((segment) => segment.toGGBCommands(false, { isFixed: true, isSelectionnable: true })),
+        //force display of right angle (if needed)
+        ...(() => {
+            const [angleRightAngle] = triangle.angles.filter((angle) => Math.abs(angle.evaluate(false) - 90) < 0.3);
+            if (angleRightAngle !== undefined) {
+                if (angleRightAngle.evaluate() === 90) {
+                    //display is already ok
+                    return [
+                        ...angleRightAngle.toCommands({
+                            pointsAreNotBuilt: false,
+                            showValue: false,
+                        }),
+                    ];
+                }
+                else {
+                    if (angleRightAngle !== undefined) {
+                        const [pointRightAngle1, pointRightAngle2, pointRightAngle3] = angleRightAngle.points;
+                        return [
+                            `lPer = PerpendicularLine(${pointRightAngle2.name},${segment.ggbName})`,
+                            `SetVisibleInView(lPer, 1, false)`,
+                            `lPer2 = PerpendicularLine(${point.name},lPer)`,
+                            `SetVisibleInView(lPer2, 1, false)`,
+                            `prjct = Intersect(lPer, lPer2)`,
+                            `SetVisibleInView(prjct, 1, false)`,
+                            //horror?
+                            `ang1 = Angle(${pointRightAngle1.name},${pointRightAngle2.name}, prjct)`,
+                            `ShowLabel(ang1, false)`,
+                            `ang2 = Angle(prjct,${pointRightAngle2.name},${pointRightAngle1.name})`,
+                            `ShowLabel(ang2, false)`,
+                            `SetVisibleInView(ang1, 1, ang1<ang2)`,
+                            `SetVisibleInView(ang2, 1, ang2<ang1)`,
+                            `ang3 = Angle(${pointRightAngle3.name},${pointRightAngle2.name}, prjct)`,
+                            `ShowLabel(ang3, false)`,
+                            `ang4 = Angle(prjct,${pointRightAngle2.name},${pointRightAngle3.name})`,
+                            `ShowLabel(ang4, false)`,
+                            `SetVisibleInView(ang3, 1, ang3<ang4)`,
+                            `SetVisibleInView(ang4, 1, ang4<ang3)`,
+                        ];
+                    }
+                    else {
+                        return [];
+                    }
+                }
+            }
+            else {
+                return [];
+            }
+        })(),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { triangle } = getHydrated(identifiers);
+    const commands = getStudentGGBCommands(triangle);
+    const studentGGB = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        hideAxes: true,
+        customToolBar: toolBarConstructor({
+            orthogonal: true,
+            midpoint: true,
+            join: true,
+        }),
+    });
+    return studentGGB.getOptions({
+        coords: studentGGB.getCoordsForPoints([...triangle.points]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { triangle, point, segment } = getHydrated(identifiers);
+    try {
+        const commands = ans;
+        const ggbParser = new GeogebraParser(commands);
+        const objectDict = ggbParser.objectDict();
+        const arrStrOrthogonalLine = Object.entries(objectDict)
+            .filter(([_, strObj]) => strObj.startsWith("OrthogonalLine"))
+            .map(([_, strObj]) => strObj);
+        //required: no orthogonal line
+        if (arrStrOrthogonalLine.length > 0) {
+            return false;
+        }
+        const arrStrLine = Object.entries(objectDict)
+            .filter(([_, strObj]) => strObj.startsWith("Line"))
+            .map(([_, strObj]) => strObj);
+        //required: only one line
+        if (arrStrLine.length !== 1) {
+            return false;
+        }
+        const [strLine] = arrStrLine;
+        const [namePoint1Ans, namePoint2Ans] = GeogebraParser.pointNamesForLineObj(strLine);
+        const [point1Ans, point2Ans] = [namePoint1Ans, namePoint2Ans].map((namePoint) => {
+            const pointCoords = ggbParser.pointCoords(namePoint);
+            if (pointCoords) {
+                const point = PointConstructor.fromCoords(pointCoords, namePoint);
+                return point;
+            }
+            else {
+                const [point] = triangle.points.filter((point) => point.name === namePoint);
+                return point;
+            }
+        });
+        const midPoint = segment.getMidpoint();
+        return [
+            [point1Ans, point2Ans],
+            [point2Ans, point1Ans],
+        ].some(([point1Ans, point2Ans]) => {
+            const isPoint = () => point1Ans.distanceTo(point) < 0.1;
+            const isMidPoint = () => point2Ans.distanceTo(midPoint) < 0.1;
+            return isPoint() && isMidPoint();
+        });
+    }
+    catch (e) {
+        console.log(e);
+        handleVEAError(e);
+        return false;
+    }
+};
+const getTraceMedianInTriangleQuestion = () => {
+    const [nameA, nameB, nameC] = shuffle(["A", "B", "C"]);
+    const [pointARaw, pointBRaw, pointCRaw] = (() => {
+        const a = -randint(4, 12);
+        const b = +randint(4, 12);
+        const pointA = PointConstructor.fromCoords([a, 0], nameA);
+        const pointB = PointConstructor.fromCoords([b, 0], nameB);
+        const rand = randint(0, 3);
+        switch (rand) {
+            case 0: {
+                const c = randint(a + 1, b);
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            case 1: {
+                const isLeftSide = coinFlip();
+                const c = isLeftSide ? a : b;
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            case 2: {
+                const isLeftSide = coinFlip();
+                const c = isLeftSide ? a - randint(2, 8) : b + randint(2, 8);
+                const h = +randint(4, 12);
+                const pointC = PointConstructor.fromCoords([c, h], nameC);
+                return [pointA, pointB, pointC];
+            }
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    })();
+    const [pointA, pointB, pointC] = (() => {
+        const pointOrigin = new Point("O", 0, 0);
+        const angleInDegrees = randint(0, 360);
+        return [pointARaw, pointBRaw, pointCRaw].map((point) => rotatePoint(point, degreesToRadians(angleInDegrees, 5), pointOrigin, point.name));
+    })();
+    const triangle = new Triangle([pointC, pointB, pointA]);
+    const strNameTriangle = shuffle(triangle.name.split("")).join("");
+    const identifiers = {
+        triangleIds: triangle.toIdentifiers(),
+        strNameTriangle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const traceMedianInTriangle = {
+    id: "traceMedianInTriangle",
+    connector: "=",
+    label: "Tracer une médiane d'un triangle",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getTraceMedianInTriangleQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getStudentGGBOptions,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/constructions/index.d.ts

@@ -6,4 +6,5 @@ export * from "./drawAVectorInGGB.js";
 export * from "./placePointFromPointAndVector.js";
 export * from "./linearVectorCombinationFromGraph.js";
 export * from "./traceVectorCL.js";
+export * from "./traceVectorSumFromVecs.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/vectors/constructions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/geometry/vectors/constructions/index.js

@@ -6,3 +6,4 @@ export * from "./drawAVectorInGGB.js";
 export * from "./placePointFromPointAndVector.js";
 export * from "./linearVectorCombinationFromGraph.js";
 export * from "./traceVectorCL.js";
+export * from "./traceVectorSumFromVecs.js";

package/lib/exercises/math/geometry/vectors/constructions/traceVectorSumFromVecs.d.ts

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

package/lib/exercises/math/geometry/vectors/constructions/traceVectorSumFromVecs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorSumFromVecs.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorSumFromVecs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AAqMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}