math-exercises 2.2.19 → 2.2.20

package/lib/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildMediatriceWithCompass.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AA8GF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}
+{"version":3,"file":"buildMediatriceWithCompass.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildMediatriceWithCompass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,CAAC,EAAE,MAAM,EAAE,CAAC;CACb,CAAC;AAsGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

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

@@ -25,12 +25,8 @@ const getBuildMediatriceWithCompassQuestion = () => {
     const yMin = Math.min(ya, yb) - length;
     const yMax = Math.max(ya, yb) + length;
     const ggbAnswer = [
-        `${pointA.toGGBCommand()}`,
-        `${pointB.toGGBCommand()}`,
-        `SetFixed(${A}, true)`,
-        `SetFixed(${B}, true)`,
-        `ShowLabel(${A}, true)`,
-        `ShowLabel(${B}, true)`,
+        ...pointA.toGGBCommand(),
+        ...pointB.toGGBCommand(),
         `Seg = Segment(${A},${B})`,
         `C_1 = Circle(${A},${B})`,
         `C_2 = Circle(${B},${A})`,
@@ -41,12 +37,8 @@ const getBuildMediatriceWithCompassQuestion = () => {
     ];
     const studentGGB = new geogebraConstructor_1.GeogebraConstructor({
         commands: [
-            `${pointA.toGGBCommand()}`,
-            `${pointB.toGGBCommand()}`,
-            `SetFixed(${A}, true)`,
-            `SetFixed(${B}, true)`,
-            `ShowLabel(${A}, true)`,
-            `ShowLabel(${B}, true)`,
+            ...pointA.toGGBCommand(),
+            ...pointB.toGGBCommand(),
             `Seg = Segment(${A},${B})`,
         ],
         hideGrid: true,

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

@@ -7,4 +7,5 @@ export * from "./vectors";
 export * from "./convexity";
 export * from "./volumes";
 export * from "./euclidianConstructions";
+export * from "./shapes";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAE1B,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAE1B,cAAc,0BAA0B,CAAC;AACzC,cAAc,UAAU,CAAC"}

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

@@ -24,3 +24,4 @@ __exportStar(require("./convexity"), exports);
 __exportStar(require("./volumes"), exports);
 // export * from "./triangles";
 __exportStar(require("./euclidianConstructions"), exports);
+__exportStar(require("./shapes"), exports);

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    type: number;
+    commands: string[];
+};
+export declare const basicShapesNaming: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=basicShapesNaming.d.ts.map

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

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

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicShapesNaming = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const line_1 = require("../../../../math/geometry/line");
+const ray_1 = require("../../../../math/geometry/ray");
+const segment_1 = require("../../../../math/geometry/segment");
+const randint_1 = require("../../../../math/utils/random/randint");
+//!!Difficile de rendre cet exo non pur QCM car taper la parenthèse ouvre un environnement left/right ce qui empeche de taper des demi droites [AB)
+//!solutions que je vois :
+//! créer une touche parenthèse qui n'ouvre pas left/right (faisable mais relou)
+//! créer des touches [..], (..) et [..) directement (mais il faut déplacer le curseur vers la gauche dans ce cas)
+const getBasicShapesNamingQuestion = () => {
+    let answer = "";
+    const commands = [];
+    const type = (0, randint_1.randint)(1, 4);
+    let startPointName = "";
+    switch (type) {
+        case 1: //segment
+            const segment = segment_1.SegmentConstructor.random();
+            commands.push(...segment.toGGBCommands(true));
+            answer = segment.name;
+            break;
+        case 2: //demi-droite
+            const ray = ray_1.RayConstructor.random();
+            commands.push(...ray.toGGBCommands(true));
+            answer = ray.name;
+            startPointName = ray.startPoint.name;
+            break;
+        case 3: //droite
+        default:
+            const line = line_1.LineConstructor.random();
+            commands.push(...line.toGGBCommands(true));
+            answer = line.name;
+            break;
+    }
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    // const letters = answer.substring(1, answer.length - 1).split("") as KeyId[];
+    // console.log(letters);
+    const question = {
+        answer,
+        instruction: `Comment se nomme la figure suivante ?`,
+        // keys: ["lbracket", "rbracket", ...letters],
+        // keys: [{
+        //   id: "custom",
+        //   label: "[...]",
+        //   labelType: "tex",
+        //   mathfieldInstructions: {
+        //     method: "write",
+        //     content: "[$1]"
+        //   }
+        // }],
+        answerFormat: "tex",
+        identifiers: { type, commands },
+        ggbOptions: ggb.getOptions({
+            coords: [-15, 15, -15, 15],
+        }),
+        hint: `On rappelle que : 
+    
+- Une longueur se note $AB$ ;
+- Un segment se note $[AB]$ ;
+- Une demi-droite d'origine $A$ se note $[AB)$ ;
+- Une droite se note $(AB)$.
+`,
+        correction: `La figure tracée est ${type === 1
+            ? "un segment"
+            : type === 2
+                ? `une demi-droite d'origine ${startPointName}$`
+                : "une droite"}.
+    
+Cette figure se nomme donc $${answer}$.`,
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const name = answer
+        .replace("\\left(", "")
+        .replace("\\right)", "")
+        .replace("[", "")
+        .replace("]", "")
+        .replace(")", "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "[" + name + "]");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "[" + name + ")");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "\\left(" + name + "\\right)");
+    (0, exercise_1.tryToAddWrongProp)(propositions, name);
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { type, answer }) => {
+    const reversedAnswer = answer[0] + answer[2] + answer[1] + answer[3];
+    if (type === 2)
+        return ans === answer;
+    else {
+        return ans === answer || ans === reversedAnswer;
+    }
+};
+exports.basicShapesNaming = {
+    id: "basicShapesNaming",
+    connector: "=",
+    label: "Nommer un segment/une demi-droite/une droite",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBasicShapesNamingQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/shapes/basicShapesRecognition.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    type: number;
+    commands: string[];
+};
+export declare const basicShapesRecognition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=basicShapesRecognition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"basicShapesRecognition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/basicShapesRecognition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AAmExD,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicShapesRecognition = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const ray_1 = require("../../../../math/geometry/ray");
+const segment_1 = require("../../../../math/geometry/segment");
+const randint_1 = require("../../../../math/utils/random/randint");
+const randomLetter_1 = require("../../../../utils/strings/randomLetter");
+const getBasicShapesRecognitionQuestion = () => {
+    let answer = "";
+    const commands = [];
+    const type = (0, randint_1.randint)(0, 4);
+    switch (type) {
+        case 0: //point
+            answer = "Un point";
+            const point = point_1.PointConstructor.random((0, randomLetter_1.randomLetter)(true));
+            commands.push(...point.toGGBCommand());
+            break;
+        case 1: //segment
+            answer = "Un segment";
+            const segment = segment_1.SegmentConstructor.random();
+            commands.push(...segment.toGGBCommands(true));
+            break;
+        case 2: //demi-droite
+            answer = "Une demi-droite";
+            const ray = ray_1.RayConstructor.random();
+            commands.push(...ray.toGGBCommands(true));
+            break;
+        case 3: //droite
+        default:
+            answer = "Une droite";
+            const line = line_1.LineConstructor.random();
+            commands.push(...line.toGGBCommands(true));
+            break;
+    }
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    const question = {
+        answer,
+        instruction: `Quel est le type d'objet tracé ci-dessous ?`,
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { type, commands },
+        ggbOptions: ggb.getOptions({
+            coords: [-15, 15, -15, 15],
+        }),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un point", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Une droite", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Un segment", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Une demi-droite", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.basicShapesRecognition = {
+    id: "basicShapesRecognition",
+    connector: "=",
+    label: "Reconnaître un point / un segment / une demi-droite / une droite",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBasicShapesRecognitionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/shapes/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

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

@@ -0,0 +1,18 @@
+"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("./basicShapesRecognition"), exports);
+__exportStar(require("./basicShapesNaming"), exports);

package/lib/exercises/math/probaStat/conditionalProbability.d.ts

@@ -1,9 +1,11 @@
 import { Exercise } from "../../exercise";
 type Identifiers = {
     flip: number;
-    pA: number;
-    pB: number;
-    pAB: number;
+    pA?: number;
+    pB?: number;
+    pAB?: number;
+    pA_B?: number;
+    pB_A?: number;
 };
 export declare const conditionalProbability: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/probaStat/conditionalProbability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAIxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAuHF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAKxB,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAyNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/probaStat/conditionalProbability.js

@@ -6,62 +6,187 @@ const exercise_1 = require("../../exercise");
 const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
 const round_1 = require("../../../math/utils/round");
 const shuffle_1 = require("../../../utils/shuffle");
+const alignTex_1 = require("../../../utils/alignTex");
 const getConditionalProbability = () => {
-    const pA = (0, randint_1.randint)(2, 100);
-    const pB = (0, randint_1.randint)(2, 100);
-    const pAB = (0, randint_1.randint)(1, Math.min(pA, pB));
-    const pA_B = (0, round_1.round)(pAB / pB, 2);
-    const pB_A = (0, round_1.round)(pAB / pA, 2);
+    let pA, pB, pAB, pA_B, pB_A;
+    let pAStr, pBStr, pABStr, pA_BStr, pB_AStr;
     const flip = (0, randint_1.randint)(1, 7);
     let instruction = `On considère deux événements $A$ et $B$ tels que `;
     let startStatement = "";
     let answer = "";
+    let correction = "";
     switch (flip) {
         case 1: {
-            instruction += `$P(A) = ${(pA / 100 + "").replace(".", ",")}\\ $ et $\\ P(A \\cap B) = ${(pAB / 100 + "").replace(".", ",")}$.$\\\\$Déterminer $P_A(B)$.`;
+            pA = (0, randint_1.randint)(2, 100);
+            pAB = (0, randint_1.randint)(1, pA);
+            pAStr = (pA / 100).frenchify();
+            pABStr = (pAB / 100).frenchify();
+            pB_AStr = (0, round_1.round)(pAB / pA, 2).frenchify();
+            instruction += `$P(A) = ${pAStr}\\ $ et $\\ P(A \\cap B) = ${pABStr}$.$\\\\$Déterminer $P_A(B)$ (arrondir au centième).`;
             startStatement = `P_A(B)`;
-            answer = `${pB_A}`;
+            answer = pB_AStr;
+            correction = `
+On sait que : 
+
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+$$
+P_A(B) = \\frac{${pABStr}}{${pAStr}} \\approx ${answer}
+$$
+      `;
             break;
         }
         case 2: {
-            instruction += `$P(B) = ${(pB / 100 + "").replace(".", ",")}\\ $ et $\\ P(B \\cap A) = ${(pAB / 100 + "").replace(".", ",")}$.$\\\\$Déterminer $P_B(A)$.`;
+            pB = (0, randint_1.randint)(2, 100);
+            pAB = (0, randint_1.randint)(1, pB);
+            pBStr = (pB / 100).frenchify();
+            pABStr = (pAB / 100).frenchify();
+            pA_BStr = (0, round_1.round)(pAB / pB, 2).frenchify();
+            instruction += `$P(B) = ${pBStr}\\ $ et $\\ P(B \\cap A) = ${pABStr}$.$\\\\$Déterminer $P_B(A)$ (arrondir au centième).`;
             startStatement = `P_B(A)`;
-            answer = `${pA_B}`;
+            answer = pA_BStr;
+            correction = `
+On sait que : 
+
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+$$
+P_B(A) = \\frac{${pABStr}}{${pBStr}} \\approx ${answer}
+$$
+      `;
             break;
         }
         case 3: {
-            instruction += `$P(A) = ${(pA / 100 + "").replace(".", ",")}\\ $ et $\\ P_A(B) = ${(pB_A + "").replace(".", ",")}$.$\\\\$Déterminer $P(A \\cap B)$.`;
+            pA = (0, randint_1.randint)(2, 100);
+            pAStr = (pA / 100).frenchify();
+            pB_A = (0, randint_1.randint)(1, pA);
+            pB_AStr = (pB_A / 100).frenchify();
+            pAB = (0, round_1.round)((pB_A * pA) / 10000, 2);
+            pABStr = pAB.frenchify();
+            instruction += `$P(A) = ${pAStr}\\ $ et $\\ P_A(B) = ${pB_AStr}$.$\\\\$Déterminer $P(A \\cap B)$ (arrondir au centième).`;
             startStatement = `P(A \\cap B)`;
-            answer = `${pAB / 100}`;
+            answer = pABStr;
+            correction = `
+On sait que : 
+      
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+${(0, alignTex_1.alignTex)([
+                ["P(A \\cap B)", "=", "P_A(B)\\times P(A)"],
+                ["", "=", `${pB_AStr}\\times ${pAStr}`],
+                ["", "\\approx", answer],
+            ])}
+            `;
             break;
         }
         case 4: {
-            instruction += `$P(B) = ${(pB / 100 + "").replace(".", ",")}\\ $ et $\\ P_B(A) = ${(pA_B + "").replace(".", ",")}$.$\\\\$Déterminer $P(A \\cap B)$.`;
+            pB = (0, randint_1.randint)(2, 100);
+            pBStr = (pB / 100).frenchify();
+            pA_B = (0, randint_1.randint)(1, pB);
+            pA_BStr = pA_B.frenchify();
+            pAB = (0, round_1.round)((pA_B * pB) / 10000, 2);
+            pABStr = pAB.frenchify();
+            instruction += `$P(B) = ${pBStr}\\ $ et $\\ P_B(A) = ${pA_BStr}$.$\\\\$Déterminer $P(A \\cap B)$ (arrondir au centième).`;
             startStatement = `P(A \\cap B)`;
-            answer = `${pAB / 100}`;
+            answer = pABStr;
+            correction = `
+On sait que : 
+      
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+${(0, alignTex_1.alignTex)([
+                ["P(A \\cap B)", "=", "P_B(A)\\times P(B)"],
+                ["", "=", `${pA_BStr}\\times ${pBStr}`],
+                ["", "\\approx", answer],
+            ])}
+            `;
             break;
         }
         case 5: {
-            instruction += `$P(A \\cap B) = ${(pAB / 100 + "").replace(".", ",")}\\ $ et $\\ P_B(A) = ${(pA_B + "").replace(".", ",")}$.$\\\\$Déterminer $P(B)$.`;
+            pA_B = (0, randint_1.randint)(1, 100);
+            pAB = (0, randint_1.randint)(1, pA_B);
+            pABStr = (pAB / 100).frenchify();
+            pA_BStr = (pA_B / 100).frenchify();
+            pB = (0, round_1.round)(pAB / pA_B, 2);
+            pBStr = pB.frenchify();
+            instruction += `$P(A \\cap B) = ${pABStr}\\ $ et $\\ P_B(A) = ${pA_BStr}$.$\\\\$Déterminer $P(B)$ (arrondir au centième).`;
             startStatement = `P(B)`;
-            answer = `${pB / 100}`;
+            answer = pBStr;
+            correction = `
+On sait que : 
+      
+$$
+P_B(A) = \\frac{P(A \\cap B)}{P(B)}
+$$
+
+On a donc : 
+
+${(0, alignTex_1.alignTex)([
+                ["P(B)", "=", "\\frac{P(A\\cap B)}{P_B(A)}"],
+                ["", "=", `\\frac{${pABStr}}{${pA_BStr}}`],
+                ["", "\\approx", answer],
+            ])}
+            `;
             break;
         }
         case 6: {
-            instruction += `$P(A \\cap B) = ${(pAB / 100 + "").replace(".", ",")}\\ $ et $\\ P_A(B) = ${(pB_A + "").replace(".", ",")}$.$\\\\$Déterminer $P(A)$.`;
+            pB_A = (0, randint_1.randint)(1, 100);
+            pAB = (0, randint_1.randint)(1, pB_A);
+            pABStr = (pAB / 100).frenchify();
+            pB_AStr = (pB_A / 100).frenchify();
+            pA = (0, round_1.round)(pAB / pB_A, 2);
+            pAStr = pA.frenchify();
+            instruction += `$P(A \\cap B) = ${pABStr}\\ $ et $\\ P_A(B) = ${pB_AStr}$.$\\\\$Déterminer $P(A)$ (arrondir au centième).`;
             startStatement = `P(A)`;
-            answer = `${pA / 100}`;
+            answer = pAStr;
+            correction = `
+On sait que : 
+      
+$$
+P_A(B) = \\frac{P(A \\cap B)}{P(A)}
+$$
+
+On a donc : 
+
+${(0, alignTex_1.alignTex)([
+                ["P(A)", "=", "\\frac{P(A\\cap B)}{P_A(B)}"],
+                ["", "=", `\\frac{${pABStr}}{${pB_AStr}}`],
+                ["", "\\approx", answer],
+            ])}
+            `;
             break;
         }
     }
-    answer = answer.replace(".", ",");
     const question = {
         instruction,
         startStatement,
         answer,
         keys: ["p", "cap", "underscore"],
         answerFormat: "tex",
-        identifiers: { flip, pA, pAB, pB },
+        identifiers: { flip, pA, pAB, pB, pA_B, pB_A },
+        hint: `Pour deux événements $M$ et $N$, on a: 
+    
+$$
+P_M(N) = \\frac{P(M \\cap N)}{P(M)}
+$$
+`,
+        correction,
     };
     return question;
 };
@@ -89,4 +214,5 @@ exports.conditionalProbability = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA6EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA8EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.js

@@ -42,10 +42,9 @@ const getRecognizeArithmeticFromGraphQuestion = () => {
         ? new Array(10).fill(0).map((el, index) => firstAriTerm + reason * index)
         : getRandomFirstNonAriTerms();
     const answer = isAri ? "Oui" : "Non";
-    const commands = sequence.flatMap((nb, index) => [
-        new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand(),
-        `SetFixed(A_${index}, true)`,
-    ]);
+    const commands = sequence.flatMap((nb, index) => new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
+        showLabel: false,
+    }));
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
         lockedAxesRatio: false,

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAiDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}
+{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.js

@@ -14,10 +14,9 @@ const getRecognizeReasonFromGraphQuestion = () => {
         .map((el, index) => firstTerm + index * reason);
     const yMin = Math.min(...sequence.slice(0, 5));
     const yMax = Math.max(...sequence.slice(0, 5));
-    const commands = sequence.flatMap((nb, index) => [
-        new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand(),
-        `SetFixed(A_${index}, true)`,
-    ]);
+    const commands = sequence.flatMap((nb, index) => new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
+        showLabel: false,
+    }));
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands,
         xAxis: { natural: true },

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

@@ -0,0 +1,6 @@
+export type ToGGBCommandsProps = {
+    isFixed?: boolean;
+    showLabel?: boolean;
+    showUnderlyingPointsLabel?: boolean;
+};
+//# sourceMappingURL=toGGBCommandsProps.d.ts.map

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

@@ -0,0 +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;CACrC,CAAC"}

package/lib/exercises/utils/geogebra/toGGBCommandsProps.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/index.d.ts

@@ -967,6 +967,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     A: number[];
     B: number[];
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    commands: string[];
+}> | import("./exercises/exercise").Exercise<{
+    type: number;
+    commands: string[];
 }> | import("./exercises/exercise").Exercise<{
     coeffs: number[];
     to: string;
@@ -1097,9 +1103,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     questionType: string;
 }> | import("./exercises/exercise").Exercise<{
     flip: number;
-    pA: number;
-    pB: number;
-    pAB: number;
+    pA?: number | undefined;
+    pB?: number | undefined;
+    pAB?: number | undefined;
+    pA_B?: number | undefined;
+    pB_A?: number | undefined;
 }> | import("./exercises/exercise").Exercise<{
     isParityQuestion: boolean;
     isEvenQuestion: boolean;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAaA,OAAO,yBAAyB,CAAC;AAEjC,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

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

@@ -1,18 +1,26 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { EqualNode } from "../../tree/nodes/equations/equalNode";
 import { Point } from "./point";
 import { Vector } from "./vector";
+export declare abstract class LineConstructor {
+    static random(name?: string): Line;
+}
 export declare class Line {
     pointA: Point;
     pointB: Point;
     isVertical: boolean;
     a: AlgebraicNode | undefined;
     b: AlgebraicNode | undefined;
-    constructor(pointA: Point, pointB: Point);
+    name: string;
+    ggbName: string;
+    constructor(pointA: Point, pointB: Point, name?: string);
     getParallele(point: Point): Line;
     includes(point: Point, allowApprox?: boolean): boolean;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
     getCartesianEquation(): EqualNode;
+    toTex(): string;
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
 }
 //# sourceMappingURL=line.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;gBACjB,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAkBxC,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;CAsBlC"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAQjE,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAK5B;AACD,qBAAa,IAAI;IACf,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,UAAU,EAAE,OAAO,CAAC;IACpB,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAoBvD,YAAY,CAAC,KAAK,EAAE,KAAK;IASzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAgBnD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,KAAK;IAIL,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/line.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Line = void 0;
+exports.Line = exports.LineConstructor = void 0;
+const randomSegmentName_1 = require("../../exercises/utils/geometry/randomSegmentName");
 const equalNode_1 = require("../../tree/nodes/equations/equalNode");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
@@ -11,8 +12,16 @@ const variableNode_1 = require("../../tree/nodes/variables/variableNode");
 const randint_1 = require("../utils/random/randint");
 const point_1 = require("./point");
 const vector_1 = require("./vector");
+class LineConstructor {
+    static random(name) {
+        const names = (0, randomSegmentName_1.randomSegmentName)();
+        const points = point_1.PointConstructor.randomDifferent(names.split(""));
+        return new Line(points[0], points[1], name);
+    }
+}
+exports.LineConstructor = LineConstructor;
 class Line {
-    constructor(pointA, pointB) {
+    constructor(pointA, pointB, name) {
         this.getEquation = (u, a) => {
             const x = new variableNode_1.VariableNode("x");
             const y = new variableNode_1.VariableNode("y");
@@ -28,6 +37,8 @@ class Line {
         };
         this.pointA = pointA;
         this.pointB = pointB;
+        this.name = name ?? `\\left(${pointA.name}${pointB.name}\\right)`;
+        this.ggbName = name ?? `line_{${pointA.name}${pointB.name}}`;
         this.isVertical = pointA.x.equals(pointB.x);
         if (this.isVertical) {
             this.a = undefined;
@@ -80,5 +91,27 @@ class Line {
         const y = new variableNode_1.VariableNode("y");
         return new equalNode_1.EqualNode(new addNode_1.AddNode(new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), x).simplify(), new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(b), y).simplify()), new numberNode_1.NumberNode(c)).simplify({ forbidFactorize: true }), new numberNode_1.NumberNode(0));
     }
+    toTex() {
+        return this.name;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = {}) {
+        const commands = [
+            `${this.ggbName}=Line(${this.pointA.name},${this.pointB.name})`,
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
+        ];
+        if (shouldBuildPoints) {
+            const ACommands = this.pointA.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            const BCommands = this.pointB.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            commands.unshift(...ACommands, ...BCommands);
+        }
+        return commands;
+    }
 }
 exports.Line = Line;

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

@@ -1,5 +1,6 @@
 import { NodeIds } from "../../tree/nodes/node";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
 export declare abstract class PointConstructor {
     static random(name: string): Point;
     static randomDifferent(names: string[]): Point[];
@@ -29,6 +30,6 @@ export declare class Point {
     distanceTo(B: Point): number;
     equals(B: Point): boolean;
     isAligned(B: Point, C: Point): boolean;
-    toGGBCommand(): string;
+    toGGBCommand({ isFixed, showLabel }?: ToGGBCommandsProps): string[];
 }
 //# sourceMappingURL=point.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY;CAKb"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAY,MAAM,uBAAuB,CAAC;AAI1D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;IAMlC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;IAetC,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM;CAclC;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBACL,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa;IAM5D,KAAK,IAAI,MAAM;IAGf,aAAa;;;;;;;;;;IAQb,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAMpB,UAAU,IAAI,MAAM;IAMpB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,SAAM,GAAG,KAAK;IAiBrC,UAAU,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAM5B,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG,OAAO;IAGzB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK;IAM5B,YAAY,CAAC,EAAE,OAAc,EAAE,SAAgB,EAAE,GAAE,kBAAuB;CAO3E"}

package/lib/math/geometry/point.js

@@ -96,8 +96,12 @@ class Point {
         const AC = vector_1.VectorConstructor.fromPoints(this, C);
         return AB.isColinear(AC);
     }
-    toGGBCommand() {
-        return `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`;
+    toGGBCommand({ isFixed = true, showLabel = true } = {}) {
+        return [
+            `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`,
+            `SetFixed(${this.name},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
+        ];
     }
 }
 exports.Point = Point;

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

@@ -0,0 +1,15 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
+import { Point } from "./point";
+export declare abstract class RayConstructor {
+    static random(name?: string): Ray;
+}
+export declare class Ray {
+    startPoint: Point;
+    secondPoint: Point;
+    name: string;
+    ggbName: string;
+    constructor(startPoint: Point, secondPoint: Point, name?: string);
+    toTex(): string;
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
+}
+//# sourceMappingURL=ray.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ray.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/ray.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAElD,8BAAsB,cAAc;IAClC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;CAK5B;AAED,qBAAa,GAAG;IACd,UAAU,EAAE,KAAK,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,UAAU,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAOhE,KAAK;IAGL,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/ray.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ray = exports.RayConstructor = void 0;
+const randomSegmentName_1 = require("../../exercises/utils/geometry/randomSegmentName");
+const point_1 = require("./point");
+class RayConstructor {
+    static random(name) {
+        const names = (0, randomSegmentName_1.randomSegmentName)();
+        const points = point_1.PointConstructor.randomDifferent(names.split(""));
+        return new Ray(points[0], points[1], name);
+    }
+}
+exports.RayConstructor = RayConstructor;
+class Ray {
+    constructor(startPoint, secondPoint, name) {
+        this.startPoint = startPoint;
+        this.secondPoint = secondPoint;
+        this.name = name ?? `[${startPoint.name}${secondPoint.name})`;
+        this.ggbName = name ?? `ray_{${startPoint.name}${secondPoint.name}}`;
+    }
+    toTex() {
+        return this.name;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = {}) {
+        const commands = [
+            `${this.ggbName}=Ray(${this.startPoint.name},${this.secondPoint.name})`,
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
+        ];
+        if (shouldBuildPoints) {
+            const ACommands = this.startPoint.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            const BCommands = this.secondPoint.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            commands.unshift(...ACommands, ...BCommands);
+        }
+        return commands;
+    }
+}
+exports.Ray = Ray;

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

@@ -1,9 +1,16 @@
+import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
 import { Point } from "./point";
+export declare abstract class SegmentConstructor {
+    static random(): Segment;
+}
 export declare class Segment {
     pointA: Point;
     pointB: Point;
+    name: string;
+    ggbName: string;
     constructor(pointA: Point, pointB: Point);
     getLength(): number;
-    getName(): string;
+    toTex(): string;
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
 }
 //# sourceMappingURL=segment.d.ts.map

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,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;gBACF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAIxC,SAAS;IAGT,OAAO;CAMR"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AAEvF,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAElD,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;CAKd;AACD,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK;IAMxC,SAAS;IAGT,KAAK;IAGL,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/segment.js

@@ -1,16 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Segment = void 0;
+exports.Segment = exports.SegmentConstructor = void 0;
+const randomSegmentName_1 = require("../../exercises/utils/geometry/randomSegmentName");
+const point_1 = require("./point");
+class SegmentConstructor {
+    static random() {
+        const name = (0, randomSegmentName_1.randomSegmentName)();
+        const points = point_1.PointConstructor.randomDifferent(name.split(""));
+        return new Segment(points[0], points[1]);
+    }
+}
+exports.SegmentConstructor = SegmentConstructor;
 class Segment {
     constructor(pointA, pointB) {
         this.pointA = pointA;
         this.pointB = pointB;
+        this.name = `[${pointA.name}${pointB.name}]`;
+        this.ggbName = `segment_{${pointA.name}${pointB.name}}`;
     }
     getLength() {
         return this.pointA.distanceTo(this.pointB);
     }
-    getName() {
-        return `\\left[${this.pointA.name}, ${this.pointB.name}\\right]`;
+    toTex() {
+        return this.name;
+    }
+    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = {}) {
+        const commands = [
+            `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"})`,
+            `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
+        ];
+        if (shouldBuildPoints) {
+            const ACommands = this.pointA.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            const BCommands = this.pointB.toGGBCommand({
+                isFixed,
+                showLabel: showUnderlyingPointsLabel,
+            });
+            commands.unshift(...ACommands, ...BCommands);
+        }
+        return commands;
     }
 }
 exports.Segment = Segment;

package/lib/tree/parsers/isSegmentName.d.ts

@@ -0,0 +1,2 @@
+export declare const isSegmentName: (ans: string) => boolean;
+//# sourceMappingURL=isSegmentName.d.ts.map

package/lib/tree/parsers/isSegmentName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSegmentName.d.ts","sourceRoot":"","sources":["../../../src/tree/parsers/isSegmentName.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa,QAAS,MAAM,YAUxC,CAAC"}

package/lib/tree/parsers/isSegmentName.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSegmentName = void 0;
+const isLetter_1 = require("../../utils/strings/isLetter");
+//to use when the answer is a segment type [AB]
+const isSegmentName = (ans) => {
+    if (ans.length === 4 &&
+        ans[0] === "[" &&
+        ans[ans.length - 1] === "]" &&
+        (0, isLetter_1.isLetter)(ans[1]) &&
+        (0, isLetter_1.isLetter)(ans[2]))
+        return true;
+    return false;
+};
+exports.isSegmentName = isSegmentName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.2.19",
+  "version": "2.2.20",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [