math-exercises 3.0.20 → 3.0.21

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -0,0 +1,187 @@
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   GGBVEA,
+//   addValidProp,
+//   shuffleProps,
+//   tryToAddWrongProp,
+//   GetAnswer,
+//   GetHint,
+//   GetCorrection,
+//   GetInstruction,
+//   GetKeys,
+//   GetGGBOptions,
+//   GetStudentGGBOptions,
+//   GetGGBAnswer,
+// } from "../../../../exercises/exercise.js";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+// import { Line, LineConstructor } from "../../../../math/geometry/line.js";
+// import {
+//   Point,
+//   PointConstructor,
+//   PointIdentifiers,
+// } from "../../../../math/geometry/point.js";
+// import {
+//   Segment,
+//   SegmentConstructor,
+//   SegmentIdentifiers,
+// } from "../../../../math/geometry/segment.js";
+// import {
+//   Triangle,
+//   TriangleConstructor,
+//   TriangleIdentifiers,
+// } from "../../../../math/geometry/triangle.js";
+// import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+export {};
+// type Identifiers = {
+//   isAskingLength: boolean;
+//   triangleIdentifiers: TriangleIdentifiers;
+//   extraPoints: PointIdentifiers[];
+//   isSegmentHeight: boolean; // si hauteur alors configuration pythagore
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer, "raw");
+//   tryToAddWrongProp(propositions, "Le théorème de Thalès", "raw");
+//   tryToAddWrongProp(propositions, "La réciproque du théorème de Thalès", "raw");
+//   tryToAddWrongProp(propositions, "Le théorème de Pythagore", "raw");
+//   tryToAddWrongProp(
+//     propositions,
+//     "La réciproque du théorème de Pythagore",
+//     "raw",
+//   );
+//   return shuffleProps(propositions, n);
+// };
+// const getAnswer: GetAnswer<Identifiers> = (identifiers) => {
+//   const { isAskingLength, triangleIdentifiers, isSegmentHeight } = identifiers;
+//   return isSegmentHeight
+//     ? isAskingLength
+//       ? "Le théorème de Pythagore"
+//       : "La réciproque du théorème de Pythagore"
+//     : isAskingLength
+//     ? "Le théorème de Thalès"
+//     : "La réciproque du théorème de Thalès";
+// };
+// const getInstruction: GetInstruction<Identifiers> = (identifiers) => {
+//   const { isAskingLength, triangleIdentifiers, isSegmentHeight, extraPoints } = identifiers;
+//   const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+//   const points = extraPoints.map((e) => PointConstructor.fromIdentifiers(e));
+//   let instruction = ``;
+//   if(isSegmentHeight){
+//     if(isAskingLength){
+//       instruction = `calculer la longueur $${triangle.sides[2].toInsideName()}$`
+//     } else {
+//       instruction = `prouver que le triangle $${triangle.points[1].name}${triangle.points[2].name}${points[0].name}$ est rectangle en $${points[0].name}$`
+//     }
+//   } else {
+//     if(isAskingLength){
+//       instruction = `calculer la longueur $${points[0].name}${points[1].name}$`
+//     } else {
+//       instruction = `prouver que les droites $${}$ et $${}$ sont parallèles`
+//     }
+//   }
+//   return `On donne la figure ci-dessous.
+// Pour ${instruction}, il faut utiliser... `;
+// };
+// // const getHint: GetHint<Identifiers> = (identifiers) => {};
+// // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+// const getGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
+//   const { isAskingLength, triangleIdentifiers, extraPoints, isSegmentHeight } =
+//     identifiers;
+//   const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+//   const points = extraPoints.map((e) => PointConstructor.fromIdentifiers(e));
+//   const commands = [
+//     ...triangle.commands,
+//     ...points.flatMap((p) => p.toGGBCommand()),
+//   ];
+//   if (isSegmentHeight) {
+//     commands.push(
+//       ...new Segment(triangle.points[1], points[0]).toGGBCommands(false),
+//     );
+//   } else {
+//     commands.push(...new Segment(points[0], points[1]).toGGBCommands(false));
+//   }
+//   const ggb = new GeogebraConstructor({
+//     commands,
+//     hideAxes: true,
+//     hideGrid: true,
+//   });
+//   return ggb.getOptions({
+//     coords: triangle.generateCoords(),
+//   });
+// };
+// const getKeys: GetKeys<Identifiers> = (identifiers) => {
+//   return [];
+// };
+// const isAnswerValid: VEA<Identifiers> = (ans, { answer }) => {
+//   throw Error("VEA not implemented");
+// };
+// const getPythagoreOrThalesQuestion: QuestionGenerator<Identifiers> = (opts) => {
+//   // const triangle = TriangleConstructor.randomNiceSides({});
+//   const A = new Point("A", 0, 0);
+//   const B = new Point("B", 4, 4);
+//   const C = new Point("C", 8, 0);
+//   const triangle = new Triangle([A, B, C]);
+//   const isSegmentHeight = coinFlip();
+//   const isAskingLength = coinFlip();
+//   let extraPoints: PointIdentifiers[] = [];
+//   if (isSegmentHeight) {
+//     const baseLine = LineConstructor.fromSegment(triangle.sides[1]);
+//     const height = baseLine.getPerpendicular(triangle.points[1]);
+//     extraPoints.push(height.intersect(baseLine, "H").toIdentifiers());
+//   } else {
+//     const baseLine = LineConstructor.fromSegment(triangle.sides[1]);
+//     const D = PointConstructor.onSegment(triangle.sides[2], "D", {
+//       spacing: 0.3,
+//     });
+//     const para = baseLine.getParallele(D);
+//     const E = para.intersect(
+//       LineConstructor.fromSegment(triangle.sides[0]),
+//       "E",
+//     );
+//     extraPoints.push(D.toIdentifiers());
+//     extraPoints.push(E.toIdentifiers());
+//   }
+//   const identifiers: Identifiers = {
+//     triangleIdentifiers: triangle.toIdentifiers(),
+//     // segmentIdentifiers: triangle.sides[0].toIdentifiers(),
+//     extraPoints,
+//     isAskingLength,
+//     isSegmentHeight,
+//   };
+//   const question: Question<Identifiers> = {
+//     answer: getAnswer(identifiers),
+//     instruction: getInstruction(identifiers),
+//     keys: getKeys(identifiers),
+//     answerFormat: "raw",
+//     identifiers,
+//     // hint: getHint(identifiers),
+//     // correction: getCorrection(identifiers),
+//     ggbOptions: getGGBOptions(identifiers),
+//   };
+//   return question;
+// };
+// export const pythagoreOrThales: Exercise<Identifiers> = {
+//   id: "pythagoreOrThales",
+//   label: "",
+//   isSingleStep: true,
+//   generator: (nb, opts) =>
+//     getDistinctQuestions(() => getPythagoreOrThalesQuestion(opts), nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   subject: "Mathématiques",
+//   // getHint,
+//   // getCorrection,
+//   getInstruction,
+//   getAnswer,
+//   getGGBOptions,
+//   hasGeogebra: true,
+//   answerType: "QCU",
+// };

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

@@ -11,4 +11,5 @@ export * from "./shapes/index.js";
 export * from "./parametric/index.js";
 export * from "./quadrilaterals/index.js";
 export * from "./angles/index.js";
+export * from "./lines/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAElC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AAEnC,cAAc,mCAAmC,CAAC;AAClD,cAAc,mBAAmB,CAAC;AAElC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

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

@@ -9,7 +9,8 @@ export * from "./volumes/index.js";
 // export * from "./triangles.js";
 export * from "./euclidianConstructions/index.js";
 export * from "./shapes/index.js";
-// export * from "./euclidian.js";
+// export * from "./euclidian/index.js";
 export * from "./parametric/index.js";
 export * from "./quadrilaterals/index.js";
 export * from "./angles/index.js";
+export * from "./lines/index.js";

package/lib/exercises/math/geometry/lines/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./linesRelativePositions.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/lines/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/geometry/lines/index.js

@@ -0,0 +1 @@
+export * from "./linesRelativePositions.js";

package/lib/exercises/math/geometry/lines/linesRelativePositions.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    lines: {
+        pointA: number[];
+        pointB: number[];
+        label: string;
+    }[];
+    coupleAsked: number;
+};
+export declare const linesRelativePositions: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=linesRelativePositions.d.ts.map

package/lib/exercises/math/geometry/lines/linesRelativePositions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linesRelativePositions.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/lines/linesRelativePositions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAE/D,WAAW,EAAE,MAAM,CAAC;CAKrB,CAAC;AA+IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

package/lib/exercises/math/geometry/lines/linesRelativePositions.js

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Line } from "../../../../math/geometry/line.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+const getPropositions = (n, { answer, coupleAsked, lines }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "perpendiculaires", "raw");
+    tryToAddWrongProp(propositions, "parallèles", "raw");
+    tryToAddWrongProp(propositions, "sécantes mais non perpendiculaires", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { coupleAsked, lines } = identifiers;
+    switch (coupleAsked) {
+        case 0:
+            return `perpendiculaires`;
+        case 1:
+            return "parallèles";
+        case 2:
+        case 3:
+        default:
+            return "sécantes mais non perpendiculaires";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { coupleAsked, lines } = identifiers;
+    const askedLines = coupleAsked === 0
+        ? [lines[0], lines[4]]
+        : coupleAsked === 3
+            ? [lines[2], lines[4]]
+            : [lines[coupleAsked], lines[coupleAsked + 1]];
+    return `On donne la figure ci-dessous. 
+  
+$${askedLines[0].label}$ et $${askedLines[1].label}$ semblent...`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const lines = identifiers.lines.map((d, i) => new Line(new Point(`A_${d.label}`, d.pointA[0], d.pointA[1]), new Point(`B_${d.label}`, d.pointB[0], d.pointB[1]), d.label));
+    const ggb = new GeogebraConstructor({
+        commands: lines.flatMap((l) => l.toGGBCommands(false, { showLabel: true, color: "black" })),
+        forbidShiftDragZoom: true,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-3, 5, -2, 6],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getLinesRelativePositionsQuestion = (opts) => {
+    // const permut = shuffle([1, 2, 3, 4, 5]);
+    const permut = [1, 2, 3, 4, 5];
+    // const v2 = VectorConstructor.random("v2", false);
+    // const v3 = v2;
+    // let v1: Vector;
+    // let v4: Vector;
+    // let v5: Vector;
+    // do {
+    //   v1 = VectorConstructor.random("v1", false);
+    // } while (Math.abs(v1.determinant(v2).evaluate()) < 2);
+    // v5 = v1.getOrthogonal();
+    // // do {
+    // v4 = VectorConstructor.random("v4", false);
+    //   console.log("iter");
+    // } while (
+    //   Math.abs(v4.determinant(v3).evaluate()) > 10 ||
+    //   Math.abs(v4.determinant(v3).evaluate()) < 1
+    // );
+    // console.log("det", Math.abs(v4.determinant(v3).evaluate()));
+    // let pointA = [randint(-9, 10), randint(-9, 10)];
+    // let B = v1.getEndPoint(new Point("A", pointA[0], pointA[1]));
+    // let pointB = [B.x.evaluate(), B.y.evaluate()];
+    const d1 = {
+        label: `d_{${permut[0]}}`,
+        pointA: [-2, 5],
+        pointB: [-1, 4],
+    };
+    const d2 = {
+        label: `d_{${permut[1]}}`,
+        pointA: [1, 6],
+        pointB: [0, 3],
+    };
+    const d3 = {
+        label: `d_{${permut[2]}}`,
+        pointA: [2, 5],
+        pointB: [1, 2],
+    };
+    const d4 = {
+        label: `d_{${permut[3]}}`,
+        pointA: [6, 7],
+        pointB: [3, 1],
+    };
+    const d5 = {
+        label: `d_{${permut[4]}}`,
+        pointA: [0, 1],
+        pointB: [1, 2],
+    };
+    const lines = [d1, d2, d3, d4, d5];
+    const coupleAsked = randint(0, 4);
+    const identifiers = { lines, coupleAsked };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const linesRelativePositions = {
+    id: "linesRelativePositions",
+    label: "Déterminer la position relative de deux droites",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getLinesRelativePositionsQuestion(opts), nb, 4),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    maxAllowedQuestions: 4,
+    answerType: "QCU",
+};

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

@@ -1,4 +1,5 @@
 export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
+export * from "./scalarProductOrthoInSquare.js";
 export * from "./scalarProductViaNorms.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AAGzC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AAEzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC"}

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

@@ -1,4 +1,4 @@
 export * from "./scalarProductViaCoords.js";
 export * from "./scalarProductViaCos.js";
-// export * from "./scalarProductOrthoInSquare.js";
+export * from "./scalarProductOrthoInSquare.js";
 export * from "./scalarProductViaNorms.js";

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.d.ts

@@ -1,8 +1,12 @@
 import { Exercise } from "../../../../../exercises/exercise.js";
 type Identifiers = {
     c: number;
-    vector1Name: string;
-    vector2Name: string;
+    vec1Name: string;
+    vec2Name: string;
+    areSameDirection: boolean;
+    vec1ProjLength: number;
+    vec2ProjLength: number;
+    rotationAngle: number;
 };
 export declare const scalarProductOrthoInSquare: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4HF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}
+{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAgKF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.js

@@ -1,57 +1,75 @@
-import { addValidProp, shuffleProps, } from "../../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../../exercises/vea/rationalVEA.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../../math/geometry/point.js";
-import { Rational } from "../../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../../utils/alea/random.js";
-const getPoints = (c) => {
-    const midC = new Rational(c, 2).simplify().toTree();
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPoints = (identifiers) => {
+    const { c, rotationAngle } = identifiers;
+    // const midC = new Rational(c, 2).simplify().toTree();
+    const midC = c / 2;
+    const oppMidC = -c / 2;
     const zeroTree = (0).toTree();
-    const cTree = c.toTree();
+    const center = new Point("O", zeroTree, zeroTree);
     const points = [
-        { name: "A", x: zeroTree, y: zeroTree },
-        { name: "I", x: midC, y: zeroTree },
-        { name: "B", x: cTree, y: zeroTree },
-        { name: "J", x: cTree, y: midC },
-        { name: "C", x: cTree, y: cTree },
-        { name: "K", x: midC, y: cTree },
-        { name: "D", x: zeroTree, y: cTree },
-        { name: "L", x: zeroTree, y: midC },
-        { name: "O", x: midC, y: midC },
-    ];
-    return points;
+        { name: "A", x: oppMidC, y: oppMidC },
+        { name: "I", x: zeroTree, y: oppMidC },
+        { name: "B", x: midC, y: oppMidC },
+        { name: "J", x: midC, y: zeroTree },
+        { name: "C", x: midC, y: midC },
+        { name: "K", x: zeroTree, y: midC },
+        { name: "D", x: oppMidC, y: midC },
+        { name: "L", x: oppMidC, y: zeroTree },
+    ].map((d) => new Point(d.name, d.x, d.y).rotate(rotationAngle, center));
+    return [...points, center];
 };
 const buildFromIdentifiers = (identifiers) => { };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const wrongAnswers = [
+        c.toTree(),
+        frac(c, 2),
+        (c * c).toTree(),
+        frac(c ** 2, 4),
+    ];
     while (propositions.length < n) {
-        throw Error("QCM not implemented");
+        let wrongItem = random(wrongAnswers);
+        if (coinFlip())
+            wrongItem = opposite(wrongItem);
+        tryToAddWrongProp(propositions, wrongItem.simplify().toTex());
     }
     return shuffleProps(propositions, n);
 };
 const getAnswer = (identifiers) => {
-    return Math.random() + "";
+    const { areSameDirection, c, vec1Name, vec1ProjLength, vec2Name, vec2ProjLength, } = identifiers;
+    const frac1 = new NumberNode(vec1ProjLength).toFrac();
+    const frac2 = new NumberNode(vec2ProjLength).toFrac();
+    if (areSameDirection) {
+        return multiply(frac1, frac2).simplify().toTex();
+    }
+    return opposite(multiply(frac1, frac2)).simplify().toTex();
 };
-const getInstruction = ({ c, vector1Name, vector2Name, }) => {
+const getInstruction = ({ c, vec1Name, vec2Name, }) => {
     return `$ABCD$ est un carré de côté $${c}$ et de centre $O$. Les points $I$,$J$,$K$ et $L$ sont les milieux respectifs des segments $[AB]$, $[BC]$, $[CD]$ et $[AD]$. Calculer : 
   
 $$
-\\overrightarrow{${vector1Name}}\\cdot \\overrightarrow{${vector2Name}}
+\\overrightarrow{${vec1Name}}\\cdot \\overrightarrow{${vec2Name}}
 $$`;
 };
-const getHint = (identifiers) => {
-    return "";
-};
-const getCorrection = (identifiers) => {
-    return "";
-};
-const getGGBOptions = ({ c }) => {
-    const points = getPoints(c).map((d) => new Point(d.name, d.x, d.y));
+const getGGBOptions = (identifiers) => {
+    const { c } = identifiers;
+    const points = getPoints(identifiers);
     const ggb = new GeogebraConstructor({
         commands: [
-            ...points.flatMap((p) => p.toGGBCommand()),
+            ...points.flatMap((p) => p.toGGBCommand({ style: 1 })),
             `Polygon(A,B,C,D)`,
             `Segment(A,C)`,
             `Segment(B,D)`,
@@ -60,56 +78,70 @@ const getGGBOptions = ({ c }) => {
         hideGrid: true,
     });
     return ggb.getOptions({
-        coords: [-1, c + 1, -1, c + 1],
+        coords: ggb.getCoordsForPoints(points),
     });
 };
 const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const getScalarProductOrthoInSquareQuestion = () => {
     const c = randint(1, 10);
-    // AB AO
-    // AB AK
-    // AB AJ
-    // AB AC
-    //ou
-    // AI AO
-    // AI AK
-    // AI AC
-    // AI AJ
-    //ou
-    // AB IJ
-    // AB OC
-    // AB LK
-    // AB OJ
-    // AB LO
-    //ou
-    // AI IJ
-    // AI OC
-    // AI LK
-    // AI OJ
-    // AI LO
-    // puis on shuffle dans tous les sens
-    const firstPointIndex = random([0, 2, 4, 6]); //A,B,C,D
-    const isD = firstPointIndex === 6;
-    const delta = isD ? 3 : 2;
-    const secondPointIndex = random([
-        (firstPointIndex + delta) % 8,
-        (firstPointIndex + 1) % 8,
-    ]); //si first=A alors B ou I, idem par translation pour les autres
-    const thirdPointIndex = random([(1 + delta) % 8, (7 + delta * 8) % 8, 8]);
-    const identifiers = { c, vector1Name: "BC", vector2Name: "AC" };
+    // A(B,I) * A(J,C,O,K)
+    // A(D,L) * A(J,C,O,K)
+    //puis on reverse tout possiblement
+    const isFirstVecOnAB = coinFlip();
+    const vecs = {
+        AB: { projLength: c, reps: ["AB", "DC"] },
+        AC: { projLength: c, reps: ["AC"] },
+        AD: { projLength: c, reps: ["AD", "IK", "BC"] },
+        AJ: { projLength: isFirstVecOnAB ? c : c / 2, reps: ["AJ", "LC"] },
+        AO: { projLength: c / 2, reps: ["AO", "LK", "OC", "IJ"] },
+        AK: { projLength: isFirstVecOnAB ? c / 2 : c, reps: ["AK", "IC"] },
+        AI: {
+            projLength: c / 2,
+            reps: ["AI", "IB", "LO", "OJ", "DK", "KC"],
+        },
+        AL: {
+            projLength: c / 2,
+            reps: ["AL", "LD", "IO", "OK", "BJ", "BC"],
+        },
+    };
+    const vec1Choices = random(isFirstVecOnAB ? ["AB", "AI"] : ["AD", "AL"]);
+    const vec2Choices = random(["AJ", "AC", "AO", "AK"]);
+    let vec1 = random(vecs[vec1Choices].reps);
+    let vec2 = random(vecs[vec2Choices].reps);
+    let inversionsCount = 0;
+    if (coinFlip()) {
+        inversionsCount++;
+        vec1 = vec1.split("").reverse().join("");
+    }
+    if (coinFlip()) {
+        inversionsCount++;
+        vec2 = vec2.split("").reverse().join("");
+    }
+    const identifiers = {
+        c,
+        vec1Name: vec1,
+        vec2Name: vec2,
+        areSameDirection: inversionsCount % 2 === 0,
+        vec1ProjLength: vecs[vec1Choices].projLength,
+        vec2ProjLength: vecs[vec2Choices].projLength,
+        rotationAngle: Math.random() * 2 * Math.PI,
+    };
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -126,8 +158,8 @@ export const scalarProductOrthoInSquare = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    getHint,
-    getCorrection,
     getAnswer,
     getGGBOptions,
+    getInstruction,
+    hasGeogebra: true,
 };

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAyCnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;gBAEhB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAcpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAiDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAiBzD"}