Evaluation.md

 ## Etendue et qualité de l'étude
 - Nombre de tris
-  - [ ] Insertion, Fusion, Rapide et au moins un autre tri sont traités.
+  - [x] Insertion, Fusion, Rapide et au moins un autre tri sont traités.
   - [ ] Insertion, Fusion et Rapide sont traités.
-  - [x] Insertion, Fusion et Rapide ne sont pas tous traités.
+  - [ ] Insertion, Fusion et Rapide ne sont pas tous traités.
 - Type de jeu de test
-  - [ ] Aléatoire, Trié, Tri inversé et au moins un autre jeu sont traités.
+  - [x] Aléatoire, Trié, Tri inversé et au moins un autre jeu sont traités.
   - [ ] Aléatoire, Trié et Tri inversé sont traités.
-  - [x] Aléatoire, Trié et Tri inversé ne sont pas tous traités.
+  - [ ] Aléatoire, Trié et Tri inversé ne sont pas tous traités.
 - Aspects
-  - [ ] Consommation mémoire et CPU sont traitées.
+  - [x] Consommation mémoire et CPU sont traitées.
   - [ ] Consommation mémoire ou CPU sont traitées.
-  - [x] Consommation mémoire et CPU ne sont pas traitées.
+  - [ ] Consommation mémoire et CPU ne sont pas traitées.
 - Qualité
   - [ ] L'absence de fuite mémoire a été expérimentalement vérifiée.
-  - [ ] Il n'y a pas de problème apparent de fuite mémoire.
-  - [x] Il y a des problèmes apparents de fuite mémoire.
+  - [x] Il n'y a pas de problème apparent de fuite mémoire.
+  - [ ] Il y a des problèmes apparents de fuite mémoire.
 
 ## Rédaction et analyses
 - Description du problème
   - [ ] La section est pertinente, succincte et précise.
-  - [ ] La section est pertinente.
-  - [x] La section n'est pas pertinente.
+  - [x] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
 - Application
-  - [ ] La section est pertinente, succincte et précise.
+  - [x] La section est pertinente, succincte et précise.
   - [ ] La section est pertinente.
-  - [x] La section n'est pas pertinente.
+  - [ ] La section n'est pas pertinente.
 - Environnement de test
-  - [ ] La section est pertinente, succincte et précise.
+  - [x] La section est pertinente, succincte et précise.
   - [ ] La section est pertinente.
-  - [x] La section n'est pas pertinente.
+  - [ ] La section n'est pas pertinente.
 - Description de la démarche systématique
-  - [ ] La section est pertinente, succincte et précise.
+  - [x] La section est pertinente, succincte et précise.
   - [ ] La section est pertinente.
-  - [x] La section n'est pas pertinente.			
+  - [] La section n'est pas pertinente.			
 - Analyse des résultats préalables
   - [ ] La section est pertinente, succincte et précise.
   - [ ] La section est pertinente.

TP1/Makefile

+all: main
+	
+main : tris.o utils.o main.c
+	gcc -o main -Wall utils.o tris.o -g main.c
+
+tris.o : tris.c tris.h
+	gcc -c -Wall -g tris.c
+
+utils.o : utils.c utils.h
+	gcc -c -Wall -g utils.c
+clean :
+	rm *.o

TP1/main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "tris.h"
+#include "utils.h"
+
+
+int main() {
+  long taille = (long) 100;
+
+  printf("Tri Insertion: \n");
+  long* triIns = malloc(sizeof(long) * taille);
+  listeAlea(triIns,100,300);
+  affichertab(triIns,100);
+  triInsertion(triIns,100);
+  affichertab(triIns,100);
+
+  free(triIns);
+
+  printf("Tri Rapide: \n");
+  long* triRap = malloc(sizeof(long) * taille);
+  listeAlea(triRap,100,300);
+  affichertab(triRap,100);
+  printf("Issou");
+  triRapide(triRap, 100);
+  affichertab(triRap,100);
+
+  free(triRap);
+
+  printf("Tri Fusion: \n");
+  long* triFus = malloc(sizeof(long) * taille);
+  listeAlea(triFus,100,300);
+  affichertab(triFus,100);
+  triFusion(triFus, 100);
+  affichertab(triFus,100);
+
+  free(triFus);
+
+  return 0;
+}

TP1/tridec.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tris.h"
+
+void triInsertionDec(long* A, size_t n) {
+    for(size_t i = 1; i <= n-1; i++){
+        long cle = A[i];
+        size_t j = i - 1;
+        size_t ecriture=0;
+        while(j+1 >= j && A[j] > cle){
+            ecriture++;
+            A[j+1] = A[j];
+            j = j-1;
+        }
+        ecriture++;
+        A[j+1] = cle;
+    }
+}
+
+void triFusionDec(long* A, size_t size) {
+  sousTriFusionDec(A, 0, size);
+}
+
+void sousTriFusionDec(long* A, size_t first, size_t size) {
+    if(first+1 <size){ // p < r - 1
+        size_t middle = floor((first+size)/2);
+        sousTriFusionDec(A, first, middle);
+        sousTriFusionDec(A, middle, size);
+        fusionDec(A, first, middle, size);
+    }
+}
+
+void copySousTableDec(long* mainT, long* underT, size_t id, size_t size) {
+  for(size_t i = id; i < id+size; ++i) {
+    underT[i-id] = mainT[i];
+  }
+}
+
+void fusionDec(long* A, size_t first, size_t middle, size_t size) {
+    size_t n1 = middle - first; // Nb elem dans A[p , q]  q exclu
+    size_t n2 = size - middle;  // Nb elem dans A[q , r]  r exclu
+
+    size_t indg = 0;
+    size_t indd = 0;
+
+    long* ag = malloc(sizeof(long) * n1);
+    long* ad = malloc(sizeof(long) * n2);
+
+    copySousTableDec(A, ag, first, n1);
+    copySousTableDec(A, ad, middle, n2);
+
+    int i = first;
+
+    while(i < size) {
+      if(indg == n1) {
+        A[i] = ad[indd];
+        indd++;
+      }
+      else if(indd == n2) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else if(ag[indg] < ad[indd]) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else {
+        A[i] = ad[indd];
+        indd++;
+      }
+      ++i;
+    }
+
+    free(ag);
+    free(ad);
+}
+
+void triRapideDec(long* A, size_t n) {
+    sousTriRapideDec(A,0,n);
+}
+
+void sousTriRapideDec(long* A, size_t first, size_t size){
+    if(first+1 < size){
+        size_t middle = partitionDec(A,first,size);
+        sousTriRapideDec(A,first,middle);
+        sousTriRapideDec(A,middle+1,size);
+    }
+}
+
+size_t partitionDec(long* A, size_t first, size_t size) {
+    long pivot = A[size-1];
+    size_t i = first;
+    for(int j = first; j+2 <= size; j++){
+        if(A[j] <= pivot){
+            permuterDec(A,i,j);
+            i++;
+        }
+    }
+    permuterDec(A,i,size-1);
+    return i;
+}
+
+void permuterDec(long* A,size_t i,size_t j) {
+    long inter = A[i];
+    A[i] = A[j];
+    A[j] = inter;
+}

TP1/tridec.h

+#ifndef TRIS_H
+#define TRIS_H
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertionDec(long* A, size_t n);
+
+void triFusionDec(long* A, size_t size);
+void sousTriFusionDec(long* A, size_t first, size_t size);
+void fusionDec(long* A, size_t first, size_t middle, size_t size);
+
+void triRapideDec(long* A, size_t n);
+void sousTriRapideDec(long* A, size_t first, size_t size);
+size_t partitionDec(long* A, size_t first, size_t size);
+void permuterDec(long* A,size_t i,size_t j);
+
+#endif //TRIS_H
\ No newline at end of file

TP1/tris.c

+#include <math.h>
+#include "tris.h"
+
+void triInsertion(long* A, size_t n) {
+    for(size_t i = 1; i <= n-1; i++){
+        long cle = A[i];
+        size_t j = i - 1;
+        while(j+1 >= j && A[j] > cle){
+            A[j+1] = A[j];
+            j = j-1;
+        }
+        A[j+1] = cle;
+    }
+}
+
+void triFusion(long* A, size_t size) {
+  sousTriFusion(A, 0, size);
+}
+
+void sousTriFusion(long* A, size_t first, size_t size) {
+    if(first+1 <size){ // p < r - 1
+        size_t middle = floor((first+size)/2);
+        sousTriFusion(A, first, middle);
+        sousTriFusion(A, middle, size);
+        fusion(A, first, middle, size);
+    }
+}
+
+void copySousTable(long* mainT, long* underT, size_t id, size_t size) {
+  for(size_t i = id; i < id+size; ++i) {
+    underT[i-id] = mainT[i];
+  }
+}
+
+void fusion(long* A, size_t first, size_t middle, size_t size) {
+    size_t n1 = middle - first; // Nb elem dans A[p , q]  q exclu
+    size_t n2 = size - middle;  // Nb elem dans A[q , r]  r exclu
+
+    size_t indg = 0;
+    size_t indd = 0;
+
+    long* ag = malloc(sizeof(long) * n1);
+    long* ad = malloc(sizeof(long) * n2);
+
+    copySousTable(A, ag, first, n1);
+    copySousTable(A, ad, middle, n2);
+
+    int i = first;
+
+    while(i < size) {
+      if(indg == n1) {
+        A[i] = ad[indd];
+        indd++;
+      }
+      else if(indd == n2) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else if(ag[indg] < ad[indd]) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else {
+        A[i] = ad[indd];
+        indd++;
+      }
+      ++i;
+    }
+
+    free(ag);
+    free(ad);
+}
+
+void triRapide(long* A, size_t n) {
+    sousTriRapide(A,0,n);
+}
+
+void sousTriRapide(long* A, size_t first, size_t size){
+    if(first+1 < size){
+        size_t middle = partition(A,first,size);
+        sousTriRapide(A,first,middle);
+        sousTriRapide(A,middle+1,size);
+    }
+}
+
+int partition(long* A, int p, int r) {
+    long pivot = A[r-1];
+    int i = p;
+    long temp;
+    for(int j = p; j <= r-2; j++){
+        if(A[j] <= pivot){
+            temp = A[i];
+            A[i] = A[j];
+            A[j] = temp;
+            i++;
+        }
+    }
+
+    long permuter = A[i];
+    A[i] = A[r - 1];
+    A[r - 1] = permuter;
+    //permuter(A,i,size-1);
+    
+    return i;
+}
+
+/*
+size_t partition(long* A, size_t first, size_t size) {
+    long pivot = A[size-1];
+    size_t i = first;
+    for(int j = first; j+2 <= size; j++){
+        if(A[j] <= pivot){
+            permuter(A,i,j);
+            i++;
+        }
+    }
+
+}
+*/
+void permuter(long* A,size_t i,size_t j) {
+    long inter = A[i];
+    A[i] = A[j];
+    A[j] = inter;
+}

TP1/tris.h

+#ifndef TRIS_H
+#define TRIS_H
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertion(long* A, size_t n);
+
+void triFusion(long* A, size_t size);
+void sousTriFusion(long* A, size_t first, size_t size);
+void fusion(long* A, size_t first, size_t middle, size_t size);
+
+void triRapide(long* A, size_t n);
+void sousTriRapide(long* A, size_t first, size_t size);
+size_t partition(long* A, size_t first, size_t size);
+void permuter(long* A,size_t i,size_t j);
+
+#endif //TRIS_H

TP1/utils.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "utils.h"
+
+void affichertab(long* T, int s){
+    printf("[ ");
+    for(int i = 0; i < s-1; i++){
+        printf("%ld , ",T[i]);
+    }
+    printf("%ld ]\n",T[s-1]);
+}
+
+void listeAlea(long *T,size_t longeur, long N){
+    
+    for(size_t i = 0; i < longeur; i++){
+        T[i] = rand() % N * -1; 
+    } 
+}   
\ No newline at end of file

TP1/utils.h

+#include <stdio.h>
+#include <stdlib.h>
+
+void affichertab(long* T, int s);
+void listeAlea(long *T,size_t longeur, long N);
\ No newline at end of file

exemples/exemple.R

+library(ggplot2)
+
+#!/usr/bin/env Rscript
+args = commandArgs(trailingOnly=TRUE)
+
+df <- read.table("data", sep="\t", header=TRUE)
+head(df)
+df$moyenneMessagesEnAttente <-with(df, nbMessagesEnAttente * 1.0 / nbStations)#/ nbStations)
+
+df$pn <- with(df, proba * nbStations)
+
+head(df)
+
+tail(df)
+
+y_axis <- "Nombre moyen de messages en attente"
+
+titre <- "Aloha avec relance beb, proba = 0.001"#, k=10"
+
+
+p <- ggplot(data=df,
+    aes(x=nbSlots, y=moyenneMessagesEnAttente, colour=factor(pn)))
+    
+#p <- p + geom_point(size=0, alpha=0.1)
+p <- p + geom_smooth()
+p <- p + labs(  x="Slot",
+                y=y_axis,
+                color="p*n",
+                title=titre)
+ggsave(file="name.eps")
+png("myplot.png")
+print(p)
+dev.off()
+
+print(p)
+
+

exemples/plot_pn2.R

+library(ggplot2)
+
+
+df <- read.table("data", sep="\t", header=TRUE)	#lecture d'un csv avec tabulation en séprateur
+
+y_axis <- "Nombre moyen de messages en attente"
+
+titre <- "Aloha avec relance beb, proba = 0.001"
+
+p <- ggplot(data=df,
+    aes(x=nbSlots,			#nom des issues des colonnes de data
+	y=moyenneMessagesEnAttente,
+	colour=factor(pn)))
+    
+p <- p + geom_smooth()
+p <- p + labs(  x="Slot",
+                y=y_axis,
+                color="p*n",
+                title=titre)
+
+# pour sauvegarder une image (différents formats ici)
+ggsave(file="name.eps")
+png("myplot.png")
+print(p)
+dev.off()
+
+print(p)
+
+

renduTP1/Makefile

+all: main
+	
+main : tris.o main.c
+	gcc -o main -Wall utils.o -g main.c
+
+tris.o : tris.c tris.h
+	gcc -c -Wall -g tris.c
+
+clean :
+	rm *.o

renduTP1/tris.c

+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "tris.h"
+
+void triInsertion(long* A, size_t n) {
+    for(size_t i = 1; i <= n-1; i++){
+        long cle = A[i];
+        size_t j = i - 1;
+        while(j+1 >= j && A[j] > cle){
+            A[j+1] = A[j];
+            j = j-1;
+        }
+        A[j+1] = cle;
+    }
+}
+
+void triFusion(long* A, size_t n) {
+  sousTriFusion(A, 0, n);
+}
+
+void sousTriFusion(long* A, size_t first, size_t n) {
+    if(first+1 <n){ // p < r - 1
+        size_t middle = floor((first+n)/2);
+        sousTriFusion(A, first, middle);
+        sousTriFusion(A, middle, n);
+        fusion(A, first, middle, n);
+    }
+}
+
+void copySousTable(long* mainT, long* underT, size_t id, size_t n) {
+  for(size_t i = id; i < id+n; ++i) {
+    underT[i-id] = mainT[i];
+  }
+}
+
+void fusion(long* A, size_t first, size_t middle, size_t n) {
+    size_t n1 = middle - first; // Nb elem dans A[p , q]  q exclu
+    size_t n2 = n - middle;  // Nb elem dans A[q , r]  r exclu
+
+    size_t indg = 0;
+    size_t indd = 0;
+
+    long* ag = malloc(sizeof(long) * n1);
+    long* ad = malloc(sizeof(long) * n2);
+
+    copySousTable(A, ag, first, n1);
+    copySousTable(A, ad, middle, n2);
+
+    int i = first;
+
+    while(i < n) {
+      if(indg == n1) {
+        A[i] = ad[indd];
+        indd++;
+      }
+      else if(indd == n2) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else if(ag[indg] < ad[indd]) {
+        A[i] = ag[indg];
+        indg++;
+      }
+      else {
+        A[i] = ad[indd];
+        indd++;
+      }
+      ++i;
+    }
+
+    free(ag);
+    free(ad);
+}
+
+void triRapide(long* A, size_t n) {
+    sousTriRapide(A,0,n);
+}
+
+void sousTriRapide(long* A, size_t first, size_t n){
+    if(first+1 < n){
+        size_t middle = partition(A,first,n);
+        sousTriRapide(A,first,middle);
+        sousTriRapide(A,middle+1,n);
+    }
+}
+
+size_t partition(long* A, size_t first, size_t n) {
+    long pivot = A[n-1];
+    size_t i = first;
+    for(int j = first; j+2 <= n; j++){
+        if(A[j] <= pivot){
+            permuter(A,i,j);
+            i++;
+        }
+    }
+    permuter(A,i,n-1);
+    return i;
+}
+
+void permuter(long* A,size_t i,size_t j) {
+    long inter = A[i];
+    A[i] = A[j];
+    A[j] = inter;
+}

renduTP1/tris.h

+#ifndef TRIS_H
+#define TRIS_H
+#include <stdint.h>
+#include <stdlib.h>
+
+void triInsertion(long* A, size_t n);
+
+void triFusion(long* A, size_t size);
+void sousTriFusion(long* A, size_t first, size_t size);
+void fusion(long* A, size_t first, size_t middle, size_t size);
+
+void triRapide(long* A, size_t n);
+void sousTriRapide(long* A, size_t first, size_t size);
+size_t partition(long* A, size_t first, size_t size);
+void permuter(long* A,size_t i,size_t j);
+
+#endif //TRIS_H

renduTP2/.Rhistory

+installe.packages("ggthemes")
+install.packages("ggthemes")
+q()

renduTP2/Makefile

+all: sort
+	
+sort : tris.o utils.o perf.o main.c
+	gcc -o sort -Wall utils.o tris.o perf.o -g main.c
+
+tris.o : tris.c tris.h
+	gcc -c -Wall -g tris.c
+
+utils.o : utils.c utils.h
+	gcc -c -Wall -g utils.c
+
+perf.o : perf.c perf.h
+	gcc -c -Wall -g perf.c
+
+clean :
+	rm *.o

renduTP2/README.md

+
+# P4z : Analyse de performances de différents tris
+
+## Problème
+
+
+Dans l'analyse de performances de différents tris il est necessaire de trouver l'utilisation optimal pour chacun des algorithme de tris.
+Ainsi nous devons essayer de comprendre pourquoi certain algorithme ne  fonctionnent pas avec chaques tableau mais aussi trouvre les limites qui nous empêcherais d'utiliser cette algorithme.
+
+Pour se faire il faut bien comprendre pourquoi et comment est influé le temps et la consommation de mémoire grace aux différents parametres de celui-ci:
+
+le nombres d'appel de fonction
+le temps de calcul : le nombre d'écriture + comparaison 
+
+grace à ça on pourra voir le temps 
+
+voir si la memoire, le temps cpu est lié avec le nombre de comparaison /ecriture /
+
+créeer fonction affection pour calculer le nombre de x que on affect
+```
+- Le temps d'éxécution d'un tri (Sur les tableaux de differentes allures)
+- La consommation de memoire lors du tri (Sur les tableaux de differentes allures)
+- Son estimation de temps d'execution (La fonction O(f) -> log(n), n^2, nlog(n), etc)
+- Pareil pour la memoire
+- Le nombre de comparaisons total
+- Le nombre d'ecritures total
+
+```
+Nous allons donc chercher à comprendre l'influence des paramètres ci-dessus sur la rapidité et l'optimisation des algorithme. Par la suite nous comprendrons mieux l'application de chacun des algorithme et nous essaierons de trouver un correctif pour améliorer nos performances.
+
+
+## Dispositif expérimental
+
+### Application
+
+[Main](./main.c)
+
+``` 
+main --taille --typeTableau --typeTri 
+```
+ 
+| Arguments                | Default       | Description   |	
+| :------------------------ |:-------------:| :-------------|
+| `--taille` | **1000** | **La taille du tableau de n éléments.** |
+| `--typeTableau -aricm` | **a** | **Défini le type du tableau avec `a` aléatoire, `t` trié, `i` inversé, `c` identique et `m` trié à moitié.**|
+| `--typeTri -irf` | **i** | **Algorithme de tri avec `i` insertion, `r` rapide et `f` fusion.** |
+
+[./utils.c](chemin)
+
+Le main se contente d'initialiser les paramètres, les fonctions de création et d'affichage du tableau sont dans le fichier utils.c.
+Par la suite, le main choisit le bon tri via un switch.
+
+```
+Dans le fichier utils on retrouve :
+    - afficherTab : qui parcourt le tableau et affiche chacun de ses elements
+    - genTab : ils recoit un pointeur sur un tableau, sa taille, le type du tableau (les mêmes que dans le main) et la taille max des elements du tableau.
+```
+
+
+
+### Environnement de test
+
+Nos test sont réalisé sur le serveur Phoenix avec comme caractéristique
+
+```
+
+Processeur(s) :                         40
+Liste de processeur(s) en ligne :       0-39
+Thread(s) par cœur :                    2
+Cœur(s) par socket :                    10
+Socket(s) :                             2
+
+Nom de modèle :                         Intel(R) Xeon(R) CPU E5-2630 v4 @ 2.20GHz
+Vitesse maximale du processeur en MHz : 3100,0000
+Cache L1d :                             32K
+Cache L1i :                             32K
+Cache L2 :                              256K
+Cache L3 :                              25600K
+
+
+```
+
+
+
+### Description de la démarche systématique
+
+Description de la démarche systématique et de l'espace d'exploration pour chaque paramètres.
+
+```
+Suite des commandes, ou script, à exécuter pour produire les données.
+    - Executer le shell script: ./perf.sh
+    - Executer le R script pour produire le graphe: Rscript rplot3.R
+```
+
+## Résultats préalables
+
+### Temps d'exécution
+
+| Jeu de test          | Tri par Insertion         | Tri Fusion                | Tri Rapide                | Tri à bulle               |
+|----------------------|---------------------------|---------------------------|---------------------------|---------------------------|
+| | ![plot](./images/tab_insert2.png) | 1| 2| 3| 
+
+### Consommation mémoire
+
+| Jeu de test          | Tri par Insertion         | Tri Fusion                | Tri Rapide                | Tri à bulle               |
+|----------------------|---------------------------|---------------------------|---------------------------|---------------------------|
+| Aléatoire            | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) | ![plot](path/to/plot.png) |
+
+
+### Analyse des résultats préalables
+
+*Qu'est-ce qu'on voit:*
+
+Pour la l'algorithme de tri fusion on remarque que la consommation de mémoire est linéaire, ne fluctu pas et pour une taille donné sa consommation reste identique pour n'importe quel type de tableau. Le temps de que met l'algo pour trier reste lui aussi reste linaire, a une fluctuation très minime mais contrairement à la consommation de mémoire le type de tableau influ sur le temps de résolution. On voit que le 
+C'est un algorithme gourmant mais fiable pour toute taille de tableau.
+
+
+
+
+```
+- Tri Fusion est le plus efficace dans la rapidite pour tout type de tableaux, mais la consommation de memoire reste a ameliorer
+
+- Tri Rapide est tres rapide sur des tableaux aleatoires, mais la vitesse d'execution explose pour les tableaux constants, ranges et inverses
+
+- Tri Insertion est beaucoup moins rapide que les deux autres algos sur les tableaux aleatoires (plus de 1 seconde de plus), mais ne fait aucune operation sur les tableaux constants et ranges, ce qui peut etre un tres grand atout dans quelques situations. Par contre son temps d'execution explose pour les tableaux inversés
+- Tri A Bulle est le pire de nos quatre algos car il metra un temps monstre pour trié peut importe le type de tableaux que l'on lui donne, mais les tableau aleatoire reste les pires
+```
+
+*Explication detaillee:*
+
+### Discussion des résultats préalables
+
+Explications précises et succinctes des limites des résultats
+préalables et ce qu'ils ne permettent pas de vérifier.
+
+## Etude approfondie
+
+### Hypothèse
+
+Expression précise et succincte d'une hypothèse.
+
+### Protocole expérimental de vérification de l'hypothèse
+
+Expression précise et succincte du protocole.
+
+```
+Suite des commandes, ou script, à exécuter pour produire les données.
+```
+
+### Résultats expérimentaux
+
+### Analyse des résultats expérimentaux
+
+### Discussion des résultats expérimentaux
+
+## Conclusion et travaux futurs