math-exercises 3.0.21 → 3.0.22

package/lib/exercises/math/functions/affines/algebricExpressionOfAffine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algebricExpressionOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/algebricExpressionOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoDF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"algebricExpressionOfAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/algebricExpressionOfAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6DF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/math/functions/affines/algebricExpressionOfAffine.js

@@ -2,6 +2,8 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { polynomialParser } from "../../../../tree/parsers/polynomialParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getAlgebricExpressionOfAffineQuestion = () => {
     const f = AffineConstructor.random();
     const a = f.a;
@@ -26,9 +28,18 @@ const getPropositions = (n, { answer, a, b }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { a, b }) => {
-    const f = new Affine(a, b, "x");
-    return f.toTree().toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer, a, b }) => {
+    try {
+        const parsed = polynomialParser(ans);
+        if (parsed === false)
+            return false;
+        return (parsed
+            .simplify({ forbidFactorize: true, towardsDistribute: true })
+            .toTex() === answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const generatePropositions = (a, b) => {
     const firstProposition = new Affine(b !== 0 ? b : randint(-10, 11, [0]), a, "x");

package/lib/exercises/math/geometry/cartesian/pointCoordinates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointCoordinates.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/pointCoordinates.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"pointCoordinates.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/pointCoordinates.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

package/lib/exercises/math/geometry/cartesian/pointCoordinates.js

@@ -3,44 +3,45 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-const getPointCoordinatesQuestion = () => {
-    const x = randint(-10, 10);
-    const y = randint(-10, 10);
+const getInstruction = (identifiers) => {
+    return `Lire les coordonnées du point $A$ représenté dans le repère ci-dessous : `;
+};
+const getAnswer = (identifiers) => {
+    const { x, y } = identifiers;
+    const A = new Point("A", x, y);
+    return A.toCoords();
+};
+const getGGBOptions = (identifiers) => {
+    const { x, y } = identifiers;
     const xMin = Math.min(x) - 5;
     const xMax = Math.max(x) + 5;
     const yMin = Math.min(y) - 5;
     const yMax = Math.max(y) + 5;
-    const instruction = `Lire les coordonnées du point $A$ représenté dans le repère ci-dessous : `;
-    const commands = [
-        `A = (${x}, ${y})`,
-        `ShowLabel(A, true)`,
-        "SetPointStyle(A, 1)",
-        `SetVisibleInView(A, 1, true)`,
-        `SetCoords(A, ${x}, ${y})`,
-        `SetPointStyle(A, 0)`,
-        `SetPointSize(A, 5)`,
-        `SetFixed(A, true)`,
-        `ZoomIn(${xMin}, ${yMin}, ${xMax}, ${yMax})`,
-    ];
+    const A = new Point("A", x, y);
     const ggb = new GeogebraConstructor({
-        commands,
+        commands: A.toGGBCommand(),
     });
-    const A = new Point("A", x.toTree(), y.toTree());
-    const question = {
-        answer: A.toCoords(),
-        instruction,
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({
-                xMin,
-                xMax,
-                yMin,
-                yMax,
-                forceShowAxes: true,
-            }),
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+            forceShowAxes: true,
         }),
+    });
+};
+const getPointCoordinatesQuestion = () => {
+    const x = randint(-10, 10);
+    const y = randint(-10, 10);
+    const identifiers = { x, y };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: ["x", "y", "semicolon"],
         answerFormat: "tex",
-        identifiers: { x, y },
+        identifiers,
     };
     return question;
 };

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

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

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

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

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

@@ -1,2 +1 @@
-export {};
-// export * from "./pythagoreOrThales.js";
+export * from "./pythagoreOrThales.js";

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts

@@ -1,2 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    isAskingLength: boolean;
+    isSegmentHeight: boolean;
+    pointsIdentifiers: PointIdentifiers[];
+    lengths: number[];
+};
+export declare const pythagoreOrThales: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=pythagoreOrThales.d.ts.map

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":""}
+{"version":3,"file":"pythagoreOrThales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/pythagoreOrThales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAkBtC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,OAAO,CAAC;IAEzB,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,EAAE,CAAC;CAQnB,CAAC;AA+MF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

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

@@ -1,187 +1,205 @@
-// 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",
-// };
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Angle } from "../../../../math/geometry/angle.js";
+import { PointConstructor, } from "../../../../math/geometry/point.js";
+import { RightTriangleConstructor } from "../../../../math/geometry/rightTriangle.js";
+import { Segment, } from "../../../../math/geometry/segment.js";
+import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangle.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { round } from "../../../../math/utils/round.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    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 = (identifiers) => {
+    const { isAskingLength, 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 = (identifiers) => {
+    const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
+    let instruction = ``;
+    if (isSegmentHeight) {
+        if (isAskingLength) {
+            instruction = `calculer la longueur $${points[0].name}${points[1].name}$`;
+        }
+        else {
+            instruction = `prouver que le triangle $${points[1].name}${points[2].name}${points[3].name}$ est rectangle en $${points[3].name}$`;
+        }
+    }
+    else {
+        if (isAskingLength) {
+            instruction = `calculer la longueur $${points[1].name}${points[3].name}$`;
+        }
+        else {
+            instruction = `prouver que les droites $\\left(${points[1].name}${points[3].name}\\right)$ et $\\left(${points[0].name}${points[4].name}\\right)$ sont parallèles`;
+        }
+    }
+    return `On donne la figure ci-dessous${!isSegmentHeight && isAskingLength
+        ? `, où les droites $\\left(${points[1].name}${points[3].name}\\right)$ et $\\left(${points[0].name}${points[4].name}\\right)$ sont parallèles.`
+        : "."}
+
+Pour ${instruction}, il faut utiliser... `;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBOptions = (identifiers) => {
+    const { isAskingLength, lengths, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
+    let segments;
+    if (isSegmentHeight) {
+        const withoutA = points.slice(1);
+        segments = withoutA.map((p, i) => new Segment(p, withoutA[(i + 1) % 3], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[3], points[0], {
+            lengthNode: new NumberNode(lengths[3]),
+        }));
+        segments.push(new Segment(points[0], points[1]));
+    }
+    else {
+        segments = points.map((p, i) => new Segment(p, points[(i + 1) % points.length], {
+            lengthNode: new NumberNode(lengths[i]),
+        }));
+        segments.push(new Segment(points[1], points[3]));
+    }
+    const commands = [
+        ...points.flatMap((p) => p.toGGBCommand()),
+        ...segments.flatMap((s, i) => s.toGGBCommands(false, { color: "grey", thickness: 3 })),
+        ...segments
+            .slice(0, segments.length - 1)
+            .flatMap((s, i) => s.getFitCaptionCommands({ size: "scriptsize", color: "red" })),
+        ...(isAskingLength && isSegmentHeight
+            ? new Angle([points[1], points[3], points[0]]).toCommands()
+            : []),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getPythagoreOrThalesQuestion = (opts) => {
+    const isSegmentHeight = coinFlip();
+    const isAskingLength = coinFlip();
+    let points;
+    let lengths;
+    const triangle = isSegmentHeight
+        ? RightTriangleConstructor.randomNiceSides({ names: ["D", "B", "C"] })
+        : TriangleConstructor.randomNiceSides({ minAngle: 40 });
+    const summitNames = triangle.points.map((p) => p.name);
+    if (isSegmentHeight) {
+        const triangle = RightTriangleConstructor.randomNiceSides({
+            names: ["D", "B", "C"],
+        });
+        const ratio = round(0.4 + Math.random() * 0.2, 1);
+        const triangleLengths = triangle.sides.map((s) => s.getLength());
+        const A = VectorConstructor.fromPoints(triangle.points[2], triangle.points[0])
+            .times(ratio.toTree())
+            .getEndPoint(triangle.points[0], "A");
+        points = [A, triangle.points[1], triangle.points[2], triangle.points[0]];
+        lengths = [
+            round(triangleLengths[0], 2),
+            round(triangleLengths[1], 2),
+            round(triangleLengths[2], 2),
+            round(A.distanceTo(triangle.points[0]), 2),
+        ];
+    }
+    else {
+        const triangle = TriangleConstructor.randomNiceSides({ minAngle: 40 });
+        const ratio = round(0.4 + Math.random() * 0.2, 1);
+        const dName = "D";
+        const eName = "E";
+        const subTriangle = getSubTriangle({
+            triangle,
+            insidePointsNames: [dName, eName],
+            ratio,
+            isPapillon: false,
+        });
+        const triangleLengths = triangle.sides.map((s) => s.getLength());
+        const subTriangleLengths = subTriangle.sides.map((s) => s.getLength());
+        points = [
+            triangle.points[0],
+            subTriangle.points[0],
+            triangle.points[1],
+            subTriangle.points[2],
+            triangle.points[2],
+        ];
+        lengths = [
+            round(triangleLengths[2] - subTriangleLengths[2], 2),
+            round(subTriangleLengths[2], 2),
+            round(subTriangleLengths[0], 2),
+            round(triangleLengths[0] - subTriangleLengths[0], 2),
+            round(triangleLengths[1], 2),
+        ];
+    }
+    const identifiers = {
+        lengths,
+        pointsIdentifiers: points.map((p) => p.toIdentifiers()),
+        isAskingLength,
+        isSegmentHeight,
+    };
+    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 pythagoreOrThales = {
+    id: "pythagoreOrThales",
+    label: "Choisir entre Thalès, Pythagore et leurs réciproques",
+    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",
+};
+const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
+    const [A, B, C] = triangle.points;
+    const [dName, eName] = insidePointsNames;
+    const vecAB = VectorConstructor.fromPoints(A, B).times((1 - ratio).toTree());
+    const pointD = vecAB.getEndPoint(A, dName);
+    const vecCB = VectorConstructor.fromPoints(C, B).times((1 - ratio).toTree());
+    const pointE = vecCB.getEndPoint(C, eName);
+    return new Triangle([pointD, triangle.points[1], pointE], {
+        sidesLengths: triangle.sides.map((s) => round(s.getLength() * Math.abs(ratio), 2).toTree()),
+    });
+};

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

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

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;AAClC,cAAc,kBAAkB,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;AAClC,cAAc,sBAAsB,CAAC;AACrC,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,7 @@ export * from "./volumes/index.js";
 // export * from "./triangles.js";
 export * from "./euclidianConstructions/index.js";
 export * from "./shapes/index.js";
-// export * from "./euclidian/index.js";
+export * from "./euclidian/index.js";
 export * from "./parametric/index.js";
 export * from "./quadrilaterals/index.js";
 export * from "./angles/index.js";

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,EAqBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAQzC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAqJF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBvD,CAAC"}
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAqBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,iCAAiC,CAAC;AAQzC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AA8DF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBvD,CAAC"}

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

@@ -83,7 +83,7 @@ const getGGBOptions = (identifiers) => {
     const seg = new Segment(points[0], points[1]);
     const commands = [
         ...triangle.commands,
-        ...points.flatMap((p) => p.toGGBCommand({ style: 0, color: "#444444", size: 4 })),
+        ...points.flatMap((p) => p.toGGBCommand({ color: "#444444", size: 4 })),
         ...seg.toGGBCommands(false),
     ];
     if (identifiers.isPapillon) {

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts

@@ -8,5 +8,6 @@ export type ToGGBCommandsProps = {
     color?: string;
     showLength?: boolean;
     label?: string;
+    thickness?: number;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

package/lib/exercises/utils/geogebra/toGGBCommandsProps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC"}
+{"version":3,"file":"toGGBCommandsProps.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toGGBCommandsProps.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC"}

package/lib/index.d.ts

@@ -1260,6 +1260,11 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     type: number;
     commands: string[];
+}, {}> | Exercise<{
+    isAskingLength: boolean;
+    isSegmentHeight: boolean;
+    pointsIdentifiers: import("./math/geometry/point.js").PointIdentifiers[];
+    lengths: number[];
 }, {}> | Exercise<{
     startPoint: number[];
     vector: number[];

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/math/geometry/segment.d.ts

@@ -35,8 +35,12 @@ export declare class Segment {
     toTex(): string;
     toInsideName(): string;
     toLengthTex(): string;
-    getFitCaptionCommands(text?: string, color?: string): string[];
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, }?: ToGGBCommandsProps): string[];
+    getFitCaptionCommands({ text, color, size, }?: {
+        text?: string;
+        color?: string;
+        size?: "scriptsize" | "tiny" | "small" | "large";
+    }): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, }?: ToGGBCommandsProps): string[];
     includes(point: Point): boolean;
     toVector(): Vector;
 }

package/lib/math/geometry/segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAanD,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,GACN,GAAE,kBAAuB;IA8B5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EAAE,MAAM,EAAqB,MAAM,aAAa,CAAC;AAExD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,GACV,GAAE,kBAAuB;IAgC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -74,20 +74,22 @@ export class Segment {
     toLengthTex() {
         return `${this.toInsideName()} = ${this.getLengthNode().toTex()}`;
     }
-    getFitCaptionCommands(text, color) {
+    getFitCaptionCommands({ text, color, size, } = {}) {
         const txt = text ?? this.getLength().frenchify();
         const midPoint = this.getMidpoint().toMathString();
         const cmds = [
-            `angle_{${this.name}} = Angle(Vector(${this.pointA.name}, ${this.pointB.name}))`,
-            `SetVisibleInView(angle_{${this.name}}, 1, false)`,
-            `text_{${this.name}} = Text(RotateText("${txt}", If(angle_{${this.name}} > 90° ∧ angle_{${this.name}} < 270°, angle_{${this.name}} + 180°, angle_{${this.name}})), ${midPoint}, true, true, 0, 0)`,
+            // `angle_{${this.name}} = Angle(Vector(${this.pointA.name}, ${this.pointB.name}))`,
+            // `SetVisibleInView(angle_{${this.name}}, 1, false)`,
+            // `text_{${this.name}} = Text(RotateText("${txt}", If(angle_{${this.name}} > 90° ∧ angle_{${this.name}} < 270°, angle_{${this.name}} + 180°, angle_{${this.name}})), ${midPoint}, true, true, 0, 0)`,
+            `text_{${this.name}} = Text("${size ? `\\${size}` : ""} ${txt}", ${midPoint}, true, true, 0, 0)`,
+            // `SetBackgroundColor(text_{${this.name}}, "white")`,
         ];
         if (color) {
             cmds.push(`SetColor(text_{${this.name}}, "${color}")`);
         }
         return cmds;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
             `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
@@ -98,9 +100,12 @@ export class Segment {
         }
         if (showLength) {
             const length = this.getLengthNode().toTex();
-            commands.push(`SetCaption(${this.ggbName}, ${length})`);
+            commands.push(`SetCaption(${this.ggbName}, "${length}")`);
             commands.push(`ShowLabel(${this.ggbName}, true)`);
         }
+        if (thickness !== undefined) {
+            commands.push(`SetLineThickness(${this.ggbName}, ${thickness})`);
+        }
         if (shouldBuildPoints) {
             const ACommands = this.pointA.toGGBCommand({
                 isFixed,

package/lib/math/geometry/triangle.d.ts

@@ -9,10 +9,11 @@ export type TriangleIdentifiers = {
 };
 export declare abstract class TriangleConstructor {
     static fromIdentifiers(identifiers: TriangleIdentifiers): Triangle;
-    static randomNiceSides({ names, randomName, intSides, }: {
+    static randomNiceSides({ names, randomName, intSides, minAngle, }: {
         names?: string[] | undefined;
         randomName?: boolean | undefined;
         intSides?: boolean | undefined;
+        minAngle?: number | undefined;
     }): Triangle;
     static randomName(): string[];
 }

package/lib/math/geometry/triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,GACjB;;;;KAAA,GAAG,QAAQ;IA8BZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAWH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}
+{"version":3,"file":"triangle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/triangle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEvE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAKnC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAG7C,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAEF,8BAAsB,mBAAmB;IACvC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,mBAAmB,GAAG,QAAQ;IAgBlE,MAAM,CAAC,eAAe,CAAC,EACrB,KAAuB,EACvB,UAAkB,EAClB,QAAgB,EAChB,QAAY,GACb;;;;;KAAA,GAAG,QAAQ;IA+CZ,MAAM,CAAC,UAAU;CAQlB;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,YAAY,CAAC,EAAE,CAAC,eAAe,GAAG,SAAS,CAAC,EAAE,CAAC;IAC/C,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;IACvC,kBAAkB,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC,CAAC;AACF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,CAAC,aAAa,GAAG,SAAS,CAAC,EAAE,CAAC;IAC7C,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;IACrC,kBAAkB,CAAC,EAAE,aAAa,EAAE,CAAC;CACtC,CAAC;AACF,qBAAa,QAAQ;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,aAAa,CAAC;gBACV,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,aAAa;IAyClD,aAAa,IAAI,mBAAmB;IAepC,YAAY,IAAI,MAAM;IAItB,OAAO,IAAI,MAAM;IASjB,OAAO,IAAI,OAAO;IAIlB,aAAa,IAAI,OAAO;IAMxB,WAAW,IAAI,OAAO;IAUtB,SAAS,IAAI,OAAO;IASpB,aAAa,CACX,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;QACJ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB;IAcH,cAAc,CACZ,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE;QACL,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;KACrB;IAKH,eAAe,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE;IAQtC,SAAS,CACP,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB;IAYH,UAAU,CACR,WAAW,EAAE,MAAM,EACnB,IAAI,CAAC,EAAE;QACL,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,KAAK,CAAC;KACnB;IAoCH,cAAc,IAAI,MAAM,EAAE;CAkB3B"}

package/lib/math/geometry/triangle.js

@@ -16,23 +16,38 @@ export class TriangleConstructor {
             sidesLengths: identifiers.props?.sidesLengths?.map((n) => n ? reifyAlgebraic(n) : undefined),
         });
     }
-    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, }) {
+    static randomNiceSides({ names = ["A", "B", "C"], randomName = false, intSides = false, minAngle = 0, }) {
         let vertices = [];
         if (randomName)
             vertices = TriangleConstructor.randomName();
         else
             vertices = names;
-        const angle = randfloat(0, 2 * Math.PI);
-        const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
-        //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
-        //puis [AB] sur (Ox) qu'on rotate
-        const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
-        const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
-        const origin = new Point("O", (0).toTree(), (0).toTree());
-        const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
-        const A = startA.rotate(angle, origin);
-        const C = new Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
-        const B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        let A;
+        let B;
+        let C;
+        const anglesAreNice = () => {
+            const values = [
+                new Angle([C, B, A]).evaluate(),
+                new Angle([A, C, B]).evaluate(),
+                new Angle([B, A, C]).evaluate(),
+            ];
+            if (minAngle)
+                return values.every((v) => v > minAngle && v < 180 - minAngle);
+            return values.every((v) => v > 20 && v < 110);
+        };
+        do {
+            const angle = randfloat(0, 2 * Math.PI);
+            const addAngle = randfloat(Math.PI / 4, (3 * Math.PI) / 4);
+            //on construit [AC] sur (Ox) de milieu O et de taille 2*xRand
+            //puis [AB] sur (Ox) qu'on rotate
+            const xRand = intSides ? randint(5, 9) : randfloat(5, 8, 1);
+            const xRand2 = intSides ? randint(-5, 5) : randfloat(-5, 5, 1);
+            const origin = new Point("O", (0).toTree(), (0).toTree());
+            const startA = new Point(vertices[0], (-xRand).toTree(), (0).toTree());
+            A = startA.rotate(angle, origin);
+            C = new Point(vertices[2], xRand.toTree(), (0).toTree()).rotate(angle, origin);
+            B = new Point(vertices[1], (-xRand + xRand2).toTree(), (0).toTree()).rotate(angle + addAngle, startA);
+        } while (!anglesAreNice());
         return new Triangle([A, B, C], {
             sidesLengths: [
                 round(B.distanceTo(C), intSides ? 0 : 1).toTree(),
@@ -138,7 +153,10 @@ export class Triangle {
         if (opts.color)
             this.commands.push(`SetColor(${side.ggbName}, "${opts.color}")`);
         if (opts.caption) {
-            this.commands.push(...side.getFitCaptionCommands(opts.caption, opts.color));
+            this.commands.push(...side.getFitCaptionCommands({
+                text: opts.caption,
+                color: opts.color,
+            }));
         }
     }
     highlightAngle(index, opts) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.21",
+  "version": "3.0.22",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [