diff --git a/Makefile b/Makefile
index 1821e5e82ffc600f141d495af72ac389d95ae9cb..0dcc3091c69a1e5712d3ae7cf89622e8cb1c8c12 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ LIBS=-lcunit -lm -lxml2
 
 all: prog
 
-prog:src/main.o src/regressionLin.o
+prog:src/main.o src/regressionLin.o src/vector.o
 	$(CC) $^ -o $@ $(LIBS) $(SANITIZERS) $(OPTIM_OPTS)
 
 %.o : %.c
diff --git a/prog b/prog
index 8659b5cfa0775c39eb8687b4a1a217c0879d990d..5e114ca1adbd545e7798c5e681d8c04a5f7291e7 100755
Binary files a/prog and b/prog differ
diff --git a/src/main.c b/src/main.c
index 11f9a15052b2c4b36f10322b74dd7497e768dcc1..f4e3c49d546985f2911c072ee11a8d784a926172 100644
--- a/src/main.c
+++ b/src/main.c
@@ -8,5 +8,43 @@
 
 int main() {
 
+  point pt0;
+  pt0.x=0;
+  pt0.y=0;
+
+  point pt1;
+  pt1.x=1;
+  pt1.y=1;
+
+  point pt2;
+  pt2.x=2;
+  pt2.y=2;
+
+  point pt3;
+  pt3.x=3;
+  pt3.y=3;
+
+  point pt4;
+  pt4.x=4;
+  pt4.y=4;
+
+  vector v;
+  vector_init(&v);
+  vector_push(&v,pt0);
+  vector_push(&v,pt1);
+  vector_push(&v,pt2);
+  vector_push(&v,pt3);
+  vector_push(&v,pt4);
+
+  point p = findBestDroite(v);
+  printf("Sol Analytique : %f %f\n",p.x,p.y);
+  point drt;
+  drt.x=1;
+  drt.y=0;
+  p = descenteGradient(0.00001,drt,v);
+  printf("Sol Numérique : %f %f\n",p.x,p.y);
+
+  vector_free(&v);
+
   return EXIT_SUCCESS;
 }
diff --git a/src/main.o b/src/main.o
index 82399091ac91c0bd190889bed3a65b312d61704d..65995157d7e47db285d3f2f5d61bdf31f4bee87f 100644
Binary files a/src/main.o and b/src/main.o differ
diff --git a/src/regressionLin.c b/src/regressionLin.c
index 19f80f703d684de5d824149bf01bf4bb64763a5d..a297cdeb801bd714881f4b9ceadedf2078dc9e25 100644
--- a/src/regressionLin.c
+++ b/src/regressionLin.c
@@ -1,36 +1,73 @@
 #include "regressionLin.h"
 
-droite findBestDroite(point* pts){
+point findBestDroite(vector pts){
   // dans le cas que l'on a vu en exercice on peut directement dire :
   // car c'est la même fonction de base
+  double gA=0; // somme des xi ^2
+  double gB=0; // somme des xi
+  double gC=0; // sommes des xi*yi
+  double gD=0; // somme des yi
+  double gN=pts.length; // nombre de points
+
+  for(int i = 0; i < pts.length; i++){
+    gA += pts.content[i].x * pts.content[i].x;
+    gB += pts.content[i].x;
+    gC += pts.content[i].x * pts.content[i].y;
+    gD += pts.content[i].y;
+  }
 
-  double gA=1; // somme des xi ^2
-  double gB=1; // somme des xi
-  double gC=1; // sommes des xi*yi
-  double gD=1; // somme des yi
-  double gN=2; // nombre de points
   double numerateur=gC * gN - gB * gD;
   double denominateur=gA * gN - gB * gB; // pas possible si = 0
   double a = numerateur / denominateur;
   double b = ( gC - a * gA ) / gB;
 
-  droite d;
-  d.a=a;
-  d.b=b;
+  point d;
+  d.x=a;
+  d.y=b;
   return d;
 }
 
-point minmethode1(point depart, point arrivee, droite fonction){
-  point pt;
-  return pt;
-}
 
-point solvSystem(droite dim1, droite dim2){
+point descenteGradient(double precision, point drt, vector pts){
   point pt;
-  return pt;
-}
+  pt.x = drt.x;
+  pt.y = drt.y;
+  double gradientx = 0;
+  double gradienty = 0;
+  double oldptx = 0;
+  double oldpty = 0;
+  double testSortie;
+
+  while(1){
+    gradientx = 0;
+    gradienty = 0;
+    testSortie = 0;
+
+
+    for(int i = 0; i < pts.length; i++){
+      gradientx += ((pts.content[i].x * pts.content[i].x) * drt.x) + (drt.y * pts.content[i].x) - (pts.content[i].x * pts.content[i].y);
+      gradienty += (drt.x * pts.content[i].x) - pts.content[i].y;
+    }
+    gradientx = gradientx*2;
+
+    gradienty += drt.y * pts.length;
+    gradienty = gradienty*2;
+
+    double lambda = 0.1;
+    //drt.x est a et drt.b est b
+    oldptx = pt.x;
+    oldpty = pt.y;
+
+    pt.x = drt.x - lambda *(gradientx);
+    pt.y = drt.y - lambda *(gradienty);
+
+
+    testSortie = sqrt(pow(pt.x - oldptx,2) + pow(pt.y - oldpty,2));
+
+    if(testSortie < precision){
+      break;
+    }
+  }
 
-point descenteGradient(int precision, droite drt){
-  point pt;
   return pt;
 }
diff --git a/src/regressionLin.h b/src/regressionLin.h
index f1902d644e3e63de45abb0414031ca5a2f6963cb..47b68a3529406475123dc84a31ff111e58881697 100644
--- a/src/regressionLin.h
+++ b/src/regressionLin.h
@@ -7,29 +7,15 @@
 #include <string.h>
 #include <math.h>
 
-typedef struct _point {
-    double x;
-    double y;
-} point;
-
-typedef struct _droite {
-    double a;
-    double b;
-} droite;
-
+#include "vector.h"
 
 // Analytique
-droite findBestDroite(point* pts);
+point findBestDroite(vector pts);
 // vérifier que ce que l'on trouve soit correct à l'exercice (on a déjà fait dans un exo)
 // on peut donc reprendre simplement A=.. et B=.. si la fonction de base ne change pas
 // sinon utilise solvSystem
 
-point minmethode1(point depart, point arrivee, droite fonction);
-// on doit faire ceci uniquement si la fonction de base à minimisé n'est plus la somme de a*x+b-y le tout au carré
-
-point solvSystem(droite dim1, droite dim2);//différentes méthodes vues en classe donc minmethode1 etc.
-
 // Numérique
-point descenteGradient(int precision, droite drt);
+point descenteGradient(double precision, point drt, vector pts);
 
 #endif
diff --git a/src/regressionLin.o b/src/regressionLin.o
index 8a66d8cb671cb37de211f2f370d1c391dc2f9096..e848455ca599c588cea6cc7e76440a0860701014 100644
Binary files a/src/regressionLin.o and b/src/regressionLin.o differ
diff --git a/src/vector.c b/src/vector.c
new file mode 100644
index 0000000000000000000000000000000000000000..4f02bab8ef3bbdf5b37a45593f9e58fd387b1bf8
--- /dev/null
+++ b/src/vector.c
@@ -0,0 +1,166 @@
+#include "vector.h"
+
+void vectorPrint(vector v){
+  for(int i=0;i<v.length;i++){
+    printf("%f %f",v.content[i].x,v.content[i].y);
+  }
+  printf("\n");
+}
+
+void printError(int index){
+    const char* error_code_names[] = {"ok", "out_of_bounds", "memory_error", "unitialized"};
+    printf("%s\n", error_code_names[index]);
+}
+
+error_code vector_init(vector* v){
+    error_code result = ok;
+
+    v->capacity = VECTOR_INIT_CAPACITY;
+    v->length = 0;
+    v->content = malloc(sizeof(type)*VECTOR_INIT_CAPACITY);
+
+    if (v->content == NULL)
+    {
+        result = uninitialized;
+    }
+    return result;
+}
+
+
+error_code vector_length(vector *v, int *length){
+    error_code result = ok;
+
+    if (length != NULL)
+    {
+        *length = v->length;
+    }else{
+        result = uninitialized;
+    }
+
+    return result;
+}
+
+error_code vector_push(vector *v, type element){
+    error_code result = ok;
+
+    if (v->length == v->capacity)
+    {
+        v->capacity = v->capacity * 2;
+        v->content = realloc(v->content, sizeof(type) * v->capacity);
+    }
+
+    v->content[v->length] = element;
+    v->length++;
+
+    return result;
+}
+
+error_code vector_pop(vector *v, type *element){
+    error_code result = ok;
+
+    *element = v->content[v->length-1];
+    point pt;
+    pt.x=0;
+    pt.y=0;
+    v->content[v->length-1] = pt;
+    v->length--;
+
+    if (v->length < v->capacity/4)
+    {
+        v->capacity = v->capacity / 2;
+        v->content = realloc(v->content, sizeof(type) * v->capacity);
+    }
+
+    return result;
+}
+
+error_code vector_set(vector *v, int index, type element){
+    error_code result = ok;
+
+    if (index < v->length && index >= 0)
+    {
+        v->content[index] = element;
+    } else {
+        result = out_of_bounds;
+    }
+
+    return result;
+}
+
+error_code vector_get(vector *v, int index, type *element){
+    error_code result = ok;
+
+    if (index < v->length && index >= 0)
+    {
+        *element = v->content[index];
+    } else {
+        result = out_of_bounds;
+    }
+
+    return result;
+}
+
+error_code vector_remove(vector *v, int index){
+    error_code result = ok;
+
+    if (index < v->length && index >= 0)
+    {
+        for (int i = index; i < v->length; i++)
+        {
+            v->content[i] = v->content[i+1];
+        }
+        v->length--;
+      if (v->length < v->capacity/4){
+        v->capacity = v->capacity / 2;
+        v->content = realloc(v->content, sizeof(type) * v->capacity);
+      }
+
+    } else {
+        result = out_of_bounds;
+    }
+
+    return result;
+}
+
+error_code vector_insert(vector *v, type element, int index){
+    error_code result = ok;
+
+    if (index < v->length && index >= 0){
+        if (v->length == v->capacity){
+        v->capacity = v->capacity * 2;
+        v->content = realloc(v->content, sizeof(type) * v->capacity);
+        }
+
+        for (int i = v->length-1; i >= index; i--){
+            v->content[i+1] = v->content[i];
+        }
+        v->content[index] = element;
+        v->length++;
+    }else{
+        result = out_of_bounds;
+    }
+
+    return result;
+}
+
+error_code vector_free(vector *v){
+    error_code result = ok;
+
+    if (v->content != NULL)
+    {
+        v->capacity = -1;
+        v->length = -1;
+        free(v->content);
+    }
+
+    return result;
+}
+
+error_code vector_empty(vector *v){
+  error_code error =uninitialized;
+  if(v->content!=NULL){
+    v->length=0;
+    error = ok;
+  }
+  return error;
+}
diff --git a/src/vector.h b/src/vector.h
new file mode 100644
index 0000000000000000000000000000000000000000..829019f27602da9b93b692c74e2296c0fa61d076
--- /dev/null
+++ b/src/vector.h
@@ -0,0 +1,64 @@
+/*
+Auteur : Simon Cirilli
+Projet : Outil de gestion de vecteurs
+Hesge 2019
+*/
+#ifndef VECTOR_H
+#define VECTOR_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <math.h>
+
+#define VECTOR_INIT_CAPACITY 4
+
+
+typedef struct _point {
+    double x;
+    double y;
+} point;
+
+typedef point type;
+
+typedef struct _vector {
+    type *content; // actual content of the vector
+    int capacity; // capacity allocated
+    int length; // actual length
+} vector;
+
+typedef enum error_code {
+    ok, out_of_bounds, memory_error, uninitialized
+} error_code;
+
+
+void printError(int index);
+
+void vectorPrint(vector v);
+
+error_code vector_init(vector *v);
+
+error_code vector_length(vector *v, int *length);
+
+error_code vector_push(vector *v, type element);
+
+error_code vector_pop(vector *v, type *element);
+
+error_code vector_set(vector *v, int index, type element);
+
+error_code vector_get(vector *v, int index, type *element);
+
+error_code vector_remove(vector *v, int index);
+
+error_code vector_insert(vector *v, type element, int index);
+
+error_code vector_empty(vector *v);
+
+error_code vector_free(vector *v);
+
+error_code vector_map(vector *v, type (*f)(type), vector *rhs);
+
+error_code vector_filter(vector *v, bool (*f)(type), vector *rhs);
+
+
+#endif
diff --git a/src/vector.o b/src/vector.o
new file mode 100644
index 0000000000000000000000000000000000000000..975b949e63c195d145badfa60e030d4dd1ef599c
Binary files /dev/null and b/src/vector.o differ