math-exercises 3.0.99 → 3.0.100

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

@@ -0,0 +1,110 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.opposite().getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+      
+$$
+\\overrightarrow{${origin}K} = -\\overrightarrow{${vec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceOppositeVectorQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        vectorPointsIndexes = randomMany([0, 1, 2], 2);
+        const vec = VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec.opposite().getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceOppositeVector = {
+    id: "traceOppositeVector",
+    label: "Placer un point $K$ tel que $\\overrightarrow{AK} = -\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceOppositeVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+};
+export declare const traceVectorDifference: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorDifference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorDifference.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AAsJF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}

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

@@ -0,0 +1,123 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { doWhile } from "../../../../../utils/doWhile.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        VectorConstructor.fromPoints(points[identifiers.secondVectorPointsIndexes[0]], points[identifiers.secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0].substract(vecs[1]).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+    
+  $$
+  \\overrightarrow{${origin}K} = \\overrightarrow{${firstVec}} - \\overrightarrow{${secondVec}}
+  $$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorDifferenceQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        firstVectorPointsIndexes = randomMany([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = doWhile(() => randomMany([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .substract(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorDifference = {
+    id: "traceVectorDifference",
+    label: "Placer un point défini par une différence de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorDifferenceQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+    coeff: number;
+};
+export declare const traceVectorMultiple: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorMultiple.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorMultiple.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorMultiple.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+HF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

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

@@ -0,0 +1,115 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { random, randomMany } from "../../../../../utils/alea/random.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.times(identifiers.coeff.toTree()).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+        
+$$
+\\overrightarrow{${origin}K} = ${identifiers.coeff}\\overrightarrow{${vec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorMultipleQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    let coeff = 0;
+    while (true) {
+        points = [];
+        coeff = random([-3, -2, 2, 3]);
+        points.push(...PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        vectorPointsIndexes = randomMany([0, 1, 2], 2);
+        const vec = VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec
+            .times(coeff.toTree())
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+        coeff,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorMultiple = {
+    id: "traceVectorMultiple",
+    label: "Placer un point $M$ tel que $\\overrightarrow{AM} = k\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorMultipleQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+};
+export declare const traceVectorSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorSum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorSum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AAsJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

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

@@ -0,0 +1,123 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { doWhile } from "../../../../../utils/doWhile.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        VectorConstructor.fromPoints(points[identifiers.secondVectorPointsIndexes[0]], points[identifiers.secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0].add(vecs[1]).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+  
+$$
+\\overrightarrow{${origin}K} = \\overrightarrow{${firstVec}} + \\overrightarrow{${secondVec}}
+$$`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorSumQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        firstVectorPointsIndexes = randomMany([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = doWhile(() => randomMany([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .add(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorSum = {
+    id: "traceVectorSum",
+    label: "Placer un point défini par une somme de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorSumQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/geometry/vectors/coordinatesReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/geometry/vectors/coordinatesReading.js

@@ -2,17 +2,24 @@ import { shuffleProps, tryToAddWrongProp, addValidProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Vector } from "../../../../math/geometry/vector.js";
 import { IntegerConstructor } from "../../../../math/numbers/integer/integer.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-const getInstruction = (identifiers) => {
-    return `Lire les coordonnées du vecteur $\\overrightarrow u$ représenté ci-dessous :`;
-};
-const getAnswer = (identifiers) => {
+import { binom, isBinomialCoefficientNode, } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { vectorParser } from "../../../../tree/parsers/vectorParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getVector = (identifiers) => {
     const { xA, xB, yA, yB } = identifiers;
     const xDelta = xB - xA;
     const yDelta = yB - yA;
-    const answer = `\\left(${xDelta};${yDelta}\\right)`;
-    return answer;
+    return new Vector("u", xDelta.toTree(), yDelta.toTree());
+};
+const getInstruction = (identifiers) => {
+    return `Donner les coordonnées du vecteur $\\overrightarrow u$ représenté ci-dessous :`;
+};
+const getAnswer = (identifiers) => {
+    return getVector(identifiers).toBinomCoords().toTex();
 };
 const getGGBOptions = (identifiers) => {
     const { xA, xB, yA, yB } = identifiers;
@@ -34,14 +41,36 @@ const getGGBOptions = (identifiers) => {
         coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
     });
 };
+const getHint = (identifiers) => {
+    const vec = new Vector("u", "x".toTree(), "y".toTree());
+    return `L'abscisse d'un vecteur est le déplacement en abscisse représenté par le vecteur. L'ordonnée est le déplacement en ordonnée représenté par le vecteur. 
+  
+Si un vecteur a pour abscisse $x$ et pour ordonnée $y$, alors on note : 
+
+$$
+${vec.toTexWithBinomCoords()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const vec = getVector(identifiers);
+    return `On lit graphiquement que la flèche représentant $\\overrightarrow{u}$ est un déplacement de $${vec.x.toTex()}$ unité(s) en abscisse, et de $${vec.y.toTex()}$ unité(s) en ordonnée. 
+  
+Les coordonnées du vecteur $\\overrightarrow u$ sont donc : 
+
+$$
+\\overrightarrow{u}${getAnswer(identifiers)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["semicolon", "vectorU"],
+        keys: ["semicolon", "binom"],
         answerFormat: "tex",
         ggbOptions: getGGBOptions(identifiers),
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -57,17 +86,36 @@ const getCoordinatesReadingQuestion = () => {
 const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, `\\left(${xA - xB};${yA - yB}\\right)`);
-    tryToAddWrongProp(propositions, `\\left(${xA + xB};${yA + yB}\\right)`);
-    tryToAddWrongProp(propositions, `\\left(${xA - yA};${xB - yB}\\right)`);
-    tryToAddWrongProp(propositions, `\\left(${yA - xA};${yB - xB}\\right)`);
+    tryToAddWrongProp(propositions, binom(xA - xB, yA - yB).toTex());
+    tryToAddWrongProp(propositions, binom(xA + xB, yA + yB).toTex());
+    tryToAddWrongProp(propositions, binom(xA - yA, xB - yB).toTex());
+    tryToAddWrongProp(propositions, binom(yA - xA, yB - xB).toTex());
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, `\\left(${randint(-10, 10)};${randint(-10, 10)}\\right)`);
+        tryToAddWrongProp(propositions, binom(randint(-10, 10), randint(-10, 10)).toTex());
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
-    return [answer, "\\overrightarrow{u}" + answer].includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    // return [answer, "\\overrightarrow{u}" + answer].includes(ans);
+    try {
+        const solVector = getVector(identifiers);
+        if (ans.includes("binom")) {
+            const parsed = parseAlgebraic(ans);
+            if (!isBinomialCoefficientNode(parsed))
+                return false;
+            const vec = new Vector("u", parsed.leftChild, parsed.rightChild).simplify();
+            return solVector.equals(vec);
+        }
+        else {
+            const vec = vectorParser(ans);
+            if (!vec)
+                return false;
+            return solVector.equals(vec.simplify());
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const coordinatesReading = {
     id: "coordinatesReading",
@@ -82,4 +130,5 @@ export const coordinatesReading = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/vectors/equalCaracteristicFromGraph.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     uPoints: number[][];
     vPoints: number[][];
     isTrue: boolean;
+    sameDirection?: boolean;
+    sameNorm?: boolean;
+    sameSens?: boolean;
 };
 export declare const equalCaracteristicFromGraph: Exercise<Identifiers>;
 export {};