math-exercises 2.2.56 → 2.2.57

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/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":""}

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

@@ -0,0 +1,214 @@
+"use strict";
+// import {
+//   Exercise,
+//   Proposition,
+//   QCMGenerator,
+//   Question,
+//   QuestionGenerator,
+//   VEA,
+//   addValidProp,
+//   tryToAddWrongProp,
+// } from "../../../../exercises/exercise";
+// import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions";
+// import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor";
+// import { Rational } from "../../../../math/numbers/rationals/rational";
+// import { randint } from "../../../../math/utils/random/randint";
+// import { Node } from "../../../../tree/nodes/node";
+// import { coinFlip } from "../../../../utils/alea/coinFlip";
+// import { shuffle } from "../../../../utils/alea/shuffle";
+// type Identifiers = {
+//   sideLengths: number[];
+//   rand: number;
+//   rand2: number;
+//   isAskingC: boolean;
+//   xA: number;
+//   yA: number;
+//   xB: number;
+//   yB: number;
+//   xC: number;
+//   yC: number;
+//   factor: number;
+// };
+// const getThales: QuestionGenerator<Identifiers> = () => {
+//   const vertices = [];
+//   const code = 65 + 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] = [randint(-10, 11), 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] = [
+//       randint(-10, 11),
+//       randint(-10, 11),
+//       randint(-10, 11),
+//       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 = 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]}`,
+//   ];
+//   // 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 = randint(0, 3);
+//   let rand2 = randint(0, 3, [rand]);
+//   if (sideLengths[2 * rand] === sideLengths[2 * rand2])
+//     rand2 = 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: Node;
+//   let startStatement;
+//   const isAskingC = 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(
+//       sideLengths[2 * rand2] * sideLengths[2 * rand + 1],
+//       sideLengths[2 * rand],
+//     )
+//       .simplify()
+//       .toTree();
+//   } 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(
+//       sideLengths[2 * rand2 + 1] * sideLengths[2 * rand],
+//       sideLengths[2 * rand + 1],
+//     )
+//       .simplify()
+//       .toTree();
+//   }
+//   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)`,
+//   ];
+//   const ggb = new GeogebraConstructor({
+//     commands,
+//     hideAxes: true,
+//     hideGrid: true,
+//   });
+//   const answer = statement.toTex();
+//   const question: Question<Identifiers> = {
+//     instruction,
+//     startStatement,
+//     answer,
+//     keys: [],
+//     ggbOptions: ggb.getOptions({
+//       coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+//     }),
+//     answerFormat: "tex",
+//     identifiers: {
+//       isAskingC,
+//       rand,
+//       rand2,
+//       sideLengths,
+//       xA,
+//       yA,
+//       xB,
+//       yB,
+//       xC,
+//       yC,
+//       factor,
+//     },
+//   };
+//   return question;
+// };
+// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
+//   const propositions: Proposition[] = [];
+//   addValidProp(propositions, answer);
+//   while (propositions.length < n) {
+//     tryToAddWrongProp(
+//       propositions,
+//       new Rational(randint(2, 30), randint(2, 30)).simplify().toTree().toTex(),
+//     );
+//   }
+//   return shuffle(propositions);
+// };
+// const isAnswerValid: VEA<Identifiers> = (
+//   ans,
+//   { isAskingC, rand, rand2, sideLengths },
+// ) => {
+//   let answer: Node;
+//   if (isAskingC)
+//     answer = new Rational(
+//       sideLengths[2 * rand2] * sideLengths[2 * rand + 1],
+//       sideLengths[2 * rand],
+//     )
+//       .simplify()
+//       .toTree();
+//   else
+//     answer = new Rational(
+//       sideLengths[2 * rand2 + 1] * sideLengths[2 * rand],
+//       sideLengths[2 * rand + 1],
+//     )
+//       .simplify()
+//       .toTree();
+//   const texs = answer.toAllValidTexs({ allowFractionToDecimal: true });
+//   return texs.includes(ans);
+// };
+// export const thalesCalcul: Exercise<Identifiers> = {
+//   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: number) => getDistinctQuestions(getThales, nb),
+//   qcmTimer: 60,
+//   freeTimer: 60,
+//   getPropositions,
+//   isAnswerValid,
+//   hasGeogebra: true,
+//   subject: "Mathématiques",
+// };