math-exercises 2.2.18 → 2.2.20

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/exercises/utils/geogebra/toolBarConstructor.d.ts

@@ -5,5 +5,6 @@ export declare const toolBarConstructor: (options: {
     orthogonal?: boolean;
     intersect?: boolean;
     vector?: boolean;
+    circleTwoPoints?: boolean;
 }) => string;
 //# sourceMappingURL=toolBarConstructor.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,WASA,CAAC"}
+{"version":3,"file":"toolBarConstructor.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geogebra/toolBarConstructor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,YAAa;IAC1C,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,WAUA,CAAC"}

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

@@ -15,6 +15,8 @@ const toolBarConstructor = (options) => {
         customToolBar += "||5";
     if (options.vector)
         customToolBar += "||7";
+    if (options.circleTwoPoints)
+        customToolBar += "||10";
     return customToolBar;
 };
 exports.toolBarConstructor = toolBarConstructor;

package/lib/exercises/utils/geometry/randomSegmentName.d.ts

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

package/lib/exercises/utils/geometry/randomSegmentName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomSegmentName.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/geometry/randomSegmentName.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,cAI7B,CAAC"}

package/lib/exercises/utils/geometry/randomSegmentName.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSegmentName = void 0;
+const randomLetter_1 = require("../../../utils/strings/randomLetter");
+const randomSegmentName = () => {
+    const A = (0, randomLetter_1.randomLetter)(true);
+    const B = (0, randomLetter_1.randomLetter)(true, [A]);
+    return `${A}${B}`;
+};
+exports.randomSegmentName = randomSegmentName;

package/lib/index.d.ts

@@ -964,6 +964,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     width: number;
     height: number;
     angle: number;
+}> | 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;
@@ -1094,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): boolean;
+    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;IAarB,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;
@@ -47,11 +58,20 @@ class Line {
         const secondPoint = new point_1.Point("D", x, y);
         return new Line(point, secondPoint);
     }
-    includes(point) {
+    includes(point, allowApprox = false) {
         if (this.isVertical) {
-            return point.x.equals(this.pointA.x);
+            if (allowApprox) {
+            }
+            else
+                return point.x.equals(this.pointA.x);
+        }
+        const evaluation = new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({});
+        console.log("eval", evaluation);
+        if (allowApprox) {
+            return Math.abs(evaluation) < 0.0000001;
         }
-        return (new substractNode_1.SubstractNode(point.y, new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(this.a, point.x), this.b)).evaluate({}) === 0);
+        else
+            return evaluation === 0;
     }
     //! caution: simplify ne gère pas bien ici
     getRandomPoint(name) {
@@ -71,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,8 +1,10 @@
 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[];
+    static fromGGBCommand(str: string): Point;
 }
 export declare class Point {
     name: string;
@@ -28,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;CAevC;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

@@ -27,6 +27,16 @@ class PointConstructor {
         }
         return res;
     }
+    static fromGGBCommand(str) {
+        const formatted = str.replace(" ", "");
+        const name = formatted.split("=")[0];
+        const [x, y] = formatted
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .split(",");
+        return new Point(name, new numberNode_1.NumberNode(Number(x)), new numberNode_1.NumberNode(Number(y)));
+    }
 }
 exports.PointConstructor = PointConstructor;
 class Point {
@@ -86,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

@@ -0,0 +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;
+    toTex(): string;
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
+}
+//# sourceMappingURL=segment.d.ts.map

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

@@ -0,0 +1 @@
+{"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"}