math-exercises 2.2.56 → 2.2.57

package/lib/index.d.ts

@@ -760,6 +760,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     trinomCoeffs: number[];
     isAskingPositive: boolean;
+}, {}> | import("./exercises/exercise").Exercise<{
+    aIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    bIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    cIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    isAsking: string;
 }, {}> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -941,9 +946,11 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     sideA: string;
     sideB: string;
     sideC: string;
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | import("./exercises/exercise").Exercise<{
     square: number;
     sideLengths: number[];
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
 }, {}> | import("./exercises/exercise").Exercise<{
     isRight: boolean;
     a: number;
@@ -952,12 +959,21 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     vertices: string[];
 }, {}> | import("./exercises/exercise").Exercise<{
     vertices: string[];
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+    xC: number;
+    yC: number;
+    factor: number;
 }, {}> | import("./exercises/exercise").Exercise<{
-    sideLengths: number[];
-    rand: number;
-    rand2: number;
-    isAskingC: boolean;
-}, {}> | import("./exercises/exercise").Exercise<{
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+    insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
+    segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
+    isPapillon: boolean;
+}, {
+    configurationType: string;
+}> | import("./exercises/exercise").Exercise<{
     randLetters: string[];
     vectors: string[];
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -1084,6 +1100,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     A: number[];
     B: number[];
+}, {}> | import("./exercises/exercise").Exercise<{
+    lengths: number[];
+}, {}> | import("./exercises/exercise").Exercise<{
+    points: import("./math/geometry/point").PointIdentifiers[];
+    startPoint: string;
+    translationPoints: string[];
 }, {}> | import("./exercises/exercise").Exercise<{
     type: number;
     commands: string[];
@@ -1249,6 +1271,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     colorAskedIndex: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     questionType: string;
+    value?: string | undefined;
+    color?: import("./exercises/utils/cardsData").CardsColor | undefined;
 }, {}> | import("./exercises/exercise").Exercise<{
     flip: number;
     pA?: number | undefined;
@@ -1260,6 +1284,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     isParityQuestion: boolean;
     isEvenQuestion: boolean;
     nbFaces: number;
+    faceAsked: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     type: number;
     A: number;
@@ -1300,12 +1325,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     isJustified: boolean;
+    cloudPointsIdentifiers: import("./math/geometry/CloudPoints").CloudPointsIdentifiers;
 }, {}> | import("./exercises/exercise").Exercise<{
     pA: number;
     pB: number;
     pUnion: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     questionType: string;
+    value?: string | undefined;
+    color?: string | undefined;
 }, {}> | import("./exercises/exercise").Exercise<{
     aCapB: number;
     aCapBBarre: number;
@@ -1327,6 +1355,13 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {
     allowNonIrreductible?: boolean | undefined;
 }> | import("./exercises/exercise").Exercise<{
+    exerciseVars: {
+        n: number;
+        k: number;
+        a: number;
+        b: number;
+    };
+}, {}> | import("./exercises/exercise").Exercise<{
     nX: number;
     a: number;
     b: number;
@@ -1335,13 +1370,14 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
 }, {}> | import("./exercises/exercise").Exercise<{
-    exerciseVars: {
-        n: number;
-        k: number;
-        a: number;
-        b: number;
-    };
-}, {}> | import("./exercises/exercise").Exercise<{
+    n: number;
+    p: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    interval: import("./tree/nodes/sets/intervalNode").IntervalNodeIdentifiers;
+    type: number;
+    isSentence: boolean;
+}, {
+    instructionType: string;
+}> | import("./exercises/exercise").Exercise<{
     firstValue: number;
     askedRank: number;
     reason: number;
@@ -1540,6 +1576,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     randSideQuestion: number;
 }, {}> | import("./exercises/exercise").Exercise<{
     angleValue: number;
+    angleIdentifiers: import("./tree/nodes/nodeConstructor").NodeIdentifiers;
+    point: string;
 }, {}> | import("./exercises/exercise").Exercise<{
     trigFunction: string;
     trigValue: number;
@@ -1683,12 +1721,21 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     isLog10: boolean;
 }, {}> | import("./exercises/exercise").Exercise<{
     vertices: string[];
+    xA: number;
+    yA: number;
+    xB: number;
+    yB: number;
+    xC: number;
+    yC: number;
+    factor: number;
 }, {}> | import("./exercises/exercise").Exercise<{
-    sideLengths: number[];
-    rand: number;
-    rand2: number;
-    isAskingC: boolean;
-}, {}> | import("./exercises/exercise").Exercise<{
+    triangleIdentifiers: import("./math/geometry/triangle").TriangleIdentifiers;
+    insidePointsIdentifiers: import("./math/geometry/point").PointIdentifiers[];
+    segmentAsked: import("./math/geometry/segment").SegmentIdentifiers;
+    isPapillon: boolean;
+}, {
+    configurationType: string;
+}> | import("./exercises/exercise").Exercise<{
     xA: number;
     xB: number;
     yA: number;
@@ -1872,7 +1919,12 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     firstReagentVariables: number[];
     secondReagentVariables: number[];
-}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
+}, {}> | import("./exercises/exercise").Exercise<{
+    instruction: string;
+    answer: string;
+    nA: number;
+    nB: number;
+}, {}> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     vA: number;
@@ -1911,7 +1963,10 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     r: number;
     R: number;
     isAsking: string;
-}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
+}, {}> | import("./exercises/exercise").Exercise<{
+    ggbCommands: string[];
+    type: string;
+}, {}> | import("./exercises/exercise").Exercise<{
     isAsking: string;
     uAB: number;
     uED: number;
@@ -1972,7 +2027,10 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
     variable: "P_in" | "P_out" | "η";
 }, {}> | import("./exercises/exercise").Exercise<{
     norm: number;
-}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
+}, {}> | import("./exercises/exercise").Exercise<{
+    ggbCommands: string[];
+    movementType: string;
+}, {}> | import("./exercises/exercise").Exercise<{
     distance: {
         value: number;
         unitIndex: number;
@@ -1981,7 +2039,10 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
         value: number;
         unitIndex: number;
     };
-}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
+}, {}> | import("./exercises/exercise").Exercise<{
+    typeOfAcceleration: string;
+    ggbCommands: string[];
+}, {}> | import("./exercises/exercise").Exercise<{
     object1: string;
     object2: string;
     reference: "à l'autre" | "au sol";
@@ -1993,6 +2054,7 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     epsilon: number;
     l: number;
+    molecule: string;
 }, {}> | import("./exercises/exercise").Exercise<{
     moleculeName: string;
     concentration: number;
@@ -2017,7 +2079,11 @@ declare const pcExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     atomicMass: number;
     atomicNumber: number;
-}, {}> | import("./exercises/exercise").Exercise<{}, {}> | import("./exercises/exercise").Exercise<{
+    isAsking: string;
+    symbol: string;
+}, {}> | import("./exercises/exercise").Exercise<{
+    commands: string[];
+}, {}> | import("./exercises/exercise").Exercise<{
     order: number;
     multiplier: number;
 }, {}> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

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

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

@@ -1,6 +1,9 @@
-import { Point } from "./point";
+import { Point, PointIdentifiers } from "./point";
 import { EqualNode } from "../../tree/nodes/equations/equalNode";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode";
+export type CloudPointsIdentifiers = {
+    pointsIdentifiers: PointIdentifiers[];
+};
 export declare abstract class CloudPointsConstructor {
     static random(nbPoints: number): CloudPoints;
     static randomLinear(nbPoints: number): CloudPoints;
@@ -8,6 +11,7 @@ export declare abstract class CloudPointsConstructor {
 export declare class CloudPoints {
     points: Point[];
     constructor(points: Point[]);
+    toIdentifiers(): CloudPointsIdentifiers;
     getFineAdjustement(): EqualNode;
     getCorrelationCoeff(): NumberNode;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,MAAM,SAAS,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAQ9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}
+{"version":3,"file":"CloudPoints.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/CloudPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAGjE,OAAO,EAAE,UAAU,EAAgB,MAAM,qCAAqC,CAAC;AAM/E,MAAM,MAAM,sBAAsB,GAAG;IACnC,iBAAiB,EAAE,gBAAgB,EAAE,CAAC;CACvC,CAAC;AACF,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM;IAQ9B,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM;CAyBrC;AAED,qBAAa,WAAW;IACtB,MAAM,EAAE,KAAK,EAAE,CAAC;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAI3B,aAAa,IAAI,sBAAsB;IAMvC,kBAAkB,IAAI,SAAS;IA8C/B,mBAAmB;CAsBpB"}

package/lib/math/geometry/CloudPoints.js

@@ -41,6 +41,11 @@ class CloudPoints {
     constructor(points) {
         this.points = points;
     }
+    toIdentifiers() {
+        return {
+            pointsIdentifiers: this.points.map((p) => p.toIdentifiers()),
+        };
+    }
     getFineAdjustement() {
         const xValues = this.points.map((element) => {
             return element.getXnumber();

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

@@ -1,10 +1,18 @@
 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 { AddNode } from "../../tree/nodes/operators/addNode";
+import { SubstractNode } from "../../tree/nodes/operators/substractNode";
+import { Point, PointIdentifiers } from "./point";
 import { Vector } from "./vector";
+export type LineIdentifiers = {
+    name?: string;
+    pointA: PointIdentifiers;
+    pointB: PointIdentifiers;
+};
 export declare abstract class LineConstructor {
     static random(name?: string): Line;
+    static fromIdentifiers(identifiers: LineIdentifiers): Line;
 }
 export declare class Line {
     pointA: Point;
@@ -13,15 +21,29 @@ export declare class Line {
     a: AlgebraicNode | undefined;
     b: AlgebraicNode | undefined;
     name: string;
+    unformatedName: string;
     ggbName: string;
     constructor(pointA: Point, pointB: Point, name?: string);
+    toIdentifiers(): {
+        name: string;
+        pointA: PointIdentifiers;
+        pointB: PointIdentifiers;
+    };
+    isParallele(line: Line): boolean;
     getParallele(point: Point): Line;
     includes(point: Point, allowApprox?: boolean): boolean;
     getRandomPoint(name?: string): Point;
     getEquation: (u: Vector, a: Point) => EqualNode;
     getCartesianEquation(): EqualNode;
+    toCartesian(): AddNode;
+    toCartesianCoeffs(): {
+        a: AlgebraicNode;
+        b: import("../../tree/nodes/functions/oppositeNode").OppositeNode;
+        c: SubstractNode;
+    };
     toTex(): string;
     toTexNoLeftRight(): string;
     toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, }?: ToGGBCommandsProps): string[];
+    intersect(line: Line, intersectName?: string): Point;
 }
 //# 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,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;IAenD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}
+{"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;AAGjE,OAAO,EAAE,OAAO,EAAO,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EACL,aAAa,EAEd,MAAM,0CAA0C,CAAC;AAKlD,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,MAAM,EAAqB,MAAM,UAAU,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,eAAe;IACnC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,MAAM;IAK3B,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,eAAe;CAOpD;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,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;gBACJ,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,EAAE,MAAM;IAsBvD,aAAa;;;;;IAOb,WAAW,CAAC,IAAI,EAAE,IAAI;IAStB,YAAY,CAAC,KAAK,EAAE,KAAK;IAWzB,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,GAAE,OAAe;IAenD,cAAc,CAAC,IAAI,CAAC,EAAE,MAAM;IAa5B,WAAW,MAAO,MAAM,KAAK,KAAK,KAAG,SAAS,CAmB5C;IAEF,oBAAoB,IAAI,SAAS;IAuBjC,WAAW;IAMX,iBAAiB;;;;;IAcjB,KAAK;IAGL,gBAAgB;IAIhB,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;IAqB5B,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,aAAa,CAAC,EAAE,MAAM;CAY7C"}

package/lib/math/geometry/line.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Line = exports.LineConstructor = void 0;
 const randomSegmentName_1 = require("../../exercises/utils/geometry/randomSegmentName");
 const equalNode_1 = require("../../tree/nodes/equations/equalNode");
+const oppositeNode_1 = require("../../tree/nodes/functions/oppositeNode");
 const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const addNode_1 = require("../../tree/nodes/operators/addNode");
 const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
 const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
 const substractNode_1 = require("../../tree/nodes/operators/substractNode");
 const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const generalSystem_1 = require("../systems/generalSystem");
 const randint_1 = require("../utils/random/randint");
 const point_1 = require("./point");
 const vector_1 = require("./vector");
@@ -18,6 +20,9 @@ class LineConstructor {
         const points = point_1.PointConstructor.randomDifferent(names.split(""));
         return new Line(points[0], points[1], name);
     }
+    static fromIdentifiers(identifiers) {
+        return new Line(point_1.PointConstructor.fromIdentifiers(identifiers.pointA), point_1.PointConstructor.fromIdentifiers(identifiers.pointB), identifiers.name);
+    }
 }
 exports.LineConstructor = LineConstructor;
 class Line {
@@ -37,6 +42,7 @@ class Line {
         };
         this.pointA = pointA;
         this.pointB = pointB;
+        this.unformatedName = name ?? `${pointA.name}${pointB.name}`;
         this.name = name ?? `\\left(${pointA.name}${pointB.name}\\right)`;
         this.ggbName = name ?? `line_{${pointA.name}${pointB.name}}`;
         this.isVertical = pointA.x.equals(pointB.x);
@@ -49,13 +55,31 @@ class Line {
             this.b = new substractNode_1.SubstractNode(this.pointA.y, new multiplyNode_1.MultiplyNode(this.a, this.pointA.x)).simplify();
         }
     }
+    toIdentifiers() {
+        return {
+            name: this.unformatedName,
+            pointA: this.pointA.toIdentifiers(),
+            pointB: this.pointB.toIdentifiers(),
+        };
+    }
+    isParallele(line) {
+        if (this.isVertical) {
+            return line.isVertical;
+        }
+        if (line.isVertical) {
+            return this.isVertical;
+        }
+        return this.a.equals(line.a);
+    }
     getParallele(point) {
         if (this.isVertical) {
-            throw Error("Parallel vertical lines not implemented");
+            const y = (0, addNode_1.add)(point.y, 1).simplify();
+            const secondPoint = new point_1.Point("P", point.x, y);
+            return new Line(point, secondPoint);
         }
         const x = new addNode_1.AddNode(point.x, new numberNode_1.NumberNode(1)).simplify();
         const y = new addNode_1.AddNode(point.y, this.a).simplify();
-        const secondPoint = new point_1.Point("D", x, y);
+        const secondPoint = new point_1.Point("P", x, y);
         return new Line(point, secondPoint);
     }
     includes(point, allowApprox = false) {
@@ -90,6 +114,21 @@ 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));
     }
+    toCartesian() {
+        const { a, b, c } = this.toCartesianCoeffs();
+        return (0, addNode_1.add)((0, addNode_1.add)((0, multiplyNode_1.multiply)(a, "x"), (0, multiplyNode_1.multiply)(b, "x")), c);
+    }
+    toCartesianCoeffs() {
+        //ax+by+c = 0
+        //u(-b,a)
+        //axA+byA+c = 0 donc c = -axA-byA
+        const u = vector_1.VectorConstructor.fromPoints(this.pointA, this.pointB);
+        const a = u.y;
+        const b = (0, oppositeNode_1.opposite)(u.x);
+        // const a = u.getYAsNumber();
+        const c = (0, substractNode_1.substract)((0, oppositeNode_1.opposite)((0, multiplyNode_1.multiply)(a, this.pointA.x)), (0, multiplyNode_1.multiply)(b, this.pointA.y));
+        return { a, b, c };
+    }
     toTex() {
         return this.name;
     }
@@ -115,5 +154,17 @@ class Line {
         }
         return commands;
     }
+    intersect(line, intersectName) {
+        if (line.isParallele(this))
+            throw Error("Lines are parallel");
+        const { a, b, c } = this.toCartesianCoeffs();
+        const { a: a2, b: b2, c: c2 } = line.toCartesianCoeffs();
+        const sys = new generalSystem_1.GeneralSystem([
+            [a, b, (0, oppositeNode_1.opposite)(c)],
+            [a2, b2, (0, oppositeNode_1.opposite)(c2)],
+        ]);
+        const solve = sys.solve();
+        return new point_1.Point(intersectName ?? "I", solve.x, solve.y);
+    }
 }
 exports.Line = Line;

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

@@ -1,8 +1,19 @@
-import { NodeIds } from "../../tree/nodes/node";
 import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
+import { NodeIdentifiers } from "../../tree/nodes/nodeConstructor";
+export type PointIdentifiers = {
+    id: "point";
+    name: string;
+    x: NodeIdentifiers;
+    y: NodeIdentifiers;
+};
 export declare abstract class PointConstructor {
-    static random(name: string): Point;
+    static random(name: string, min?: number, max?: number): Point;
+    static fromIdentifiers(identifiers: PointIdentifiers): Point;
+    static onSegment(A: Point, B: Point, name: string, { spacing, coefficient, }?: {
+        spacing?: number;
+        coefficient?: number;
+    }): Point;
     static randomDifferent(names: string[]): Point[];
     static fromGGBCommand(str: string): Point;
 }
@@ -12,16 +23,7 @@ export declare class Point {
     y: AlgebraicNode;
     constructor(name: string, x: AlgebraicNode, y: AlgebraicNode);
     toTex(): string;
-    toIdentifiers(): {
-        id: string;
-        name: string;
-        x: {
-            id: NodeIds;
-        } & Record<string, any>;
-        y: {
-            id: NodeIds;
-        } & Record<string, any>;
-    };
+    toIdentifiers(): PointIdentifiers;
     toTexWithCoords(): string;
     toCoords(): string;
     getXnumber(): number;
@@ -30,6 +32,6 @@ export declare class Point {
     distanceTo(B: Point): number;
     equals(B: Point): boolean;
     isAligned(B: Point, C: Point): boolean;
-    toGGBCommand({ isFixed, showLabel }?: ToGGBCommandsProps): string[];
+    toGGBCommand({ isFixed, showLabel, style, size, color, }?: 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;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;CAQ3E"}
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/point.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAG/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mDAAmD,CAAC;AACvF,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAG1C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;CACpB,CAAC;AACF,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAM,EAAE,GAAG,SAAK,GAAG,KAAK;IAMvD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;IAQpD,MAAM,CAAC,SAAS,CACd,CAAC,EAAE,KAAK,EACR,CAAC,EAAE,KAAK,EACR,IAAI,EAAE,MAAM,EACZ,EACE,OAAa,EACb,WAAW,GACZ,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAO;IAQpD,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,IAAI,gBAAgB;IAQjC,eAAe,IAAI,MAAM;IAGzB,QAAQ,IAAI,MAAM;IAIlB,UAAU,IAAI,MAAM;IAIpB,UAAU,IAAI,MAAM;IAIpB,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,EACX,OAAc,EACd,SAAgB,EAChB,KAAK,EACL,IAAI,EACJ,KAAK,GACN,GAAE,kBAAuB;CAiB3B"}

package/lib/math/geometry/point.js

@@ -6,12 +6,23 @@ const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
 const rational_1 = require("../numbers/rationals/rational");
 const vector_1 = require("./vector");
 const randint_1 = require("../utils/random/randint");
+const nodeConstructor_1 = require("../../tree/nodes/nodeConstructor");
+const randfloat_1 = require("../utils/random/randfloat");
 class PointConstructor {
-    static random(name) {
-        const x = (0, randint_1.randint)(-10, 11);
-        const y = (0, randint_1.randint)(-10, 11);
+    static random(name, min = -10, max = 11) {
+        const x = (0, randint_1.randint)(min, max);
+        const y = (0, randint_1.randint)(min, max);
         return new Point(name, new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y));
     }
+    static fromIdentifiers(identifiers) {
+        return new Point(identifiers.name, nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.x), nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.y));
+    }
+    static onSegment(A, B, name, { spacing = 0.1, coefficient, } = {}) {
+        const coeff = coefficient ?? (0, randfloat_1.randfloat)(spacing, 1 - spacing);
+        const vector = vector_1.VectorConstructor.fromPoints(A, B).times(coeff.toTree());
+        const point = vector.getEndPoint(A, name);
+        return point;
+    }
     static randomDifferent(names) {
         const res = [];
         const points = [];
@@ -63,14 +74,10 @@ class Point {
         return `\\left(${this.x.toTex()};${this.y.toTex()}\\right)`;
     }
     getXnumber() {
-        if (this.x.type !== node_1.NodeType.number)
-            throw Error("general point not implemented yet");
-        return this.x.value;
+        return this.x.evaluate();
     }
     getYnumber() {
-        if (this.y.type !== node_1.NodeType.number)
-            throw Error("general point not implemented yet");
-        return this.y.value;
+        return this.y.evaluate();
     }
     midpoint(B, name = "I") {
         const types = [this.x.type, this.y.type, B.x.type, B.y.type];
@@ -96,13 +103,22 @@ class Point {
         const AC = vector_1.VectorConstructor.fromPoints(this, C);
         return AB.isColinear(AC);
     }
-    toGGBCommand({ isFixed = true, showLabel = true } = {}) {
-        return [
+    toGGBCommand({ isFixed = true, showLabel = true, style, size, color, } = {}) {
+        const commands = [
             `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()})`,
             `SetFixed(${this.name},${isFixed ? "true" : "false"})`,
             `ShowLabel(${this.name},${showLabel ? "true" : "false"})`,
-            `SetPointStyle(${this.name}, 1)`,
         ];
+        if (style !== undefined) {
+            commands.push(`SetPointStyle(${this.name}, ${style})`);
+        }
+        if (size) {
+            commands.push(`SetPointSize(${this.name}, ${size})`);
+        }
+        if (color) {
+            commands.push(`SetColor(${this.name}, "${color}")`);
+        }
+        return commands;
     }
 }
 exports.Point = Point;

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

@@ -1,7 +1,12 @@
 import { ToGGBCommandsProps } from "../../exercises/utils/geogebra/toGGBCommandsProps";
-import { Point } from "./point";
+import { Point, PointIdentifiers } from "./point";
+export type SegmentIdentifiers = {
+    pointA: PointIdentifiers;
+    pointB: PointIdentifiers;
+};
 export declare abstract class SegmentConstructor {
     static random(): Segment;
+    static fromIdentifiers(identifiers: SegmentIdentifiers): Segment;
 }
 export declare class Segment {
     pointA: Point;
@@ -9,8 +14,13 @@ export declare class Segment {
     name: string;
     ggbName: string;
     constructor(pointA: Point, pointB: Point);
+    toIdentifiers(): {
+        pointA: PointIdentifiers;
+        pointB: PointIdentifiers;
+    };
     getLength(): number;
     toTex(): string;
+    toInsideName(): 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,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"}
+{"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,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEpE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;CAC1B,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAKb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAMvD;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;IAOxC,aAAa;;;;IAMb,SAAS;IAGT,KAAK;IAGL,YAAY;IAGZ,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,GACjC,GAAE,kBAAuB;CAoB7B"}

package/lib/math/geometry/segment.js

@@ -9,6 +9,9 @@ class SegmentConstructor {
         const points = point_1.PointConstructor.randomDifferent(name.split(""));
         return new Segment(points[0], points[1]);
     }
+    static fromIdentifiers(identifiers) {
+        return new Segment(point_1.PointConstructor.fromIdentifiers(identifiers.pointA), point_1.PointConstructor.fromIdentifiers(identifiers.pointB));
+    }
 }
 exports.SegmentConstructor = SegmentConstructor;
 class Segment {
@@ -18,12 +21,21 @@ class Segment {
         this.name = `[${pointA.name}${pointB.name}]`;
         this.ggbName = `segment_{${pointA.name}${pointB.name}}`;
     }
+    toIdentifiers() {
+        return {
+            pointA: this.pointA.toIdentifiers(),
+            pointB: this.pointB.toIdentifiers(),
+        };
+    }
     getLength() {
         return this.pointA.distanceTo(this.pointB);
     }
     toTex() {
         return this.name;
     }
+    toInsideName() {
+        return `${this.pointA.name}${this.pointB.name}`;
+    }
     toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,