math-exercises 2.2.55 → 2.2.57

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointImageFromTranslation = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const approxEqual_1 = require("../../../../geogebra/parsers/approxEqual");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const random_1 = require("../../../../utils/alea/random");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getInstruction = (identifiers) => {
+    return `Placer l'image du point $${identifiers.startPoint}$ par la translation qui transforme $${identifiers.translationPoints[0]}$ en $${identifiers.translationPoints[1]}$.`;
+};
+const getEndPoint = (identifiers) => {
+    const translationPoints = [
+        point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.translationPoints[0])),
+        point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.translationPoints[1])),
+    ];
+    const vector = vector_1.VectorConstructor.fromPoints(translationPoints[0], translationPoints[1]);
+    const startPoint = point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.startPoint));
+    const end = vector.getEndPoint(startPoint, "M");
+    return end;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getEndPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const end = getEndPoint(identifiers);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({ point: true }),
+        commands: points.flatMap((p) => p.toGGBCommand({
+            size: 3,
+            style: 1,
+        })),
+    });
+    const [endX, endY] = [end.x.evaluate(), end.y.evaluate()];
+    return ggb.getOptions({
+        coords: [
+            Math.min(endX - 2, -7),
+            Math.max(endX + 2, 7),
+            Math.min(endY - 2, -7),
+            Math.max(endY + 2, 7),
+        ],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentAns[0].split("=")[1]);
+    const coordsAns = (0, ggbPointToCoords_1.ggbPointToCoords)(ggbAnswer[0].split("=")[1]);
+    return ((0, approxEqual_1.approxEqual)(coords.x, coordsAns.x, 0.2) &&
+        (0, approxEqual_1.approxEqual)(coords.y, coordsAns.y, 0.2));
+};
+const getPointImageFromTranslationQuestion = () => {
+    const points = [];
+    for (let i = 0; i < 4; i++) {
+        const name = String.fromCharCode(65 + i);
+        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.equals(p2)));
+        points.push(newPoint);
+    }
+    const startPoint = (0, random_1.random)(points).name;
+    const translationPoints = [
+        (0, random_1.random)(points.filter((p) => p.name !== startPoint)).name,
+    ];
+    translationPoints.push((0, random_1.random)(points.filter((p) => p.name !== translationPoints[0])).name);
+    const identifiers = {
+        points: points.map((p) => p.toIdentifiers()),
+        startPoint,
+        translationPoints,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.pointImageFromTranslation = {
+    id: "pointImageFromTranslation",
+    label: "undefined",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointImageFromTranslationQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -1,8 +1,10 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle";
 type Identifiers = {
     sideA: string;
     sideB: string;
     sideC: string;
+    triangleIdentifiers: TriangleIdentifiers;
 };
 export declare const pythagore: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"pythagore.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagore.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgEF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}
+{"version":3,"file":"pythagore.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagore.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAStC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAiEF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pythagore = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const triangles_1 = require("../../../../math/geometry/triangles");
+const triangle_1 = require("../../../../math/geometry/triangle");
 const randint_1 = require("../../../../math/utils/random/randint");
 const lengthNode_1 = require("../../../../tree/nodes/geometry/lengthNode");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
@@ -15,7 +15,7 @@ const getPythagore = () => {
     const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
     for (let i = 0; i < 3; i++)
         vertices.push(String.fromCharCode(code + i));
-    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+    const triangle = triangle_1.TriangleConstructor.createRandomRightTriangle({
         minRapport: 0.7,
         maxRapport: 1.3,
         names: vertices,
@@ -23,6 +23,7 @@ const getPythagore = () => {
     const sideA = triangle.getSideAName();
     const sideB = triangle.getSideBName();
     const sideC = triangle.getSideCName();
+    const triangleIdentifiers = triangle.toIdentifiers();
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands: triangle.generateCommands({}),
         hideAxes: true,
@@ -37,7 +38,7 @@ const getPythagore = () => {
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { sideA, sideB, sideC },
+        identifiers: { sideA, sideB, sideC, triangleIdentifiers },
     };
     return question;
 };

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.d.ts

@@ -1,7 +1,9 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle";
 type Identifiers = {
     square: number;
     sideLengths: number[];
+    triangleIdentifiers: TriangleIdentifiers;
 };
 export declare const pythagoreCalcul: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAmGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAoGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.js

@@ -4,7 +4,7 @@ exports.pythagoreCalcul = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const triangles_1 = require("../../../../math/geometry/triangles");
+const triangle_1 = require("../../../../math/geometry/triangle");
 const real_1 = require("../../../../math/numbers/reals/real");
 const randint_1 = require("../../../../math/utils/random/randint");
 const sqrtNode_1 = require("../../../../tree/nodes/functions/sqrtNode");
@@ -17,7 +17,7 @@ const getPythagoreCalcul = () => {
     const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
     for (let i = 0; i < 3; i++)
         vertices.push(String.fromCharCode(code + i));
-    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+    const triangle = triangle_1.TriangleConstructor.createRandomRightTriangle({
         minRapport: 0.7,
         maxRapport: 1.3,
         names: vertices,
@@ -59,6 +59,7 @@ const getPythagoreCalcul = () => {
         hideAxes: true,
         hideGrid: true,
     });
+    const triangleIdentifiers = triangle.toIdentifiers();
     answer = answer + "";
     const question = {
         instruction: `Dans le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$, on sait que $${sides[randoms[0]]} = ${sideLengths[randoms[0]]}$ et que $${sides[randoms[1]]} = ${sideLengths[randoms[1]]}$. Calculer la longueur exacte $${sides[randoms[2]]}$.`,
@@ -68,7 +69,7 @@ const getPythagoreCalcul = () => {
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { square, sideLengths },
+        identifiers: { square, sideLengths, triangleIdentifiers },
     };
     return question;
 };

package/lib/exercises/math/geometry/shapes/basicShapesNaming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA+FxD,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}
+{"version":3,"file":"basicShapesNaming.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesNaming.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AA8FxD,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/geometry/shapes/basicShapesNaming.js

@@ -42,7 +42,6 @@ const getBasicShapesNamingQuestion = () => {
         hideGrid: true,
     });
     const letters = answer.substring(1, answer.length - 1).split("");
-    // console.log(letters);
     const question = {
         answer,
         instruction: `Comment se nomme la figure suivante ?`,

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AAEzB,cAAc,gBAAgB,CAAC"}

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

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./thales"), exports);
+// export * from "./thalesCalculOld";
 __exportStar(require("./thalesCalcul"), exports);

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

@@ -1,6 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise";
 type Identifiers = {
     vertices: string[];
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+    xC: number;
+    yC: number;
+    factor: number;
 };
 export declare const thales: Exercise<Identifiers>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA2IF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,CAcxC,CAAC"}
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2IF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,CAcxC,CAAC"}

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

@@ -72,7 +72,7 @@ const getThales = () => {
             coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
         }),
         answerFormat: "tex",
-        identifiers: { vertices },
+        identifiers: { vertices, xA, yA, xB, yB, xC, yC, factor },
     };
     return question;
 };

package/lib/exercises/math/geometry/thales/thalesCalcul.d.ts

@@ -1,10 +1,16 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+import { SegmentIdentifiers } from "../../../../math/geometry/segment";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle";
 type Identifiers = {
-    sideLengths: number[];
-    rand: number;
-    rand2: number;
-    isAskingC: boolean;
+    triangleIdentifiers: TriangleIdentifiers;
+    insidePointsIdentifiers: PointIdentifiers[];
+    segmentAsked: SegmentIdentifiers;
+    isPapillon: boolean;
 };
-export declare const thalesCalcul: Exercise<Identifiers>;
+type Options = {
+    configurationType: string;
+};
+export declare const thalesCalcul: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=thalesCalcul.d.ts.map

package/lib/exercises/math/geometry/thales/thalesCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAmLF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAqBT,MAAM,0BAA0B,CAAC;AASlC,OAAO,EAAoB,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAC/E,OAAO,EAGL,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,uBAAuB,EAAE,gBAAgB,EAAE,CAAC;IAC5C,YAAY,EAAE,kBAAkB,CAAC;IACjC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAsKF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAiEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBvD,CAAC"}

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -3,149 +3,197 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.thalesCalcul = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const numberVEA_1 = require("../../../../exercises/vea/numberVEA");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const rational_1 = require("../../../../math/numbers/rationals/rational");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const segment_1 = require("../../../../math/geometry/segment");
+const triangle_1 = require("../../../../math/geometry/triangle");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
 const randint_1 = require("../../../../math/utils/random/randint");
+const round_1 = require("../../../../math/utils/round");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
-const shuffle_1 = require("../../../../utils/alea/shuffle");
-const getThales = () => {
-    const vertices = [];
-    const code = 65 + (0, randint_1.randint)(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
-    for (let i = 0; i < 5; i++)
-        vertices.push(String.fromCharCode(code + i));
-    const [xA, yA] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
-    let xB, yB, xC, yC;
-    let d1, d2, d3; // distance entre le point A et B
-    let theta = 0; // angle entre AB et AC
-    do {
-        [xB, yB, xC, yC] = [
-            (0, randint_1.randint)(-10, 11),
-            (0, randint_1.randint)(-10, 11),
-            (0, randint_1.randint)(-10, 11),
-            (0, randint_1.randint)(-10, 11),
-        ];
-        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
-        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
-        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
-    } while (!theta ||
-        theta < 0.35 ||
-        theta > 2.1 ||
-        d1 / d2 > 1.3 ||
-        d1 / d2 < 0.7);
-    d3 = Math.sqrt(d1 ** 2 + d2 ** 2 - 2 * d1 * d2 * Math.cos(theta)); // Calculer la distance entre C et B
-    // CB² = AB² * AC² - 2*AB*AC*cos(theta)  : pythagore généralisé
-    const factor = (0, randint_1.randint)(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
-    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
-    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
-    const xMin = Math.min(xA, xB, xC, xD, xE);
-    const xMax = Math.max(xA, xB, xC, xD, xE);
-    const yMin = Math.min(yA, yB, yC, yD, yE);
-    const yMax = Math.max(yA, yB, yC, yD, yE);
-    // AB AC BC AD AE
-    const sides = [
-        `${vertices[0]}${vertices[1]}`,
-        `${vertices[0]}${vertices[3]}`,
-        `${vertices[0]}${vertices[2]}`,
-        `${vertices[0]}${vertices[4]}`,
-        `${vertices[1]}${vertices[2]}`,
-        `${vertices[3]}${vertices[4]}`,
+const random_1 = require("../../../../utils/alea/random");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(3, 20, 1).frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const triangle = triangle_1.TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const pointD = point_1.PointConstructor.fromIdentifiers(identifiers.insidePointsIdentifiers[0]);
+    const pointE = point_1.PointConstructor.fromIdentifiers(identifiers.insidePointsIdentifiers[1]);
+    //order is important
+    const subTriangle = new triangle_1.Triangle(pointD, triangle.vertexB, pointE);
+    const segmentAskedName = segment_1.SegmentConstructor.fromIdentifiers(identifiers.segmentAsked).toInsideName();
+    const lengths = [
+        ...triangle.getSegments().map((s) => {
+            return {
+                name: s.toInsideName(),
+                length: (0, round_1.round)(s.getLength(), 1),
+            };
+        }),
+        ...subTriangle.getSegments().map((s) => {
+            return {
+                name: s.toInsideName(),
+                length: (0, round_1.round)(s.getLength(), 1),
+            };
+        }),
     ];
-    // round pour avoir des valeurs dans N tout en gardant les proportions pour que ça soit cohérent. sides[i] a pour longueur sideLengths[i]
-    const sideLengths = [d1, factor * d1, d2, factor * d2, d3, factor * d3].map((el) => Math.round(Math.abs(el)));
-    const rand = (0, randint_1.randint)(0, 3);
-    let rand2 = (0, randint_1.randint)(0, 3, [rand]);
-    if (sideLengths[2 * rand] === sideLengths[2 * rand2])
-        rand2 = (0, randint_1.randint)(0, 3, [rand, rand2]); // condition pour pas prendre 2 longueurs identiques
-    let instruction = `Dans la figure ci-dessous, on a $(${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})$, `;
-    let statement;
-    let startStatement;
-    const isAskingC = (0, coinFlip_1.coinFlip)();
-    if (isAskingC) {
-        // a/b = c/d on cherche c
-        instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${sides[2 * rand + 1]} = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2]} = ${sideLengths[2 * rand2]}$. Déterminer $${sides[2 * rand2 + 1]}$.`;
-        startStatement = `${sides[2 * rand2 + 1]}`;
-        statement = new rational_1.Rational(sideLengths[2 * rand2] * sideLengths[2 * rand + 1], sideLengths[2 * rand])
-            .simplify()
-            .toTree();
+    const askedIndex = lengths.findIndex((l) => l.name === segmentAskedName);
+    const otherIndex = (0, randint_1.randint)(0, 3, [askedIndex]);
+    const ratio = (0, fractionNode_1.frac)(lengths[otherIndex].length, lengths[otherIndex + 3].length);
+    if (askedIndex > 2) {
+        return (0, round_1.round)((0, fractionNode_1.frac)(lengths[askedIndex - 3].length, ratio).evaluate(), 1).frenchify();
     }
     else {
-        // a/b = c/d on cherche d
-        instruction += `$${sides[2 * rand]} = ${sideLengths[2 * rand]}$, $${sides[2 * rand + 1]} = ${sideLengths[2 * rand + 1]}$, $${sides[2 * rand2 + 1]} = ${sideLengths[2 * rand2 + 1]}$. Déterminer $${sides[2 * rand2]}$.`;
-        startStatement = `${sides[2 * rand2]}`;
-        statement = new rational_1.Rational(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand], sideLengths[2 * rand + 1])
-            .simplify()
-            .toTree();
+        return (0, round_1.round)((0, multiplyNode_1.multiply)(ratio, lengths[askedIndex + 3].length).evaluate(), 1).frenchify();
     }
+};
+const getInstruction = (identifiers) => {
+    const triangle = triangle_1.TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const pointD = point_1.PointConstructor.fromIdentifiers(identifiers.insidePointsIdentifiers[0]);
+    const pointE = point_1.PointConstructor.fromIdentifiers(identifiers.insidePointsIdentifiers[1]);
+    const subTriangle = new triangle_1.Triangle(pointD, triangle.vertexB, pointE);
+    const oppositeSegment = triangle.getSideBName();
+    const insideSegmentName = identifiers.insidePointsIdentifiers[0].name +
+        identifiers.insidePointsIdentifiers[1].name;
+    const segmentAskedName = segment_1.SegmentConstructor.fromIdentifiers(identifiers.segmentAsked).toInsideName();
+    const lengths = [
+        ...triangle.getSegments().map((s) => {
+            return {
+                name: s.toInsideName(),
+                length: (0, round_1.round)(s.getLength(), 1).frenchify(),
+            };
+        }),
+        ...subTriangle.getSegments().map((s) => {
+            return {
+                name: s.toInsideName(),
+                length: (0, round_1.round)(s.getLength(), 1).frenchify(),
+            };
+        }),
+    ];
+    return `Dans le triangle $${triangle.getTriangleName()}$ ci-dessous, les droites $\\left(${insideSegmentName}\\right)$ et $\\left(${oppositeSegment}\\right)$ sont parallèles.
+  
+On sait de plus que : ${lengths
+        .filter((e) => e.name !== segmentAskedName)
+        .map((e) => `$${e.name}=${e.length}$`)
+        .join(" , ")}.
+
+Calculer $${segmentAskedName}$ (arrondir aux dixième).`;
+};
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+const getGGBOptions = (identifiers) => {
+    const triangle = triangle_1.TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const points = identifiers.insidePointsIdentifiers.map((d) => point_1.PointConstructor.fromIdentifiers(d));
+    const subTriangle = new triangle_1.Triangle(points[0], triangle.vertexB, points[1]);
+    const seg = new segment_1.Segment(points[0], points[1]);
     const commands = [
-        `${vertices[0]} = Point({${xA}, ${yA}})`,
-        `${vertices[1]} = Point({${xB}, ${yB}})`,
-        `${vertices[2]} = Point({${xC}, ${yC}})`,
-        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
-        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
-        `l = Segment(${vertices[0]}, ${vertices[1]})`,
-        `i = Segment(${vertices[0]}, ${vertices[2]})`,
-        `j = Segment(${vertices[1]}, ${vertices[2]})`,
-        `k = Segment(${vertices[3]}, ${vertices[4]})`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
-        `ShowLabel(${vertices[0]}, true)`,
-        `ShowLabel(${vertices[1]}, true)`,
-        `ShowLabel(${vertices[2]}, true)`,
-        `ShowLabel(${vertices[3]}, true)`,
-        `ShowLabel(${vertices[4]}, true)`,
+        ...triangle.generateCommands({}),
+        ...points.flatMap((p) => p.toGGBCommand({ style: 0, color: "#444444", size: 4 })),
+        ...seg.toGGBCommands(false),
     ];
+    if (identifiers.isPapillon) {
+        commands.push(...new segment_1.Segment(points[0], triangle.vertexB).toGGBCommands(false));
+        commands.push(...new segment_1.Segment(points[1], triangle.vertexB).toGGBCommands(false));
+    }
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const answer = statement.toTex();
+    let coords = triangle.generateCoords();
+    if (identifiers.isPapillon) {
+        const subCoords = subTriangle.generateCoords();
+        coords = [
+            Math.min(subCoords[0], coords[0]),
+            Math.max(subCoords[1], coords[1]),
+            Math.min(subCoords[2], coords[2]),
+            Math.max(subCoords[3], coords[3]),
+        ];
+    }
+    return ggb.getOptions({
+        coords: coords,
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return (0, numberVEA_1.numberVEA)(ans, answer);
+};
+const options = [
+    {
+        id: "configurationType",
+        label: "Types de figure",
+        defaultValue: "Toutes",
+        values: ["Toutes", "Uniquement papillon", "Uniquement non papillon"],
+        target: exercise_1.GeneratorOptionTarget.generation,
+        type: exercise_1.GeneratorOptionType.select,
+    },
+];
+const getThalesFindSideQuestion = (opts) => {
+    const summitNames = triangle_1.TriangleConstructor.randomName();
+    const triangle = triangle_1.TriangleConstructor.createRandomTriangle({
+        names: summitNames,
+    });
+    const isPapillon = !opts || opts?.configurationType === "Toutes"
+        ? (0, coinFlip_1.coinFlip)()
+        : opts.configurationType === "Uniquement papillon"
+            ? true
+            : false;
+    const pointD = point_1.PointConstructor.onSegment(triangle.vertexA, triangle.vertexB, (0, randomLetter_1.randomLetter)(true, summitNames), isPapillon ? { coefficient: (0, randfloat_1.randfloat)(1.2, 1.8) } : { spacing: 0.2 });
+    const line = new line_1.Line(triangle.vertexA, triangle.vertexC);
+    const parallel = line.getParallele(pointD);
+    const intersectLine = new line_1.Line(triangle.vertexB, triangle.vertexC);
+    const pointE = parallel.intersect(intersectLine, (0, randomLetter_1.randomLetter)(true, [...summitNames, pointD.name]));
+    const subTriangle = new triangle_1.Triangle(pointD, triangle.vertexB, pointE);
+    const segmentAsked = (0, random_1.random)([
+        ...triangle.getSegments(),
+        ...subTriangle.getSegments(),
+    ]);
+    const identifiers = {
+        triangleIdentifiers: triangle.toIdentifiers(),
+        insidePointsIdentifiers: [pointD.toIdentifiers(), pointE.toIdentifiers()],
+        segmentAsked: segmentAsked.toIdentifiers(),
+        isPapillon,
+    };
     const question = {
-        instruction,
-        startStatement,
-        answer,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
         answerFormat: "tex",
-        identifiers: { isAskingC, rand, rand2, sideLengths },
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational((0, randint_1.randint)(2, 30), (0, randint_1.randint)(2, 30)).simplify().toTree().toTex());
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-const isAnswerValid = (ans, { isAskingC, rand, rand2, sideLengths }) => {
-    let answer;
-    if (isAskingC)
-        answer = new rational_1.Rational(sideLengths[2 * rand2] * sideLengths[2 * rand + 1], sideLengths[2 * rand])
-            .simplify()
-            .toTree();
-    else
-        answer = new rational_1.Rational(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand], sideLengths[2 * rand + 1])
-            .simplify()
-            .toTree();
-    const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
-    return texs.includes(ans);
-};
 exports.thalesCalcul = {
     id: "thalesCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Thalès pour faire des calculs",
-    levels: ["5ème", "4ème", "3ème", "2nde"],
-    isSingleStep: false,
-    sections: ["Théorème de Thalès", "Géométrie euclidienne"],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+    label: "Utiliser le théoreme de Thalès calculer un côté",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getThalesFindSideQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
-    hasGeogebra: true,
     subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getGGBOptions,
+    options,
+    hasGeogebra: true,
 };

package/lib/exercises/math/geometry/thales/thalesCalculOld.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=thalesCalculOld.d.ts.map

package/lib/exercises/math/geometry/thales/thalesCalculOld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thalesCalculOld.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalculOld.ts"],"names":[],"mappings":""}