diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000000000000000000000000000000000..691a8f68f405ccdc2ba08296bd21c804bbec2ff3
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+ "C_Cpp.errorSquiggles": "Disabled"
+}
\ No newline at end of file
diff --git a/readme.md b/readme.md
index 5456a9195ef9d6b1b1a87b87a0f6a3bb4d9b2378..8649ee4add25f59e0a83387034a9b5c14cdc81a9 100644
--- a/readme.md
+++ b/readme.md
@@ -25,8 +25,12 @@ Ci-dessous un exemple du résultat attendu, à savoir, connaitre la meilleure dr
{width=400px}
# Méthodes employée
-## Solution analytique - Merci le tableur
+## Solution analytique
+En premier lieux, nous avons cherchons à minimiser la fonction de coût:
+E(a,b) = $\sum_{j=1}^n (a * x_{j} + b - y_{i})^2$
+
+En résolvant le système de deux équations à deux inconnues.
## Solution numérique
diff --git a/src/A.vec b/src/A.vec
deleted file mode 100644
index a6a679093490675048789b4ccee8b71dcb191b83..0000000000000000000000000000000000000000
Binary files a/src/A.vec and /dev/null differ
diff --git a/src/B.vec b/src/B.vec
deleted file mode 100644
index f97fff96ca1a8e1b554d609631f3e76f8fc5658d..0000000000000000000000000000000000000000
Binary files a/src/B.vec and /dev/null differ
diff --git a/src/C/Makefile b/src/C/Makefile
index 2f864567cfc566a393a67cc07aea328e4b132a0e..fc74fd190f53aaf6fcc726a86e1422f89dedb6d0 100644
--- a/src/C/Makefile
+++ b/src/C/Makefile
@@ -2,7 +2,7 @@ CC=gcc
CFLAGS=-Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=undefined -fsanitize=address
LDFLAGS=-lm
-FOLDER = ./
+FOLDER = .
SOURCES = $(wildcard $(FOLDER)/*.c)
OBJECTS = $(SOURCES:.c=.o)
diff --git a/src/C/descente_radiant b/src/C/descente_radiant
index 5fed5929b323f03ff4e5525d4da7043206b9dbca..da6cbfd170b8013f32fe8b83e44adf542fd1eb38 100755
Binary files a/src/C/descente_radiant and b/src/C/descente_radiant differ
diff --git a/src/C/equation.c b/src/C/equation.c
index 83bc9bd04ca47672dec00468ab222d8db035a304..24736049da175c52937db8dc8c8369a531225906 100644
--- a/src/C/equation.c
+++ b/src/C/equation.c
@@ -1,6 +1,6 @@
#include "equation.h"
-double get_random() {
+double get_random_between_0_and_1() {
return ((double)(rand() % (RND_MAX + 1 - RND_MIN) + RND_MIN))/1; // non rabatu entre 0 et 1 pour un meilleur résultat visuel
}
@@ -11,28 +11,17 @@ int get_random_int(int min, int max) {
void generate_points(point_t* points, int N) {
for(int i = 0; i < N; i++){
point_t pt;
- pt.x = (i * GRAPH_X) / NB_POINTS; // -nan and inf, get_random() work
- pt.y = EQUATION_PENTE * pt.x + EQUATION_ORDO + get_random();
+ pt.x = (i * GRAPH_X) / NB_POINTS; // -nan and inf, get_random_between_0_and_1() work
+ pt.y = EQUATION_PENTE * pt.x + EQUATION_ORDO + get_random_between_0_and_1();
// printf("points[%d] = (point_t){.x=%f, .y=%f};\n", i, pt.x, pt.y);
points[i] = pt;
}
}
-void split_point_into_groups(point_t* points, point_t** groups, int n_points, int n_groups) {
- int cpt = 0;
-
- for (int i = 0; i < n_points; i++) {
- if(i % n_groups-1 == 0) {
- cpt++;
- }
-
- groups[cpt][i] = points[i];
- }
-}
-
void create_group(group_t *group, point_t* points, int n_points, int n_groups) {
group->n_points = n_points;
group->n_groups = n_groups;
+ group->n_points_in_group = (int)(n_points/n_groups);
group->points = malloc(sizeof(point_t*) * n_groups);
for (int i = 0; i < group->n_groups; i++) {
@@ -82,16 +71,17 @@ void create_group_random(group_t *group, point_t* points, int n_points, int n_gr
// generate group
group->n_points = n_points;
group->n_groups = n_groups;
+ group->n_points_in_group = (int)(n_points/n_groups);
group->points = malloc(sizeof(point_t*) * n_groups);
for (int i = 0; i < group->n_groups; i++) {
- group->points[i] = malloc(sizeof(point_t) * (int)(n_points/n_groups));
+ group->points[i] = malloc(sizeof(point_t) * group->n_points_in_group);
}
int cpt = 0;
int cpt2 = 0;
for (int i = 0; i < n_points; i++) {
- if(i % (int)(n_points/n_groups) == 0) {
+ if(i % group->n_points_in_group == 0) {
cpt++;
cpt2 = 0;
}
@@ -105,24 +95,27 @@ void create_group_random(group_t *group, point_t* points, int n_points, int n_gr
free(tmp);
}
-point_t* group(group_t *group, int a, int b) {
- int nb_points = (int)(group->n_points/group->n_groups) * 2; // 30 / 3 * 2 = 20
+point_t* regroup(group_t *group, int cadran_a, int cadran_b) {
+ int nb_points = group->n_points_in_group * 2; // 30 / 3 * 2 = 20
point_t* result = malloc(sizeof(point_t) * nb_points);
for (int i = 0; i < nb_points/2; i++)
{
- result[i] = group->points[a][i];
- result[nb_points/2+i] = group->points[b][i];
+ result[i] = group->points[cadran_a][i];
+ result[nb_points/2+i] = group->points[cadran_b][i];
}
return result;
}
void print_group(group_t *group){
+ printf("nb points %d ", group->n_points);
+ printf("nb groups %d ", group->n_groups);
+ printf("points per group %d \n", group->n_points_in_group);
for (int i = 0; i < group->n_groups; i++)
{
- for (int j = 0; j < (int)(group->n_points/group->n_groups); j++)
+ for (int j = 0; j < group->n_points_in_group; j++)
{
printf("[%d:%d] = %f,%f\n", i, j, group->points[i][j].x, group->points[i][j].y);
}
@@ -149,7 +142,7 @@ double erreur_quadratique(double a, double b, point_t* points, int nb_points) {
return res;
}
-vector_t descente_radian(point_t* points, int N)
+vector_t descente_gradient(point_t* points, int N)
{
double A = 0;
double B = 0;
@@ -163,7 +156,7 @@ vector_t descente_radian(point_t* points, int N)
D += points[i].y;
}
- printf("A = %f, B = %f, C = %f, D = %f\n",A,B,C,D);
+ // printf("A = %f, B = %f, C = %f, D = %f\n",A,B,C,D);
vector_t vold = {.x=1, .y=1};
vector_t vnew = {.x=2, .y=2}; //x = a , y = b
@@ -182,7 +175,7 @@ vector_t descente_radian(point_t* points, int N)
cpt++;
}
- printf("Iterations: %d\n",cpt);
+ // printf("Iterations: %d\n",cpt);
return vnew;
}
diff --git a/src/C/equation.h b/src/C/equation.h
index dfcf48a08d0f09532e46feaf313c9a5fe2c5f4b9..464d4b647ccc8572f0b792e3e3b73857027b9f83 100644
--- a/src/C/equation.h
+++ b/src/C/equation.h
@@ -21,7 +21,7 @@ typedef struct _point_t {
} point_t;
typedef struct _group_t {
- int n_points, n_groups;
+ int n_points, n_groups, n_points_in_group;
point_t **points;
} group_t;
@@ -31,26 +31,19 @@ typedef struct _vector_t {
} vector_t;
-double get_random();
+double get_random_between_0_and_1();
+int get_random_int(int min, int max);
void generate_points(point_t* points, int N);
-void split_point_into_groups(point_t* points, point_t** groups, int n_points, int n_groups);
-
-vector_t descente_radian(point_t* points, int N);
-
-vector_t direction_croissance();
+vector_t descente_gradient(point_t* points, int N);
double erreur_quadratique(double a, double b, point_t* points, int nb_points);
-double f(vector_t x); // test
-double fd(vector_t x); // test
-
// Gestion des groupes
void create_group(group_t *group, point_t* points, int n_points, int n_groups);
void create_group_random(group_t *group, point_t* points, int n_points, int n_groups);
-point_t* group(group_t *group, int a, int b);
-
+point_t* regroup(group_t *group, int cadran_a, int cadran_b);
void print_group(group_t *group);
void destroy_group(group_t *group);
diff --git a/src/C/main.c b/src/C/main.c
index 4657d7a265cb5276ed9c074e76a789961ff9ae9b..2e4f879a4fa989c2b64bdd0931fe3596caf3b488 100644
--- a/src/C/main.c
+++ b/src/C/main.c
@@ -8,7 +8,7 @@
int main(int argc, char* argv[]) {
srand( time( NULL ) );
- point_t* points;
+ point_t* nuage_points;
int nb_points = NB_POINTS;
@@ -19,76 +19,122 @@ int main(int argc, char* argv[]) {
nb_points--;
}
- points = malloc(sizeof(point_t)*nb_points);
- generate_points(points, nb_points);
+ nuage_points = malloc(sizeof(point_t)*nb_points);
+ generate_points(nuage_points, nb_points);
} else {
- points = malloc(sizeof(point_t)*NB_POINTS);
- points[0] = (point_t){.x=0.000000, .y=0.600000};
- points[1] = (point_t){.x=0.000000, .y=1.000000};
- points[2] = (point_t){.x=0.000000, .y=0.600000};
- points[3] = (point_t){.x=1.000000, .y=1.200000};
- points[4] = (point_t){.x=1.000000, .y=1.100000};
- points[5] = (point_t){.x=1.000000, .y=1.400000};
- points[6] = (point_t){.x=2.000000, .y=2.000000};
- points[7] = (point_t){.x=2.000000, .y=2.600000};
- points[8] = (point_t){.x=2.000000, .y=2.300000};
- points[9] = (point_t){.x=3.000000, .y=3.100000};
- points[10] = (point_t){.x=3.000000, .y=3.800000};
- points[11] = (point_t){.x=3.000000, .y=3.700000};
- points[12] = (point_t){.x=4.000000, .y=4.500000};
- points[13] = (point_t){.x=4.000000, .y=4.300000};
- points[14] = (point_t){.x=4.000000, .y=4.700000};
- points[15] = (point_t){.x=5.000000, .y=5.400000};
- points[16] = (point_t){.x=5.000000, .y=5.900000};
- points[17] = (point_t){.x=5.000000, .y=6.000000};
- points[18] = (point_t){.x=6.000000, .y=6.200000};
- points[19] = (point_t){.x=6.000000, .y=6.000000};
- points[20] = (point_t){.x=6.000000, .y=7.000000};
- points[21] = (point_t){.x=7.000000, .y=7.800000};
- points[22] = (point_t){.x=7.000000, .y=7.500000};
- points[23] = (point_t){.x=7.000000, .y=7.000000};
- points[24] = (point_t){.x=8.000000, .y=8.400000};
- points[25] = (point_t){.x=8.000000, .y=8.600000};
- points[26] = (point_t){.x=8.000000, .y=8.000000};
- points[27] = (point_t){.x=9.000000, .y=10.000000};
- points[28] = (point_t){.x=9.000000, .y=9.300000};
- points[29] = (point_t){.x=9.000000, .y=10.000000};
+ nuage_points = malloc(sizeof(point_t)*NB_POINTS);
+ nuage_points[0] = (point_t){.x=0.000000, .y=0.600000};
+ nuage_points[1] = (point_t){.x=0.000000, .y=1.000000};
+ nuage_points[2] = (point_t){.x=0.000000, .y=0.600000};
+ nuage_points[3] = (point_t){.x=1.000000, .y=1.200000};
+ nuage_points[4] = (point_t){.x=1.000000, .y=1.100000};
+ nuage_points[5] = (point_t){.x=1.000000, .y=1.400000};
+ nuage_points[6] = (point_t){.x=2.000000, .y=2.000000};
+ nuage_points[7] = (point_t){.x=2.000000, .y=2.600000};
+ nuage_points[8] = (point_t){.x=2.000000, .y=2.300000};
+ nuage_points[9] = (point_t){.x=3.000000, .y=3.100000};
+ nuage_points[10] = (point_t){.x=3.000000, .y=3.800000};
+ nuage_points[11] = (point_t){.x=3.000000, .y=3.700000};
+ nuage_points[12] = (point_t){.x=4.000000, .y=4.500000};
+ nuage_points[13] = (point_t){.x=4.000000, .y=4.300000};
+ nuage_points[14] = (point_t){.x=4.000000, .y=4.700000};
+ nuage_points[15] = (point_t){.x=5.000000, .y=5.400000};
+ nuage_points[16] = (point_t){.x=5.000000, .y=5.900000};
+ nuage_points[17] = (point_t){.x=5.000000, .y=6.000000};
+ nuage_points[18] = (point_t){.x=6.000000, .y=6.200000};
+ nuage_points[19] = (point_t){.x=6.000000, .y=6.000000};
+ nuage_points[20] = (point_t){.x=6.000000, .y=7.000000};
+ nuage_points[21] = (point_t){.x=7.000000, .y=7.800000};
+ nuage_points[22] = (point_t){.x=7.000000, .y=7.500000};
+ nuage_points[23] = (point_t){.x=7.000000, .y=7.000000};
+ nuage_points[24] = (point_t){.x=8.000000, .y=8.400000};
+ nuage_points[25] = (point_t){.x=8.000000, .y=8.600000};
+ nuage_points[26] = (point_t){.x=8.000000, .y=8.000000};
+ nuage_points[27] = (point_t){.x=9.000000, .y=10.000000};
+ nuage_points[28] = (point_t){.x=9.000000, .y=9.300000};
+ nuage_points[29] = (point_t){.x=9.000000, .y=10.000000};
}
group_t groups;
- create_group_random(&groups, points, nb_points, 3);
- print_group(&groups);
+ create_group_random(&groups, nuage_points, nb_points, 3);
+ point_t* groupe_0_1 = regroup(&groups, 0, 1);
+ point_t* groupe_0_2 = regroup(&groups, 0, 2);
+ point_t* groupe_1_2 = regroup(&groups, 1, 2);
- // Exemple of grouping two groups
- point_t* yes = group(&groups, 0, 1);
+ vector_t droite_nuage = descente_gradient(nuage_points, nb_points);
+ vector_t droite_0_1 = descente_gradient(groupe_0_1, groups.n_points_in_group);
+ vector_t droite_0_2 = descente_gradient(groupe_0_2, groups.n_points_in_group);
+ vector_t droite_1_2 = descente_gradient(groupe_1_2, groups.n_points_in_group);
- for (int i = 0; i < 20; i++)
- {
- printf("%f, %f\n", yes[i].x, yes[i].y);
- }
-
- vector_t resAB = descente_radian(points, nb_points);
- point_t* AB = malloc(sizeof(point_t));
- *AB = (point_t){resAB.x, resAB.y};
- printf("gradient(%f,%f)\n", resAB.x, resAB.y);
-
- double_vector_t *X = create_vector_x(points, nb_points);
- double_vector_t *Y = create_vector_y(points, nb_points);
- double_vector_t *A = create_vector_x(AB, 1);
- double_vector_t *B = create_vector_y(AB, 1);
-
- export_vector("../X.vec", X);
- export_vector("../Y.vec", Y);
- export_vector("../A.vec", A);
- export_vector("../B.vec", B);
-
- free(points);
- free(AB);
-
- destroy_vector(&X);
- destroy_vector(&Y);
- destroy_vector(&A);
- destroy_vector(&B);
+ // Faire la comparaison des gradient
+ printf("Gradient nuage complet: %f;%f\n", droite_nuage.x, droite_nuage.y);
+ printf("Gradient ground 0-1: %f;%f\n", droite_0_1.x, droite_0_1.y);
+ printf("Gradient ground 0-2: %f;%f\n", droite_0_2.x, droite_0_2.y);
+ printf("Gradient ground 1-2: %f;%f\n", droite_1_2.x, droite_1_2.y);
+
+ // Préparation à l'export
+ point_t* nuage_AB = malloc(sizeof(point_t));
+ *nuage_AB = (point_t){droite_nuage.x, droite_nuage.y};
+
+ point_t* nuage_0_1 = malloc(sizeof(point_t));
+ *nuage_0_1 = (point_t){droite_0_1.x, droite_0_1.y};
+
+ point_t* nuage_0_2 = malloc(sizeof(point_t));
+ *nuage_0_2 = (point_t){droite_0_2.x, droite_0_2.y};
+
+ point_t* nuage_1_2 = malloc(sizeof(point_t));
+ *nuage_1_2 = (point_t){droite_1_2.x, droite_1_2.y};
+
+ double_vector_t *points_X = create_vector_x(nuage_points, nb_points);
+ double_vector_t *points_Y = create_vector_y(nuage_points, nb_points);
+
+ double_vector_t *droite_nuage_complet_A = create_vector_x(nuage_AB, 1);
+ double_vector_t *droite_nuage_complet_B = create_vector_y(nuage_AB, 1);
+
+ double_vector_t *droite_nuage_0_1_A = create_vector_x(nuage_0_1, 1);
+ double_vector_t *droite_nuage_0_1_B = create_vector_y(nuage_0_1, 1);
+ double_vector_t *droite_nuage_0_2_A = create_vector_x(nuage_0_2, 1);
+ double_vector_t *droite_nuage_0_2_B = create_vector_y(nuage_0_2, 1);
+ double_vector_t *droite_nuage_1_2_A = create_vector_x(nuage_1_2, 1);
+ double_vector_t *droite_nuage_1_2_B = create_vector_y(nuage_1_2, 1);
+
+ export_vector("../points_X.vec", points_X);
+ export_vector("../points_Y.vec", points_Y);
+
+ export_vector("../droite_nuage_complet_A.vec", droite_nuage_complet_A);
+ export_vector("../droite_nuage_complet_B.vec", droite_nuage_complet_B);
+
+ export_vector("../droite_nuage_0_1_A.vec", droite_nuage_0_1_A);
+ export_vector("../droite_nuage_0_1_B.vec", droite_nuage_0_1_B);
+
+ export_vector("../droite_nuage_0_2_A.vec", droite_nuage_0_2_A);
+ export_vector("../droite_nuage_0_2_B.vec", droite_nuage_0_2_B);
+
+ export_vector("../droite_nuage_1_2_A.vec", droite_nuage_1_2_A);
+ export_vector("../droite_nuage_1_2_B.vec", droite_nuage_1_2_B);
+
+
+ free(nuage_points);
+ free(nuage_AB);
+ free(nuage_0_1);
+ free(nuage_0_2);
+ free(nuage_1_2);
+
+ free(groupe_0_1);
+ free(groupe_0_2);
+ free(groupe_1_2);
+
+ destroy_vector(&points_X);
+ destroy_vector(&points_Y);
+ destroy_vector(&droite_nuage_complet_A);
+ destroy_vector(&droite_nuage_complet_B);
+
+ destroy_vector(&droite_nuage_0_1_A);
+ destroy_vector(&droite_nuage_0_1_B);
+ destroy_vector(&droite_nuage_0_2_A);
+ destroy_vector(&droite_nuage_0_2_B);
+ destroy_vector(&droite_nuage_1_2_A);
+ destroy_vector(&droite_nuage_1_2_B);
destroy_group(&groups);
}
\ No newline at end of file
diff --git a/src/Python/display.py b/src/Python/display.py
index e9a74c7b9d5860689cdd1513bd871e74617a0543..d549a9dedc1e02090caa66cad5a0a3561b4122aa 100644
--- a/src/Python/display.py
+++ b/src/Python/display.py
@@ -3,19 +3,18 @@ from numpy.lib.npyio import loadtxt
from load_vec import load_vector
import numpy as np
-X_nuage_point = load_vector("../X.vec")
-Y_nuage_point = load_vector("../Y.vec")
+X_nuage_point = load_vector("../points_X.vec")
+Y_nuage_point = load_vector("../points_Y.vec")
-A = load_vector("../A.vec") #
-B = load_vector("../B.vec") #
+droite_nuage_complet_A = load_vector("../droite_nuage_complet_A.vec")
+droite_nuage_complet_B = load_vector("../droite_nuage_complet_B.vec")
# Nuage de points
-plt.scatter(X_nuage_point, Y_nuage_point, marker='x', label="Points")
-
+plt.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
# Meilleure droite
x = np.array(range(int(max(X_nuage_point))+1))
-y = x * A + B
+y = x * droite_nuage_complet_A + droite_nuage_complet_B
plt.plot(x, y, label="Meilleure droite", color="red")
diff --git a/src/Python/plot_groups.py b/src/Python/plot_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0fbf3ac463be6e23ed5ab3a3054d7e8aa4bc88f
--- /dev/null
+++ b/src/Python/plot_groups.py
@@ -0,0 +1,37 @@
+from matplotlib import pyplot as plt
+from numpy.lib.npyio import loadtxt
+from load_vec import load_vector
+import numpy as np
+
+fig, (ax1, ax2, ax3) = plt.subplots(3)
+fig.suptitle('Vertically stacked subplots')
+
+X_nuage_point = load_vector("../points_X.vec")
+Y_nuage_point = load_vector("../points_Y.vec")
+
+droite_nuage_0_1_A = load_vector("../droite_nuage_0_1_A.vec")
+droite_nuage_0_1_B = load_vector("../droite_nuage_0_1_B.vec")
+
+droite_nuage_0_2_A = load_vector("../droite_nuage_0_2_A.vec")
+droite_nuage_0_2_B = load_vector("../droite_nuage_0_2_B.vec")
+
+droite_nuage_1_2_A = load_vector("../droite_nuage_1_2_A.vec")
+droite_nuage_1_2_B = load_vector("../droite_nuage_1_2_B.vec")
+
+x = np.array(range(int(max(X_nuage_point))+1))
+y = x * droite_nuage_0_1_A + droite_nuage_0_1_B
+ax1.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
+ax1.plot(x, y, label="Meilleure droite", color="red")
+
+x = np.array(range(int(max(X_nuage_point))+1))
+y = x * droite_nuage_0_2_A + droite_nuage_0_2_B
+ax2.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
+ax2.plot(x, y, label="Meilleure droite", color="red")
+
+x = np.array(range(int(max(X_nuage_point))+1))
+y = x * droite_nuage_1_2_A + droite_nuage_1_2_B
+ax3.scatter(X_nuage_point, Y_nuage_point, marker='.', label="Points")
+ax3.plot(x, y, label="Meilleure droite", color="red")
+
+
+plt.show()
diff --git a/src/X.vec b/src/X.vec
deleted file mode 100644
index 54bc52036416ff8419aeb9743137fe6b5f2d446f..0000000000000000000000000000000000000000
Binary files a/src/X.vec and /dev/null differ
diff --git a/src/Y.vec b/src/Y.vec
deleted file mode 100644
index 751528d5a89c18ac0bb86bbd30891859a31bc200..0000000000000000000000000000000000000000
Binary files a/src/Y.vec and /dev/null differ
diff --git a/src/droite_nuage_0_1_A.vec b/src/droite_nuage_0_1_A.vec
new file mode 100644
index 0000000000000000000000000000000000000000..633c9dede1dc05e81c2d97d9e07f278086b6852b
Binary files /dev/null and b/src/droite_nuage_0_1_A.vec differ
diff --git a/src/droite_nuage_0_1_B.vec b/src/droite_nuage_0_1_B.vec
new file mode 100644
index 0000000000000000000000000000000000000000..ffde9feab1659a3383dce10f9e96cfc341450c23
Binary files /dev/null and b/src/droite_nuage_0_1_B.vec differ
diff --git a/src/droite_nuage_0_2_A.vec b/src/droite_nuage_0_2_A.vec
new file mode 100644
index 0000000000000000000000000000000000000000..633c9dede1dc05e81c2d97d9e07f278086b6852b
Binary files /dev/null and b/src/droite_nuage_0_2_A.vec differ
diff --git a/src/droite_nuage_0_2_B.vec b/src/droite_nuage_0_2_B.vec
new file mode 100644
index 0000000000000000000000000000000000000000..ffde9feab1659a3383dce10f9e96cfc341450c23
Binary files /dev/null and b/src/droite_nuage_0_2_B.vec differ
diff --git a/src/droite_nuage_1_2_A.vec b/src/droite_nuage_1_2_A.vec
new file mode 100644
index 0000000000000000000000000000000000000000..df9acc25cb4281b3d7a94d30102b122e9e335f01
Binary files /dev/null and b/src/droite_nuage_1_2_A.vec differ
diff --git a/src/droite_nuage_1_2_B.vec b/src/droite_nuage_1_2_B.vec
new file mode 100644
index 0000000000000000000000000000000000000000..59a9014c6e8abca8f001faffe2517a8d0c8cd500
Binary files /dev/null and b/src/droite_nuage_1_2_B.vec differ
diff --git a/src/droite_nuage_complet_A.vec b/src/droite_nuage_complet_A.vec
new file mode 100644
index 0000000000000000000000000000000000000000..d8f49ece08a9eaa1b3792313d20759bbabc4a7e7
Binary files /dev/null and b/src/droite_nuage_complet_A.vec differ
diff --git a/src/droite_nuage_complet_B.vec b/src/droite_nuage_complet_B.vec
new file mode 100644
index 0000000000000000000000000000000000000000..6ef0b30b0bee7415acc2c087b7d8d7e8210f9edb
Binary files /dev/null and b/src/droite_nuage_complet_B.vec differ
diff --git a/src/points_X.vec b/src/points_X.vec
new file mode 100644
index 0000000000000000000000000000000000000000..52a86345c51e18e82764569f2a8243396b3060ac
Binary files /dev/null and b/src/points_X.vec differ
diff --git a/src/points_Y.vec b/src/points_Y.vec
new file mode 100644
index 0000000000000000000000000000000000000000..399d6972f133ffc25dfb7d2686e2ff68586c3b1d
Binary files /dev/null and b/src/points_Y.vec differ