math-exercises 2.2.55 → 2.2.57

package/lib/exercises/pc/motion/typeOfMovement.d.ts

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

package/lib/exercises/pc/motion/typeOfMovement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeOfMovement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkHtB,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"typeOfMovement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAkHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/pc/motion/typeOfMovement.js

@@ -18,7 +18,7 @@ const getTypeOfMovementQuestion = () => {
         }),
         keys: [],
         answerFormat: "raw",
-        identifiers: {},
+        identifiers: { movementType: exo.answer, ggbCommands: ggb.commands },
     };
     return question;
 };

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts

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

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAmHtB,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAcvE,CAAC"}
+{"version":3,"file":"recognizeRefractionOrReflectionAngles.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/recognizeRefractionOrReflectionAngles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAmHF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAcvE,CAAC"}

package/lib/exercises/pc/recognizeRefractionOrReflectionAngles.js

@@ -27,7 +27,7 @@ const getRecognizeRefractionOrReflectionAnglesQuestion = () => {
             coords: exo.coords,
         }),
         answerFormat: "raw",
-        identifiers: {},
+        identifiers: { commands: exo.commands },
     };
     return question;
 };

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

@@ -2,5 +2,8 @@ export type ToGGBCommandsProps = {
     isFixed?: boolean;
     showLabel?: boolean;
     showUnderlyingPointsLabel?: boolean;
+    style?: number;
+    size?: number;
+    color?: string;
 };
 //# sourceMappingURL=toGGBCommandsProps.d.ts.map

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

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

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

@@ -6,5 +6,9 @@ export declare const toolBarConstructor: (options: {
     intersect?: boolean;
     vector?: boolean;
     circleTwoPoints?: boolean;
+    circleRadius?: boolean;
+    segment?: boolean;
+    segmentFixed?: boolean;
+    polygon?: 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;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B,WAUA,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;IAC1B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,WAcA,CAAC"}

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

@@ -17,6 +17,14 @@ const toolBarConstructor = (options) => {
         customToolBar += "||7";
     if (options.circleTwoPoints)
         customToolBar += "||10";
+    if (options.segment)
+        customToolBar += "||15";
+    if (options.segmentFixed)
+        customToolBar += "||45";
+    if (options.circleRadius)
+        customToolBar += "||34";
+    if (options.polygon)
+        customToolBar += "||16";
     return customToolBar;
 };
 exports.toolBarConstructor = toolBarConstructor;

package/lib/exercises/utils/getDistinctQuestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,EAAE,GAAG,CAAC,MAC/B,MAAM,QACJ,MAAM,wBACS,SAAS,GAAG,EAAE,GAAG,CAAC,MAAM,SAAS,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,kBAC1E,SAAS,GAAG,EAAE,GAAG,CAAC,EAapB,CAAC"}
+{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,EAAE,GAAG,CAAC,MAC/B,MAAM,QACJ,MAAM,wBACS,SAAS,GAAG,EAAE,GAAG,CAAC,MAAM,SAAS,GAAG,EAAE,GAAG,CAAC,KAAK,OAAO,kBAC1E,SAAS,GAAG,EAAE,GAAG,CAAC,EAapB,CAAC"}

package/lib/exercises/utils/getDistinctQuestions.js

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDistinctQuestions = exports.equalTab = void 0;
+const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
 function equalTab(array1, array2) {
     if (!array1 && !array2)
         return true;
@@ -38,8 +42,11 @@ const compare = (q1, q2, discriminator) => {
     if (!!discriminator) {
         return discriminator(q1, q2);
     }
-    return (q1.instruction === q2.instruction &&
-        q1.answer === q2.answer &&
-        (!q1.ggbOptions?.commands ||
-            equalTab(q1.ggbOptions?.commands, q2.ggbOptions?.commands)));
+    return (0, lodash_isequal_1.default)(q1.identifiers, q2.identifiers);
+    // return (
+    //   q1.instruction === q2.instruction &&
+    //   q1.answer === q2.answer &&
+    //   (!q1.ggbOptions?.commands ||
+    //     equalTab(q1.ggbOptions?.commands, q2.ggbOptions?.commands!))
+    // );
 };

package/lib/index.d.ts

@@ -137,6 +137,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     xValues: any[];
     yValues: any[];
     type: number;
+}, {}> | import("./exercises/exercise").Exercise<{
+    xValues: number[];
+    yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -757,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;
@@ -938,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;
@@ -949,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<{
@@ -1081,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[];
@@ -1165,9 +1190,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }, {}> | import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
-}, {}> | import("./exercises/exercise").Exercise<{
-    xValues: number[];
-    yValues: number[];
 }, {}> | import("./exercises/exercise").Exercise<{
     evolution: number;
 }, {}> | import("./exercises/exercise").Exercise<{
@@ -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;
@@ -1314,7 +1342,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     event: string;
     type: string;
     probaFrac: number[];
-}, {}> | import("./exercises/exercise").Exercise<{
+}, {
+    allowNonIrreductible?: boolean | undefined;
+}> | import("./exercises/exercise").Exercise<{
     aCapB: number;
     aCapBBarre: number;
     aBarreCapB: number;
@@ -1325,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;
@@ -1333,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;
@@ -1538,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;
@@ -1681,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;
@@ -1870,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;
@@ -1909,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;
@@ -1970,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;
@@ -1979,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";
@@ -1991,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;
@@ -2015,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;