math-exercises 2.2.68 → 2.2.70

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;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"}
+{"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;AAiBtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA+EF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

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

@@ -4,95 +4,60 @@ exports.pythagoreCalcul = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-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");
-const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
-const coinFlip_1 = require("../../../../utils/alea/coinFlip");
-const isInt_1 = require("../../../../utils/isInt");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
+const random_1 = require("../../../../utils/alea/random");
+const rightTriangle_1 = require("../../../../math/geometry/rightTriangle");
+const sqrtVEA_1 = require("../../../../exercises/vea/sqrtVEA");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
 const getPythagoreCalcul = () => {
-    const vertices = [];
-    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 = triangle_1.TriangleConstructor.createRandomRightTriangle({
-        minRapport: 0.7,
-        maxRapport: 1.3,
-        names: vertices,
+    const triangle = rightTriangle_1.RightTriangleConstructor.randomNiceSides({
+        randomName: true,
     });
-    const sides = [
-        triangle.getSideCName(),
-        triangle.getSideBName(),
-        triangle.getSideAName(),
-    ];
-    const sideLengths = [
-        triangle.getSideCnumber(),
-        triangle.getSideBnumber(),
-        triangle.getSideAnumber(),
-    ].map((el) => Math.round(el / 2));
-    const zeroOrOne = (0, shuffle_1.shuffle)([0, 1]);
-    const randoms = (0, coinFlip_1.coinFlip)() ? [...zeroOrOne, 2] : [2, ...zeroOrOne];
-    // le but est d'avoir une chance sur 2 d'avoir un hépoténus et une 1 chance sur 2 d'avoir un a des 2 autres cote
-    let answer;
-    let square;
-    if (randoms[2] === 2) {
-        // cas de l'hypoténus
-        square = sideLengths[0] ** 2 + sideLengths[1] ** 2;
-    }
-    else {
-        // les deux autres cotés
-        square = sideLengths[randoms[0]] ** 2 - sideLengths[randoms[1]] ** 2;
-    }
-    const sqrt = Math.sqrt(square);
-    answer = (0, isInt_1.isInt)(sqrt) ? sqrt + "" : `\\sqrt{${square}}`;
-    const commands = [
-        ...triangle.generateCommands({
-            showLabels: [...sides, sides[randoms[2]]],
-            setCaptions: [...sideLengths.map((el) => el + ""), "?"],
-            highlightedSide: sides[randoms[2]],
-        }),
-    ];
+    //une chance sur deux d'avoir hypoténuse
+    const sideIndexAsked = (0, random_1.random)([0, (0, random_1.random)([1, 2])]);
+    const answer = triangle.sides[sideIndexAsked].getLengthNode().toTex();
+    triangle.showSidesLength([sideIndexAsked]);
+    const commands = [...triangle.commands];
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
         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]]}$.`,
+        instruction: `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, on sait que $${triangle.sides[(sideIndexAsked + 1) % 3].toLengthTex()}$ et que $${triangle.sides[(sideIndexAsked + 2) % 3].toLengthTex()}$. 
+    
+Calculer la longueur exacte $${triangle.sides[sideIndexAsked].toInsideName()}$.`,
         answer,
-        keys: [...vertices, "equal"],
+        keys: [],
         ggbOptions: ggb.getOptions({
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { square, sideLengths, triangleIdentifiers },
+        identifiers: { sideAsked: sideIndexAsked, triangleIdentifiers },
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, triangleIdentifiers, sideAsked }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
+    const triangle = rightTriangle_1.RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const lengths = triangle.sides.map((s) => s.getLength());
+    //erreur d'oubli de la racine
+    (0, exercise_1.tryToAddWrongProp)(propositions, (0, powerNode_1.square)(answer.unfrenchify()).simplify().toTex());
+    if (sideAsked !== 0) {
+        //erreur d'application a^2+b^2 = c^2 alors qu'on cherche pas l'hypo
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(Math.sqrt(lengths[0] ** 2 + lengths[3 - sideAsked] ** 2), 1).frenchify());
+    }
     while (propositions.length < n) {
-        const temp = (0, randint_1.randint)(2, 300);
-        const squareRoot = new real_1.SquareRoot(temp);
-        const wrongAnswer = Math.sqrt(temp) === Math.floor(Math.sqrt(temp))
-            ? Math.sqrt(temp).toString()
-            : squareRoot.toTree().toTex();
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randfloat_1.randfloat)(1, 100, 1).frenchify());
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
-const isAnswerValid = (ans, { square }) => {
-    const sqrt = Math.sqrt(square);
-    const answer = (0, isInt_1.isInt)(sqrt)
-        ? new numberNode_1.NumberNode(sqrt)
-        : new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode(square), { allowSimplifySqrt: true });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer, sideAsked, triangleIdentifiers }) => {
+    return (0, sqrtVEA_1.sqrtVEA)(ans, answer);
 };
 exports.pythagoreCalcul = {
     id: "pythagoreCalcul",

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

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

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

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

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./quadrilateralRecognition"), exports);

package/lib/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { ParallelogramIdentifiers } from "../../../../math/geometry/parallelogram";
+import { RectangleIdentifiers } from "../../../../math/geometry/rectangle";
+import { RhombusIdentifiers } from "../../../../math/geometry/rhombus";
+import { SquareIdentifiers } from "../../../../math/geometry/square";
+type Identifiers = {
+    shape: string;
+    showDiagonals: boolean;
+    drawAngles: boolean;
+    shapeIdentifiers: RectangleIdentifiers | SquareIdentifiers | RhombusIdentifiers | ParallelogramIdentifiers;
+};
+export declare const quadrilateralRecognition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=quadrilateralRecognition.d.ts.map

package/lib/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadrilateralRecognition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAEL,wBAAwB,EACzB,MAAM,mCAAmC,CAAC;AAE3C,OAAO,EAEL,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAGL,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AAIpC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,OAAO,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EACZ,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,GAClB,wBAAwB,CAAC;CAC9B,CAAC;AA0MF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAoB1D,CAAC"}

package/lib/exercises/math/geometry/quadrilaterals/quadrilateralRecognition.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quadrilateralRecognition = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const parallelogram_1 = require("../../../../math/geometry/parallelogram");
+const rectangle_1 = require("../../../../math/geometry/rectangle");
+const rhombus_1 = require("../../../../math/geometry/rhombus");
+const square_1 = require("../../../../math/geometry/square");
+const coinFlip_1 = require("../../../../utils/alea/coinFlip");
+const random_1 = require("../../../../utils/alea/random");
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un rectangle", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un carré", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un losange", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un parallélogramme", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    switch (identifiers.shape) {
+        case "rectangle":
+            return "Un rectangle";
+        case "rhombus":
+            return "Un losange";
+        case "square":
+            return "Un carré";
+        case "parallelogram":
+        default:
+            return "Un parallélogramme";
+    }
+};
+const getInstruction = (identifiers) => {
+    return "Quelle est la nature du quadrilatère ci-dessous ? Donner la réponse la plus précise possible. ";
+};
+const getHint = (identifiers) => {
+    const { shape, showDiagonals, drawAngles } = identifiers;
+    switch (shape) {
+        case "rectangle":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont de même longueur et se coupent en leur milieu.";
+            }
+            else {
+                if (drawAngles) {
+                    return "$ABCD$ est un quadrilatère avec $4$ angles droits.";
+                }
+                return "$ABCD$ possède un angle droit, et ses côtés sont égaux deux à deux.";
+            }
+        case "rhombus":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont perpendiculaires et se coupent en leur milieu.";
+            }
+            else {
+                return "$ABCD$ possède quatre côtés égaux.";
+            }
+        case "square":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont de même longueur, sont perpendiculaires et se coupent en leur milieu.";
+            }
+            else {
+                return "$ABCD$ est un quadrilatère avec $4$ angles droits et $4$ côtés égaux.";
+            }
+        case "parallelogram":
+        default:
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ se coupent en leur milieu.";
+            }
+            else {
+                return "Les côtés de $ABCD$ sont égaux deux à deux.";
+            }
+    }
+};
+const getCorrection = (identifiers) => {
+    const { shape, showDiagonals, drawAngles } = identifiers;
+    switch (shape) {
+        case "rectangle":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont de même longueur et se coupent en leur milieu. Donc, $ABCD$ est un rectangle.";
+            }
+            else {
+                if (drawAngles) {
+                    return "$ABCD$ est un quadrilatère avec $4$ angles droits : c'est donc un rectangle.";
+                }
+                return "$ABCD$ possède un angle droit, et ses côtés sont égaux deux à deux. Donc, $ABCD$ est un rectangle.";
+            }
+        case "rhombus":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont perpendiculaires et se coupent en leur milieu. Donc, $ABCD$ est un losange.";
+            }
+            else {
+                return "$ABCD$ possède quatre côtés égaux. Donc, $ABCD$ est un losange.";
+            }
+        case "square":
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ sont de même longueur, sont perpendiculaires et se coupent en leur milieu. Donc, $ABCD$ est un carré.";
+            }
+            else {
+                return "$ABCD$ est un quadrilatère avec $4$ angles droits et $4$ côtés égaux : c'est donc un carré.";
+            }
+        case "parallelogram":
+        default:
+            if (showDiagonals) {
+                return "Les diagonales de $ABCD$ se coupent en leur milieu. Donc, $ABCD$ est un parallélogramme.";
+            }
+            else {
+                return "Les côtés de $ABCD$ sont égaux deux à deux. Donc, $ABCD$ est un parallélogramme.";
+            }
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { shape, showDiagonals, drawAngles } = identifiers;
+    let shapeObject;
+    switch (shape) {
+        case "rectangle":
+            shapeObject = rectangle_1.RectangleConstructor.fromIdentifiers(identifiers.shapeIdentifiers);
+            if (showDiagonals)
+                shapeObject.drawDiagonals({ drawCenter: true, drawDecorations: true });
+            else
+                shapeObject.drawSidesDecoration({
+                    drawAngles: drawAngles,
+                    drawSidesLengths: !drawAngles,
+                });
+            break;
+        case "square":
+            shapeObject = square_1.SquareConstructor.fromIdentifiers(identifiers.shapeIdentifiers);
+            if (showDiagonals)
+                shapeObject.drawDiagonals({ drawCenter: true, drawDecorations: true });
+            else
+                shapeObject.drawSidesDecoration({
+                    drawAngles,
+                    drawSidesLengths: !drawAngles,
+                });
+            break;
+        case "parallelogram":
+            shapeObject = parallelogram_1.ParallelogramConstructor.fromIdentifiers(identifiers.shapeIdentifiers);
+            if (showDiagonals)
+                shapeObject.drawDiagonals({
+                    drawCenter: true,
+                    drawDecorations: true,
+                });
+            else
+                shapeObject.drawSidesDecoration({});
+            break;
+        case "rhombus":
+        default:
+            shapeObject = rhombus_1.RhombusConstructor.fromIdentifiers(identifiers.shapeIdentifiers);
+            if (showDiagonals)
+                shapeObject.drawDiagonals({ drawCenter: true, drawDecorations: true });
+            else
+                shapeObject.drawSidesDecoration();
+    }
+    const cmds = shapeObject.toGGBCommands();
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({ hideAxes: true, hideGrid: true });
+    ggb.commands = cmds;
+    return ggb.getOptions({ coords: [-10, 10, -10, 10] });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    throw Error("VEA not implemented");
+};
+const getQuadrilateralRecognitionQuestion = (opts) => {
+    const shape = (0, random_1.random)(["rectangle", "rhombus", "parallelogram", "square"]);
+    let shapeObject;
+    switch (shape) {
+        case "rectangle":
+            shapeObject = rectangle_1.RectangleConstructor.random();
+            break;
+        case "square":
+            shapeObject = square_1.SquareConstructor.random();
+            break;
+        case "parallelogram":
+            shapeObject = parallelogram_1.ParallelogramConstructor.random();
+            break;
+        case "rhombus":
+        default:
+            shapeObject = rhombus_1.RhombusConstructor.random();
+    }
+    const showDiagonals = (0, coinFlip_1.coinFlip)();
+    const drawAngles = (0, coinFlip_1.coinFlip)();
+    const identifiers = {
+        showDiagonals,
+        drawAngles,
+        shape,
+        shapeIdentifiers: shapeObject.toIdentifiers(),
+    };
+    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;
+};
+exports.quadrilateralRecognition = {
+    id: "quadrilateralRecognition",
+    connector: "=",
+    label: "Reconnaître un quadrilatère",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getQuadrilateralRecognitionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    answerType: "QCU",
+    hasGeogebra: true,
+    hasHintAndCorrection: true,
+};

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;AAEzB,cAAc,gBAAgB,CAAC"}
+{"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"}

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

@@ -15,5 +15,4 @@ 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.js

@@ -92,8 +92,8 @@ const getPropositions = (n, { answer, vertices }) => {
     const indexRange = Array.from({ length: 8 }, (_, i) => i);
     while (propositions.length < n) {
         const rands = (0, shuffle_1.shuffle)(indexRange).slice(0, 6);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `\\frac{${wrongQuotients[rands[0]]}}{${wrongQuotients[rands[1]]}} = 
-    \\frac{${wrongQuotients[rands[2]]}}{${wrongQuotients[rands[3]]}} = 
+        (0, exercise_1.tryToAddWrongProp)(propositions, `\\frac{${wrongQuotients[rands[0]]}}{${wrongQuotients[rands[1]]}} =
+    \\frac{${wrongQuotients[rands[2]]}}{${wrongQuotients[rands[3]]}} =
     \\frac{${wrongQuotients[rands[4]]}}{${wrongQuotients[rands[5]]}}`);
     }
     return (0, shuffle_1.shuffle)(propositions);

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

@@ -1,11 +1,10 @@
 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 = {
+    ratio: number;
     triangleIdentifiers: TriangleIdentifiers;
-    insidePointsIdentifiers: PointIdentifiers[];
-    segmentAsked: SegmentIdentifiers;
+    insidePointsNames: string[];
+    segmentAskedName: string;
     isPapillon: boolean;
 };
 type Options = {

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,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;AAmEF,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,0BAA0B,CAAC;AAMlC,OAAO,EAGL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAQtC,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"}

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

@@ -5,18 +5,25 @@ 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 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 vector_1 = require("../../../../math/geometry/vector");
 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 random_1 = require("../../../../utils/alea/random");
 const randomLetter_1 = require("../../../../utils/strings/randomLetter");
+const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
+    const [A, B, C] = triangle.points;
+    const [dName, eName] = insidePointsNames;
+    const vecAC = vector_1.VectorConstructor.fromPoints(A, C).times((1 - ratio).toTree());
+    const pointD = vecAC.getEndPoint(A, dName);
+    const vecBC = vector_1.VectorConstructor.fromPoints(B, C).times((1 - ratio).toTree());
+    const pointE = vecBC.getEndPoint(B, eName);
+    return new triangle_1.Triangle([pointD, pointE, triangle.points[2]], {
+        sidesLengths: triangle.sides.map((s) => (0, round_1.round)(s.getLength() * Math.abs(ratio), 2).toTree()),
+    });
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
@@ -27,66 +34,41 @@ const getPropositions = (n, { answer }) => {
 };
 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),
-            };
-        }),
-    ];
-    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 {
-        return (0, round_1.round)((0, multiplyNode_1.multiply)(ratio, lengths[askedIndex + 3].length).evaluate(), 1).frenchify();
+    let segment = triangle.sides.find((s) => s.name === identifiers.segmentAskedName);
+    if (segment) {
+        return segment.getLength().frenchify();
     }
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio: identifiers.ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    segment = subTriangle.sides.find((s) => s.name === identifiers.segmentAskedName);
+    if (!segment)
+        throw Error("Question poorly built");
+    return segment.getLength().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
+    const ratio = identifiers.ratio;
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    const oppositeSegment = triangle.sides[2].toInsideName();
+    const segmentAskedName = identifiers.segmentAskedName;
+    const allSides = [...triangle.sides, ...subTriangle.sides];
+    return `Dans le triangle $${triangle.name}$ ci-dessous, les droites $\\left(${subTriangle.sides[2].toInsideName()}\\right)$ et $\\left(${oppositeSegment}\\right)$ sont parallèles.
+
+On sait de plus que : ${allSides
         .filter((e) => e.name !== segmentAskedName)
-        .map((e) => `$${e.name}=${e.length}$`)
+        .map((e) => `$${e.toLengthTex()}$`)
         .join(" , ")}.
 
-Calculer $${segmentAskedName}$ (arrondir aux dixième).`;
+Calculer $${segmentAskedName.slice(1, 3)}$ (arrondir aux dixième).`;
 };
 // const getHint : GetHint<Identifiers> = (identifiers)=>{
 // }
@@ -94,17 +76,22 @@ Calculer $${segmentAskedName}$ (arrondir aux dixième).`;
 // }
 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 subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio: identifiers.ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    const points = [subTriangle.points[0], subTriangle.points[1]];
     const seg = new segment_1.Segment(points[0], points[1]);
     const commands = [
-        ...triangle.generateCommands({}),
+        ...triangle.commands,
         ...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));
+        commands.push(...new segment_1.Segment(points[0], triangle.points[2]).toGGBCommands(false));
+        commands.push(...new segment_1.Segment(points[1], triangle.points[2]).toGGBCommands(false));
     }
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
@@ -141,31 +128,35 @@ const options = [
         type: exercise_1.GeneratorOptionType.select,
     },
 ];
+// (DE) // (AB)
 const getThalesFindSideQuestion = (opts) => {
-    const summitNames = triangle_1.TriangleConstructor.randomName();
-    const triangle = triangle_1.TriangleConstructor.createRandomTriangle({
-        names: summitNames,
+    const triangle = triangle_1.TriangleConstructor.randomNiceSides({
+        randomName: true,
     });
+    const summitNames = triangle.points.map((p) => p.name);
     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(),
-    ]);
+    //homothety rapport
+    // const ratio = !isPapillon ? randfloat(0.2, 0.8, 1) : randfloat(-0.2, -0.8, 1);
+    const ratio = 0.5;
+    const dName = (0, randomLetter_1.randomLetter)(true, summitNames);
+    const eName = (0, randomLetter_1.randomLetter)(true, [...summitNames, dName]);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: [dName, eName],
+        ratio,
+        isPapillon,
+    });
+    const segmentAsked = (0, random_1.random)([...triangle.sides, ...subTriangle.sides]);
     const identifiers = {
         triangleIdentifiers: triangle.toIdentifiers(),
-        insidePointsIdentifiers: [pointD.toIdentifiers(), pointE.toIdentifiers()],
-        segmentAsked: segmentAsked.toIdentifiers(),
+        insidePointsNames: [dName, eName],
+        segmentAskedName: segmentAsked.name,
         isPapillon,
+        ratio,
     };
     const question = {
         answer: getAnswer(identifiers),