diff --git a/create_document.sh b/create_document.sh
index 040231aafce2cde876ad34e4d03da58b06fd4380..79efdd12c40501c422db6402663c0d82fdcd5d59 100755
--- a/create_document.sh
+++ b/create_document.sh
@@ -2,4 +2,4 @@
 filename=$1
 output="${filename%.*}.pdf"
 
-pandoc --number-sections --table-of-contents -V geometry:margin=1in rapport.md -o rapport.pdf
\ No newline at end of file
+pandoc --number-sections --table-of-contents -V geometry:margin=1in readme.md -o readme.pdf
diff --git a/readme.md b/readme.md
index aef4cc43e6d4424e38b5a2ff1f943f11ada504fb..59ff6c8c66a63f51584d19249f8cd3f211744843 100644
--- a/readme.md
+++ b/readme.md
@@ -19,6 +19,7 @@ Ci-dessous un exemple du résultat attendu:
 ![Exemple ](./doc/screenshots/exemple.png){width=400px}
 
 # Solution analytique
+
 ## Minimisation de la fonction de coût 
 En premier lieux, nous avons cherchons à minimiser la fonction de coût (Erreur quadratique):
 
@@ -92,7 +93,7 @@ $b = -a\frac{B}{N} + \frac{D}{N} = -(\frac{CN - BD}{AN -  {B}^2})\frac{B}{N} + \
 
 $b = -(\frac{CNB - {B^2}D}{{AN^2} - {B^2}N}) + \frac{D}{N}$
 
-## Vérifiaction
+## Vérifications
 On peux tester nos deux formules dans un excel par exemple pour s'assurer de la justesse des transformation.
 
 On vas donc génerer un nuage de points suivant une droite, puis calculer nos deux formules en rentrant comme paramètre les differentes sommes de points. 
@@ -107,6 +108,7 @@ De cette façon, nous avons pû confirmer la qualité de nos calculs, mais aussi
 À partir de ce moment là, on en a déduit que les équations obtenues en **A** et **B** sont correcte.
 
 # Solution numérique
+
 ## Génération des points pseudo aléatoire
 Nous parlons de points pseudo aléatoire car, ils sont en réalité générés autour d'une fonction de droite tel que f() = ax+b avec une marge d'erreur entre 0 et 1 sur l'axe y.
 
@@ -117,8 +119,29 @@ En effet, de cette façon on s'assure que la droite que nous souhaitons retrouve
 ## Descente de gradient
 Pour trouver la meilleure droite passant par le nuage de points, nous devont appliquer la descente de gradient. En effet, c'est cette formule qui nous permettra de retrouver l'ordonnée à l'origine ainsi que la pente de la meilleur droite.
 
-Sur notre nuage de points nous avons appliqué la formule suivante:
-**Formule descente de gradient**
+Sur notre nuage de points nous avons appliqué la formule suivante :
+
+$\begin{pmatrix} ai+1 \\ bi+1 \end{pmatrix} = \begin{pmatrix} ai \\ bi \end{pmatrix}-\lambda*\vec{\nabla}E(ai,bi)$
+
+Chez nous, nous l'avons appliquée tel que :
+
+$\begin{pmatrix} ai+1 \\ bi+1 \end{pmatrix} = \begin{pmatrix} ai \\ bi \end{pmatrix} - \lambda * \vec{\nabla}E\begin{pmatrix} aA + bB -C \\ aB + Nb - D \end{pmatrix}$
+
+Pour rappel :
+
+$A = \sum{{x_{j}}^2}$
+
+$B = \sum{x_{j}}$
+
+$C = \sum{x_{j}}\sum{y_{j}}$
+
+$D = \sum{y_{j}}$
+
+et
+
+$\lambda$ = 0,001
+
+N = Nombre de point
 
 Et nous nous sommes arrêté quand le $\epsilon$ était inférieur à 0.001 ce qui représente environ 385 itération sur 30 points.
 
@@ -133,22 +156,32 @@ Il a donc fallu en premier temps séparer de manière aléatoire notre nuage de
 L'erreur quadratique va nous donner un indice de précision dans le calcul de la descente de gradient. Plus la valeur de l'erreur quadratique est petite, mieux c'est.
 
 En voici la formule :
-**Formule erreur quadratique**
+E(a,b) = $\sum_{j=1}^N (a * x_{j} + b - y_{j})^2$
 
 # Résultats
 Comme nous avons pu le voir dans les figures précédentes, nous avons obtenu des résultats concluents. J'entends pas là que aussi bien la droite obtenue sur la descente de gradient avec le nuage complet **et** les droits obtenues sur la validation croisée se ressemble et semblent juste au niveau de nos nuage de points.
 
-Voici un tableau des données obtenues sur une génération aléatoire:
+Voici un tableau des données obtenues:
+
+| Nuage de 30 points | Descente de gradient | Erreur quadratique | Groupe comparaison | Descente de gradient | Erreur quadratique |
+| :-- | :-- | :-- | :-- | :-- | :-- |
+| Complet       | 1.009172; 0.458943 | 3.338631 | - | - | - |
+| Groupe 0-1 | 1.050928; 0.451662 | 4.045180 | G2 | 1.050411; 0.313806 | 0.505211 |
+| Groupe 0-2 | 1.050928; 0.451662 | 1.265707 | G1 | 0.928786; 0.625360 | 0.717456 |
+| Groupe 1-2 | 0.953815; 0.847161 | 3.387789 | G0 | 1.050928; 0.451662 | 0.562148 |
+
+**Comparaison suite**
 
-| Nuage de 30 points | Descente de gradient | Différence | Erreur quadratique |
-| :-- | :-- | :-- | :-- |
-| Complet       | 1.012865; 0.437018 | - | 3.774071 |
-| Groupe 0 et 1 | 1.001448; 0.469333 | 0.011417; -0.032315 | 1.163377 |
-| Groupe 0 et 2 | 1.001448; 0.469333 | 0.011417; -0.032315 | 1.163377 |
-| Groupe 1 et 2 | 0.963636; 0.605260 | 0.049229; -0.168242 | 1.226093 |
+| Groupes | Différence Gradient | Différence d'erreur quadratique |
+| :-- | :-- | :-- |
+| Groupe 0-1 et G2 | -0.038394; -0.009297 | 1.092668 |
+| Groupe 0-2 et G1 | -0.024588; -0.042307 | 2.104142 |
+| Groupe 1-2 et G0 | 0.024588; 0.042307 | 0.654723 |
 
 On peut constater une différence de précision au niveau de l'erreur quadratique. En effet, l'erreur quadratique obtenue pendant la validation croisée par chacun des groupes sont bien plus petites que cette optenue sur le nuage complet. On peut en déduire qu'il est préférable de réaliser la descente de gradient sur des lots données pas trop volumineux et de vérifier l'écart de chacun des résultats afin de s'assurer que le résultat obtenu soit le plus juste possible.
 
+\newpage
+
 # Conclusion
 Pour conclure, nous sommes parvenu à retrouvé la meilleure droite passant par un nuage de point aléatoire. Ce qui était l'objectif final ce travail. Ce qui veut dire que les étapes intermédiaire pour arriver à ce point sont fonctionnels, à savoir: **la minisation de la fonction de coup** et la **descente de gradient**. Nous avons également pu faire une partie analyse des résultats via l'**erreur quadratique** et on peut donc en déduire que les résultats trouvé sont plutôt satisfaisant.
 
diff --git a/src/C/descente_radiant b/src/C/descente_radiant
index a79784d9b5937134b17f1bf27a703251e3323915..8930ad567b019b84b6f8ac177ea6d18249bff619 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 8c49297a43c5778406d09c1167164e300a3b02c1..aaaf2e5b1639eba64e1adb315842cefff7590e8e 100644
--- a/src/C/equation.c
+++ b/src/C/equation.c
@@ -52,7 +52,7 @@ vector_t descente_gradient(point_t* points, int N)
     double y = 0.0015; //0,000296189
 
     int cpt = 0;
-    while(norme(soustraction_vecteur(vnew,vold)) > 0.001) //0.00001
+    while(norme(soustraction_vecteur(vnew,vold)) > 0.00001) //0.00001
     {
         vold.x = vnew.x;
         vold.y = vnew.y;
diff --git a/src/C/group.c b/src/C/group.c
index 83d2479191d70d52be71bc17a4823410f5583ff0..91f7bb43355547841e28e15e3acea1a661c5ea8a 100644
--- a/src/C/group.c
+++ b/src/C/group.c
@@ -82,8 +82,7 @@ point_t* regroup(group_t *group, int cadran_a, int cadran_b) {
 
     point_t* result = malloc(sizeof(point_t) * nb_points);
     
-    for (int i = 0; i < nb_points/2; i++)
-    {
+    for (int i = 0; i < nb_points/2; i++) {
         result[i] = group->points[cadran_a][i];
         result[nb_points/2+i] = group->points[cadran_b][i];
     }
@@ -91,6 +90,17 @@ point_t* regroup(group_t *group, int cadran_a, int cadran_b) {
     return result;   
 }
 
+point_t* peek_group(group_t *group, int cadran) {
+    point_t* result = malloc(sizeof(point_t) * group->n_points_in_group);
+
+    for (int i = 0; i < group->n_points_in_group; i++)
+    {
+        result[i] = group->points[cadran][i];
+    }
+    
+    return result;
+}
+
 void print_group(group_t *group){
     printf("nb points %d ", group->n_points);
     printf("nb groups %d ", group->n_groups);
diff --git a/src/C/group.h b/src/C/group.h
index ee89a5d08db7c5c1284a7b77d149ac1e7aca0974..02b60f11955839cd9ccdee72c05a9e878374554c 100644
--- a/src/C/group.h
+++ b/src/C/group.h
@@ -9,6 +9,7 @@ typedef struct _group_t {
 
 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* peek_group(group_t *group, int cadran);
 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 b24e56760ed7bcacb4d539ac17a3fb1201c7327d..d493f8e2aecde635be0b7aa74abe601ad8123193 100644
--- a/src/C/main.c
+++ b/src/C/main.c
@@ -61,31 +61,58 @@ int main(int argc, char* argv[]) {
     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);
+   
+    point_t* G0 = peek_group(&groups, 0);
+    point_t* G1 = peek_group(&groups, 1);
+    point_t* G2 = peek_group(&groups, 2);
 
     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);
 
+    vector_t gradient_G0 = descente_gradient(G0, groups.n_points_in_group);
+    vector_t gradient_G1 = descente_gradient(G1, groups.n_points_in_group);
+    vector_t gradient_G2 = descente_gradient(G2, groups.n_points_in_group);
+
     // Faire la comparaison des gradients
     printf("----- Calcul des gradients -----\n");
     printf("Gradient nuage complet: %f; %f       ", droite_nuage.x, droite_nuage.y);
     printf("Erreur quadratique: %f\n", erreur_quadratique(droite_nuage.x, droite_nuage.y, nuage_points, nb_points));
 
-    printf("Gradient groupe 0-1: %f; %f       ", droite_0_1.x, droite_0_1.y);
-    printf("Erreur quadratique: %f\n", erreur_quadratique(droite_0_1.x, droite_0_1.y, groupe_0_1, groups.n_points_in_group));
+    printf("Gradient groupe 0-1:    %f; %f       ", droite_0_1.x, droite_0_1.y);
+    float erreur01 = erreur_quadratique(droite_0_1.x, droite_0_1.y, groupe_0_1, groups.n_points_in_group*2);
+    printf("Erreur quadratique: %f\n", erreur01);
+
+    printf("Gradient groupe 0-2:    %f; %f       ", droite_0_2.x, droite_0_2.y);
+    float erreur02 = erreur_quadratique(droite_0_2.x, droite_0_2.y, groupe_0_2, groups.n_points_in_group*2);
+    printf("Erreur quadratique: %f\n", erreur02);
 
-    printf("Gradient groupe 0-2: %f; %f       ", droite_0_2.x, droite_0_2.y);
-    printf("Erreur quadratique: %f\n", erreur_quadratique(droite_0_2.x, droite_0_2.y, groupe_0_2, groups.n_points_in_group));
+    printf("Gradient groupe 1-2:    %f; %f       ", droite_1_2.x, droite_1_2.y);
+    float erreur12 = erreur_quadratique(droite_1_2.x, droite_1_2.y, groupe_1_2, groups.n_points_in_group*2);
+    printf("Erreur quadratique: %f\n\n", erreur12);
 
-    printf("Gradient groupe 1-2: %f; %f       ", droite_1_2.x, droite_1_2.y);
-    printf("Erreur quadratique: %f\n", erreur_quadratique(droite_1_2.x, droite_1_2.y, groupe_1_2, groups.n_points_in_group));
+    printf("Gradient groupe G0: %f; %f       ", gradient_G0.x, gradient_G0.y);
+    float erreurG0 = erreur_quadratique(gradient_G0.x, gradient_G0.y, G0, groups.n_points_in_group);
+    printf("Erreur quadratique: %f\n", erreurG0);
+    printf("Gradient groupe G1: %f; %f       ", gradient_G1.x, gradient_G1.y);
+    float erreurG1 = erreur_quadratique(gradient_G1.x, gradient_G1.y, G1, groups.n_points_in_group);
+    printf("Erreur quadratique: %f\n", erreurG1);
+    printf("Gradient groupe G2: %f; %f       ", gradient_G2.x, gradient_G2.y);
+    float erreurG2 = erreur_quadratique(gradient_G2.x, gradient_G2.y, G2, groups.n_points_in_group);
+    printf("Erreur quadratique: %f\n", erreurG2);
 
     printf("\n");
     printf("----- Calcul des différence gradients en fonction des groupes -----\n");
-    printf("Différence gradient complet ET groupe 0-1: %f; %f \n", droite_nuage.x - droite_0_1.x, droite_nuage.y - droite_0_1.y);
-    printf("Différence gradient complet ET groupe 0-2: %f; %f \n", droite_nuage.x - droite_0_2.x, droite_nuage.y - droite_0_2.y);
-    printf("Différence gradient complet ET groupe 1-2: %f; %f \n", droite_nuage.x - droite_1_2.x, droite_nuage.y - droite_1_2.y);
+    printf("Différence gradient G2 ET groupe 0-1: %f; %f \n", gradient_G2.x - droite_0_1.x, gradient_G2.y - droite_0_1.y);
+    printf("Différence gradient G1 ET groupe 0-2: %f; %f \n", gradient_G1.x - droite_0_2.x, gradient_G1.y - droite_0_2.y);
+    printf("Différence gradient G0 ET groupe 1-2: %f; %f \n", gradient_G0.x - droite_1_2.x, gradient_G0.y - droite_1_2.y);
+
+    printf("\n");
+    printf("----- Calcul des différence des erreurs quadratique -----\n");
+    printf("Différence erreurs quadratique G2 ET groupe 0-1: %f \n", fabs(erreurG2 - erreur01));
+    printf("Différence erreurs quadratique G1 ET groupe 0-2: %f \n", fabs(erreurG1 - erreur02));
+    printf("Différence erreurs quadratique G0 ET groupe 1-2: %f \n", fabs(erreurG0 - erreur12));
 
     // Préparation à l'export
     point_t* nuage_AB = malloc(sizeof(point_t));
diff --git a/src/droite_nuage_0_1_A.vec b/src/droite_nuage_0_1_A.vec
index badc478a34e09966f1ee5b65a5667a6639f10c15..842287c2b65b171ec3da9cfa73420a787ff35a9d 100644
Binary files a/src/droite_nuage_0_1_A.vec 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
index 2ab48e35a0296fd62ac37740c4d1c89f20ec6724..d605680f9da71044bb0e249177aab3f4d8a4e11b 100644
Binary files a/src/droite_nuage_0_1_B.vec 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
index badc478a34e09966f1ee5b65a5667a6639f10c15..842287c2b65b171ec3da9cfa73420a787ff35a9d 100644
Binary files a/src/droite_nuage_0_2_A.vec 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
index 2ab48e35a0296fd62ac37740c4d1c89f20ec6724..d605680f9da71044bb0e249177aab3f4d8a4e11b 100644
Binary files a/src/droite_nuage_0_2_B.vec 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
index 5ca530f7e544414b2fc2994f999972f81ee40b4f..0dd17b5089658a6648a904d9467706fd6f8b3b6f 100644
Binary files a/src/droite_nuage_1_2_A.vec 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
index 32a0f7e57f1f15c57ac527e88ce21a6a3d6980da..7d1939eb347492d27dc4c7a3b5a2f127c9cc565a 100644
Binary files a/src/droite_nuage_1_2_B.vec 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
index 55f8771fea3d801a5fc4eaa2a9a744a5be2b2df2..1f987f5e25a128a813f8e9d298805eb6639a7c6c 100644
Binary files a/src/droite_nuage_complet_A.vec 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
index 298bee33a8e9ab38d230803ccb520d5a91220086..dfa3216ad6eca45a34825b194a1207d2a3bb214e 100644
Binary files a/src/droite_nuage_complet_B.vec and b/src/droite_nuage_complet_B.vec differ
diff --git a/src/points_X.vec b/src/points_X.vec
index 287604afb3266480a772e60e2f5a003599754fb5..54bc52036416ff8419aeb9743137fe6b5f2d446f 100644
Binary files a/src/points_X.vec and b/src/points_X.vec differ
diff --git a/src/points_Y.vec b/src/points_Y.vec
index 263fcd497bc38ee55be7cd6c11a839bd5413eb00..e0e7802bef5ad1f280daa51fb11e8b5dd9c1424f 100644
Binary files a/src/points_Y.vec and b/src/points_Y.vec differ