Update README.md

README.md

@@ -60,38 +60,53 @@ Le Main va ensuite créer une structure en fonction des paramètres qu'on lui a
 
 Description de la plateforme de test
 
-![](/cpuinfo.png)
+![](/cpuinfo.PNG)
 
 
 ### Description de la démarche systématique
 
-Description de la démarche systématique et de l'espace d'exploration pour chaque paramètres.
+- Taille : taille de la structure, fixe à 100 000 éléments
+- nbOperation : nombre d'itérations pour chaque opération -> effectuer une observation à plus ou moins grande échelle, va de 50 à 250 avec un pas de 50
+- operation : String de l'opération courant (Add, remove, etc) il y en a 8 afin de pouvoir faire une observation d'ensemble sur toute les opération d'un coup
+- type : String de la structure courante. Il y a 4 structures (tableau, arraylist, linkedlist et maillon) afin de pouvoir faire une observation sur chacune d'entres elles
 
+- Les observation sont : le temps CPU sur x nombre d'opération et la consommation mémoire.
 ```
-Suite des commandes, ou script, à exécuter pour produire les données.
+library(ggplot2)
+perf <- read.csv2("perf.csv", sep="\t", dec=".")
+GraphCPU <- ggplot(perf,aes(y = CPU, x = nbOperation, colour = Structure, shape =Structure)) + geom_point() + geom_smooth() + ggtitle("Evaluation du temps d'éxecution du CPU") + labs(y="Temps en secondes", x="Nombre d'opérations") + facet_grid(.~Operation)
+GraphMemoire <- ggplot(perf,aes(y = Mem, x = nbOperation, colour = Structure, shape =Structure)) + geom_point() + geom_smooth() + ggtitle("Evaluation de la consommation mémoire") + labs(y="Temps en secondes", x="Nombre d'opérations") + facet_grid(.~Operation)
+GraphCPU + coord_cartesian(ylim = c(0, 1))
+
 ```
 
 ## Résultats préalables
 
 ### Temps d'exécution
 
-![plot](/tpsExecutionCpu.png)
-![plot zoomé](/tpsExecutionzoomer.png)
+#### Dézoomé
+![](/tpsExecutionCpu.PNG)
+#### Zoomé
+![](/tpsExecutionzoom.PNG)
 
 ### Consommation mémoire
 
-![plot](/consoMemoire.png)
+![](/consoMemoire.PNG)
 
 ### Analyse des résultats préalables
 
-La mémoire se comporte exactement pareil sur les 4 versions.
-Les temps d'exécutions dépendent essentiellement de l'affichage des valeurs du tableau.
-La version 2 de recherche semble un peu plus rapide.
+On constate que la mémoire agis différemment uniquement en fontion des structures et non pas des opérations sur celles-ci.
+De plus, la linkedList prend le plus de mémoire. ArrayList est la structure qui prend le moins de consommation mémoire, ce qui est logique car 
+implémentée de base par java et rapide dans le temps CPU.
+
+Le temps CPU varie grandement entre les structures. Bien sur, nous constatons des tendances comme par exemple ArrayList et Tableau qui sont souvent
+joints et LinkedList et Maillon qui sont aussi joints. C'est donc cohérent par rapport au mécanisme de la structure car on vois bien que sur les méthodes comme add (tete, queue, random) où l'ont constatent que le temps CPU est le même partout, ou presque pour linked et Maillon qui prennent plus ou moins de temps sur la méthode Get, ce qui est logique car ce sont des listes chainées (le déplacement prend du temps).
+
+Cependant, sur les méthodes removes (tête, middle) on constatent un temps CPU énorme sur tableau. Ce qui est logique. Lorsqu'une valeur de tableau est retirée, il faut que tout ses éléments soient décalé vers la gauche, mais quand nous avons 1 millions d'élements ou même 100 000, cela prend du temps. Les résultats sont donc cohérents car removeMiddle prend deux à trois fois moins de temps que removeTete pour tableau. Mais à part linked et tableau, les tendances sont similaires pour les autres structures sur les autres méthodes.
 
 ### Discussion des résultats préalables
 
-Explications précises et succinctes sur ce que les limites des résultats
-préalables et ce qu'ils ne permettent pas de vérifier.
+Nos observation couvrent la totalité du problème, qui est ici d'analyser comment se comportent les différentes structures sur diverses opérations.
 
 ## Etude approfondie