Evaluation.md

+## Etendue et qualité de l'étude
+- Nombre de structures
+  - [x] Tableau et liste chainées (implantations maison + implantations standard) + une autre structure sandard sont traités.
+  - [ ] Tableau et liste chainées (implantations maison + implantations standard)
+  - [ ] Tableau et liste chainées ne sont pas traités
+- Nombre d'opérations
+  - [x] Au moins trois opérations sont traitées.
+  - [ ] Deux opérations sont traitées.
+  - [ ] Deux opérations ne sont pas traitées.
+- Aspects
+  - [x] Consommation mémoire et CPU sont traitées.
+  - [ ] Consommation mémoire ou CPU sont traitées.
+  - [ ] Consommation mémoire et CPU ne sont pas traitées.
+- Qualité
+  - [x] Les principes de la programmation objet sont pleinement exploités, notamment l'héritage et l'abstraction.
+  - [ ] Les principes de la programmation objet sont exploités, notamment l'héritage.
+  - [ ] Les principes de la programmation objet ne sont pas exploités.
+## Rédaction et analyses
+- Description du problème
+  - [X] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Application
+  - [X] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Environnement de test
+  - [ ] La section est pertinente, succincte et précise.
+  - [X] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Description de la démarche systématique
+  - [X] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.			
+- Analyse des résultats préalables
+  - [X] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Discussion des résultats préalables
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [X] La section n'est pas pertinente.
+- Hypothèse
+  - [ ] La section est pertinente, succincte et précise.
+  - [X] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+- Protocole expérimental de vérification de l'hypothèse
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Analyse des résultats expérimentaux
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Discussion des résultats expérimentaux
+  - [ ] La section est pertinente, succincte et précise.
+  - [ ] La section est pertinente.
+  - [x] La section n'est pas pertinente.
+- Conclusion et travaux futurs
+  - [ ] La section est pertinente, succincte et précise.
+  - [X] La section est pertinente.
+  - [ ] La section n'est pas pertinente.
+
+## Résultats 	
+- Nombre
+  - [x] Les tests sont suffisament nombreux pour observer des épiphénomènes
+  - [ ] Les tests sont suffisament nombreux pour observer des phénomènes
+  - [ ] Les tests ne sont pas suffisament nombreux pour observer des phénomènes
+- Echantillon
+  - [ ] L'échantillon choisi a un bon équilbre entre temps d'exécution et observations
+  - [X] L'échantillon choisi néglige les temps d'exécution
+  - [ ] L'échantillon choisi néglige les observations
+- Artefacts		
+  - [ ] Les observations excluent tout artefacts		
+  - [X] Certains artefacts, comme des pas d'horloge, sont visibles
+  - [ ]	Seuls des artefacts sont observables
+- Décoration
+  - [x] Les plots contiennent légende et titre
+  - [ ]	Les plots contiennent légende ou titre
+  - [ ]	Les plots ne contiennent ni légende ni titre
+- Lisibilité
+  - [ ]	Les plots permettent de lire clairement toutes les séries
+  - [x]	Les plots permettent de lire clairement la plupart des séries
+  - [ ]	Les plots permettent pas de lire clairement la plupart des séries
+- Echelles
+  - [ ] Les échelles sont respectées pour permettre la visualisation et la comparaison des séries entre plots
+  - [x] Les échelles sont respectées pour permettre la visualisation des séries entre plots
+  - [ ] Les échelles ne sont pas respectées pour permettre la visualisation des séries entre plots
+
+## Hypothèse
+- Originalité
+  - [ ] L'hypothèse émise est orginale et trouvée intégralement par l'étudiant.
+  - [x] L'hypthèse émise est orginale.
+  - [ ] L'hypthèse émise n'est pas originale.
+- Difficulté
+  - [ ] L'hypothèse émise est très difficile à prouver.
+  - [ ]	L'hypothèse émise est difficile à prouver.
+  - [x]	L'hypothèse émise est facile à prouver.
+- Théorie
+  - [ ]	L'analyse de l'hypothèse se confronte à la théorie avec pertinence.
+  - [X]	L'analyse de l'hypothèse se confronte à la théorie.
+  - [ ]	L'analyse de l'hypothèse ne se confronte pas à la théorie.
+
+
+# Total
+
+- Total d'item « Excellent » (1 point) : 14
+- Total d'item « Satisfaisant » (0,5 point) : 7 
+- Total d'item « Insatisfaisant » (0 point) : 3
+
+- Note sur 24 : 14 (17.5)

P4a/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="Common"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/jre">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

P4a/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>P4a</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

P4a/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=15
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=15
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=15

P4a/Common/PersonalStructure/ChainedList.java

+package PersonalStructure;
+import defaultpackage.Structure;
+
+public class ChainedList implements Structure {
+	protected Link head;
+	protected Cursor cursor;
+	public int nbVal = 0;
+//	
+//	public ChainedList(Link head, Cursor cursor) {
+//		this.head = head;
+//		this.cursor = cursor;
+//		this.nbVal = 1;
+//	}
+
+	public ChainedList(Cursor cursor) {
+		this.cursor = cursor;
+		this.nbVal = 0;
+
+	}
+	
+
+	
+	public void setNextLink(Link currentLink)
+	{
+		Link last_next = this.cursor.currentLink.next;
+		this.cursor.currentLink.next = currentLink;
+		nbVal+=1;
+	}
+	
+	public void setPreviousLink(Link currentLink)
+	{
+		Link last_next = this.cursor.currentLink.next;
+		this.cursor.currentLink.next = currentLink;
+		nbVal+=1;
+	}
+	
+	public Link getLink()
+	{
+		return this.cursor.currentLink;
+	}
+	
+	public Link getNextLink()
+	{
+		return this.cursor.currentLink.next;
+	}
+	
+	public Link getPreviousLink(Link currentLink)
+	{
+		return this.cursor.currentLink.next;
+	}
+	
+	public void replaceCursor(int position)
+	{
+
+		this.cursor.currentList = this;
+		this.cursor.position(position);
+
+	}
+	
+	public boolean isEmpty() {
+		boolean res = false;
+		if(this.nbVal != 0)
+			res = true;
+		return res;
+	}
+
+	@Override
+	public void Add(int value) {
+
+		if (nbVal == 0) {
+			
+			Link new_link = new Link(value);
+			this.head = new_link;
+			this.head.last = new_link;
+
+			this.cursor.currentLink = new_link;
+
+			this.head.next = new_link;
+		}
+		else {
+
+			
+			this.replaceCursor(this.nbVal);
+		
+			Link last_before_added = this.cursor.currentLink.last;
+			Link next_after_added = this.head;
+		
+			Link new_link = new Link(value, next_after_added, last_before_added);
+
+			last_before_added.next = new_link;
+			this.head.last = new_link;
+		
+			this.cursor.currentLink = new_link;
+		}
+		this.nbVal += 1;
+
+	}
+	
+	public int GetNbVal()
+	{
+		return this.nbVal;
+	}
+
+	@Override
+	public void RemoveTete() throws Exception  {
+
+		
+		this.replaceCursor(nbVal - 1);
+		Link last_of_remove = this.cursor.currentLink.last;
+		Link next_of_remove = this.cursor.currentLink.next;
+		
+		last_of_remove.next = next_of_remove;
+		next_of_remove.last = last_of_remove;
+		
+		this.cursor.currentLink = next_of_remove;
+	}
+
+	@Override
+	public int Get(int index) throws Exception {
+		if ((index < 0) && isEmpty())
+			throw new IndexOutOfBoundsException("Wrong position");
+		this.replaceCursor(index);
+		return this.cursor.currentLink.value;
+	}
+
+
+
+	@Override
+	public void RemoveMiddle() throws Exception 
+	{
+		if(nbVal%2==0)
+		{
+			// TODO Auto-generated method stub
+			this.replaceCursor(nbVal / 2);
+			Link last_of_remove = this.cursor.currentLink.last;
+			Link next_of_remove = this.cursor.currentLink.next;
+			
+			last_of_remove.next = next_of_remove;
+			next_of_remove.last = last_of_remove;
+			
+			this.cursor.currentLink = next_of_remove;
+		}
+		else 
+		{
+			// TODO Auto-generated method stub
+			this.replaceCursor((nbVal-1) / 2);
+			Link last_of_remove = this.cursor.currentLink.last;
+			Link next_of_remove = this.cursor.currentLink.next;
+						
+			last_of_remove.next = next_of_remove;
+			next_of_remove.last = last_of_remove;
+						
+			this.cursor.currentLink = next_of_remove;
+		}
+	}
+
+
+
+	@Override
+	public int GetLenght() {
+		// TODO Auto-generated method stub
+		return nbVal;
+	}
+
+
+
+
+	@Override
+	public int GetStandard(int x) {
+		int res = -1;
+		if (x != 0)
+			res = this.GetStandard(x-1);
+		else
+			res = this.cursor.currentLink.value;
+			
+		return res;	
+	}
+
+
+
+	@Override
+	public int GetDichotomous(int x) {
+		int i = this.GetLenght();
+		int res = -1;
+		while (x != i)
+		{
+			if (x > i)
+				i = i+i/2;
+			else
+				i = i/2;
+		}
+		try {
+			res = this.Get(i);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return res;
+	}
+}

P4a/Common/PersonalStructure/Cursor.java

+package PersonalStructure;
+
+public class Cursor {
+	protected Link currentLink;
+	protected ChainedList currentList;
+	protected int pos;
+	
+	public Cursor(ChainedList currentList, Link currentLink, int pos) {
+		this.currentLink = currentLink;
+		this.currentList = currentList;
+		this.pos = pos;
+	}
+
+	public Cursor() {
+		this.pos = 0;
+	}
+	
+	public void position(int pos)
+	{
+		// si on est arrivé à la bonne position, on garde le maillon actuel
+		if (pos == this.pos)
+		{ 
+			return;
+		}
+		// si nous sommes avant la position voulue, on avance
+		else if (pos > this.pos)
+		{
+			while(pos != this.pos)
+			{
+				goForward();
+			}
+		}
+		// si nous sommes après la position voulue, on recule
+		else if (pos < this.pos)
+		{
+			while(pos != this.pos)
+			{
+				goBack();
+			}
+		}
+	}
+	
+	private void goForward()
+	{
+
+		
+		// si on n'est pas encore arrivé à la fin de la liste, on avance
+		if(this.pos <= this.currentList.GetNbVal())
+		{
+			this.pos += 1;
+			this.currentLink = this.currentLink.next;
+		}
+		// sinon on retourne au début de la liste
+		else 
+		{
+			this.pos = 0;
+			this.currentLink = this.currentList.head;
+		}
+	}
+	
+	private void goBack() {
+		// si on n'est pas encore arrivé au début de la liste, on recule
+		if(this.pos >= 0)
+		{
+			this.pos -= 1;
+		}
+		// sinon on va à la fin de la liste
+		else {
+			this.pos = this.currentList.nbVal;
+		}
+		// on recule toujours
+		this.currentLink = this.currentLink.last;
+	}
+
+	private void setList(ChainedList list) {
+		this.currentList = list;
+		this.currentLink = list.head;	
+	}
+}

P4a/Common/PersonalStructure/Link.java

+package PersonalStructure;
+
+public class Link {
+	protected int value;
+	protected Link next;
+	protected Link last;
+	
+	public Link(int value, Link next, Link last) {
+		this.value = value;
+		this.next = next;
+		this.last = next;
+	}
+
+	public Link(int value) {
+		this.value = value;
+	}
+
+	public void setNext(Link next) {
+		this.next = next;
+	}
+
+	public void setLast(Link last) {
+		this.last = last;
+	}
+
+}
+

P4a/Common/StandardStructure/ArrayListC.java

+package StandardStructure;
+
+import defaultpackage.Structure;
+import java.util.ArrayList;
+import java.util.Random;;
+
+public class ArrayListC implements Structure
+{
+	protected ArrayList<Integer> arrayList;
+	
+	public ArrayListC(int nbValue) 
+	{
+		Random rnd = new Random();
+		arrayList = new ArrayList<Integer>();
+		for(int i = 0; i < nbValue; i++) 
+		{
+			Add(rnd.nextInt());
+		}
+
+	}
+
+	@Override
+	public void Add(int value) 
+	{
+		arrayList.add(value);
+	}
+
+	@Override
+	public void RemoveTete() throws Exception 
+	{	
+		try 
+		{
+			arrayList.remove(arrayList.size() - 1);
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+	}
+
+	@Override
+	public int Get(int index) throws Exception
+	{
+		try 
+		{
+			return arrayList.get(index);
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+	}
+	
+
+	@Override
+	public void RemoveMiddle() throws Exception {
+		// TODO Auto-generated method stub
+		if(arrayList.size()%2==0) {
+			arrayList.remove(arrayList.size()/2);
+		}
+		else {
+			arrayList.remove((arrayList.size()-1)/2);
+		}
+		
+
+	}
+
+	@Override
+	public int GetLenght() {
+		// TODO Auto-generated method stub
+		return arrayList.size();
+	}
+
+	@Override
+	public int GetStandard(int x) {
+		int i = 0;
+		while (x != i)
+		{
+			i++;
+		}
+		return arrayList.get(i);
+	}
+
+	@Override
+	public int GetDichotomous(int x) {
+		int i = this.GetLenght();
+		while (x != i)
+		{
+			if (x > i)
+				i = i+i/2;
+			else
+				i = i/2;
+		}
+		return arrayList.get(i);
+	}
+
+}

P4a/Common/StandardStructure/LinkedListC.java

+package StandardStructure;
+
+import java.util.LinkedList;
+import java.util.Random;
+
+import defaultpackage.Structure;
+
+public class LinkedListC implements Structure
+{
+	
+	LinkedList<Integer> linkedList;
+	
+	public LinkedListC(int nbValue) 
+	{
+		Random rnd = new Random();
+		linkedList = new LinkedList<Integer>();
+		for(int i = 0; i < nbValue; i++) {
+			Add(rnd.nextInt());
+		}
+	}
+	@Override
+	public void Add(int value) {
+		// TODO Auto-generated method stub
+		
+		linkedList.add(value);
+	}
+
+	@Override
+	public void RemoveTete() throws Exception  {
+		// TODO Auto-generated method stub
+		
+		try 
+		{
+			linkedList.remove(linkedList.size() - 1);
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+	}
+
+	@Override
+	public int Get(int index) throws Exception
+	{
+		// TODO Auto-generated method stub
+		try
+		{
+			return linkedList.get(index);
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+	}
+	
+	@Override
+	public void RemoveMiddle() throws Exception {
+		// TODO Auto-generated method stub
+		if(linkedList.size()%2==0) {
+			linkedList.remove(linkedList.size()/2);
+		}
+		else {
+			linkedList.remove((linkedList.size()-1)/2);
+		}
+
+	}
+	@Override
+	public int GetLenght() {
+		// TODO Auto-generated method stub
+		return linkedList.size();
+	}
+	
+	@Override
+	public int GetStandard(int x) {
+		int i = 0;
+		while (x != i)
+		{
+			i++;
+		}
+		return linkedList.get(i);
+	}
+	
+	@Override
+	public int GetDichotomous(int x) {
+		int i = this.GetLenght();
+		while (x != i)
+		{
+			if (x > i)
+				i = i+i/2;
+			else
+				i = i/2;
+		}
+		return linkedList.get(i);
+	}
+
+}

P4a/Common/StandardStructure/Table.java

+package StandardStructure;
+
+import java.util.Random;
+
+import defaultpackage.Structure;
+
+public class Table implements Structure
+{
+	int[] tab;
+	int nbValue = 0;
+	
+	public Table(int nbValue)
+	{
+
+		Random rnd = new Random();
+		
+		tab = new int[nbValue];
+		
+		for(int i = 0; i < nbValue;i++) 
+		{
+			Add(rnd.nextInt());
+		}
+		
+	}
+
+	@Override
+	public void Add(int value) {
+		// TODO Auto-generated method stub
+		
+		if(nbValue < tab.length) 
+		{
+			tab[nbValue] = value;
+			nbValue++;
+		}
+		else 
+		{
+			Integer[] temp = new Integer[nbValue * 2];
+			
+			for(int i = 0; i < nbValue; i++) 
+			{
+				temp[i] = tab[i];
+			}
+			
+			temp[nbValue] = value;
+			tab=temp;
+		}
+
+		
+	}
+
+	@Override
+	public void RemoveTete() throws Exception 
+	{
+		// TODO Auto-generated method stub
+		try 
+		{
+		
+			for(int y = 1; y<tab.length;y++) 
+			{
+				tab[y-1] = tab[y];
+			}
+			
+			nbValue--;
+
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+		
+	}
+
+	@Override
+	public int Get(int index) throws Exception 
+	{
+		// TODO Auto-generated method stub
+		try 
+		{
+			return tab[index];
+		}
+		catch(IndexOutOfBoundsException e)
+		{
+			throw new Exception("L'index dfini ne se situe pas dans les bornes du tableau");
+		}
+		catch(NullPointerException e) 
+		{
+			throw new Exception("Tableau n'existe pas");
+		}
+	}
+
+	@Override
+	public void RemoveMiddle() throws Exception
+	{
+		// TODO Auto-generated method stub
+		if(tab.length%2==0)
+		{
+			tab[tab.length/2]=null;
+		}
+		else
+		{
+			tab[(tab.length - 1)/2]=null;
+		}
+		
+		int i = 0;
+		
+		while(tab[i] != null)
+		{
+			i++;
+		}
+		
+		for(int y = i+1; y<tab.length-1;y++) 
+		{
+			tab[y-1] = tab[y];
+		}
+
+	}
+
+	@Override
+	public int GetLenght() {
+		// TODO Auto-generated method stub
+		return nbValue;
+	}
+
+	@Override
+	public int GetStandard(int x) {
+		int i = 0;
+		while (x != i)
+		{
+			i++;
+		}
+		return tab[i];
+	}
+
+
+	@Override
+	public int GetDichotomous(int x) {
+		int i = this.GetLenght();
+		while (x != i)
+		{
+			if (x > i)
+				i = i+i/2;
+			else
+				i = i/2;
+		}
+		return tab[i];
+	}
+
+}

P4a/Common/defaultpackage/Main.java

+package defaultpackage;
+
+import java.math.BigInteger;
+import java.util.Random;
+
+import com.sun.jdi.Type;
+
+import PersonalStructure.ChainedList;
+import PersonalStructure.Cursor;
+import StandardStructure.ArrayListC;
+import StandardStructure.LinkedListC;
+import StandardStructure.Table;
+
+
+public class Main {
+
+	Type tab;
+	public static void main(String[] args) throws NumberFormatException, Exception {
+
+		// TODO Auto-generated method stub
+        GenerateTab(args[0],  Integer.parseInt(args[1]), args[2], Integer.parseInt(args[3]));
+
+	}
+	
+	public static void GenerateTab(String type, int nbValue, String methode, Integer nbOperation) throws Exception 
+	{
+		Random rnd = new Random();
+		if(type.equals("Tableau")) 
+		{
+			Table tab = new Table(nbValue);
+			
+
+
+			switch(methode)
+			{
+				case "Add":
+				{
+					for(int i = 0; i < nbOperation; i++)
+					{
+						tab.Add(rnd.nextInt());
+					}
+					break;
+				
+				}
+				case"RemoveTete":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						tab.RemoveTete();
+					}
+					break;
+				}
+				case"RemoveMiddle":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						tab.RemoveMiddle();
+					}
+					break;
+				}
+				case "Get":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						tab.Get(rnd.nextInt(tab.GetLenght()-1));
+					}
+					break;
+				}
+			}
+		}
+
+		
+		if(type.equals("Array")) {
+			ArrayListC array = new ArrayListC(nbValue);
+			
+			switch(methode)
+			{
+				case "Add":
+				{
+					for(int i = 0; i < nbOperation; i++)
+					{
+						array.Add(rnd.nextInt());
+					}
+					break;
+				
+				}
+				case"RemoveTete":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						array.RemoveTete();
+					}
+					break;
+				}
+				case"RemoveMiddle":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						array.RemoveMiddle();
+					}
+					break;
+				}
+				case "Get":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						array.Get(rnd.nextInt(array.GetLenght()));
+					}
+					break;
+				}
+			}
+			
+		}
+		
+		if(type.equals("Linked")) 
+		{
+			LinkedListC linked = new LinkedListC(nbValue);
+			
+			switch(methode)
+			{
+				case "Add":
+				{
+					for(int i = 0; i < nbOperation; i++)
+					{
+						linked.Add(rnd.nextInt());
+					}
+					break;
+				
+				}
+				case"RemoveTete":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						linked.RemoveTete();
+					}
+					break;
+				}
+				case"RemoveMiddle":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						linked.RemoveMiddle();
+					}
+					break;
+				}
+				case "Get":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						linked.Get(rnd.nextInt(linked.GetLenght()-1));
+					}
+					break;
+				}
+			}
+		}
+		
+		if(type.equals("Maillon")) 
+		{
+			Cursor cursor = new Cursor();
+			ChainedList maillons = new ChainedList(cursor);
+			
+			Random rndMaillon = new Random();
+			
+			for(int i = 0; i < nbValue; i++) {
+
+					maillons.Add(rndMaillon.nextInt());				
+			}
+			
+			switch(methode)
+			{
+				case "Add":
+				{
+					for(int i = 0; i < nbOperation; i++)
+					{
+						maillons.Add(rnd.nextInt());
+					}
+					break;
+				
+				}
+				case"RemoveTete":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						maillons.RemoveTete();
+					}
+					break;
+				}
+				case"RemoveMiddle":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						maillons.RemoveMiddle();
+					}
+					break;
+				}
+				case "Get":
+				{
+					for(int i = 0; i < nbOperation; i++) 
+					{
+						maillons.Get(rnd.nextInt(maillons.GetLenght()-1));
+					}
+					break;
+				}
+			}
+		}
+	}
+
+}

P4a/Common/defaultpackage/Structure.java

+package defaultpackage;
+
+
+public interface Structure 
+{
+		
+	public void Add(int value);
+	public void RemoveTete() throws Exception;
+	public void RemoveMiddle() throws Exception;
+	public int Get(int index) throws Exception;
+	public int GetLenght();
+	public int GetStandard(int x);
+	public int GetDichotomous(int x);
+
+}

P4a/bin/.gitignore

+/StandardStructure/
+/defaultpackage/
+/PersonalStructure/

P4a/manifest

+Manifest-Version: 1.0
+Main-Class: defaultpackage.Main
+

README.md

-
 # P4a : Analyse de performances de différentes structures
 
-[Grille d'évaluation P4a](https://docs.google.com/spreadsheets/d/1x72glVEQHPx56Wr8G0RNQgfQXGX6xCsjms_6b7J6si0/edit?usp=sharing
-)
+[Grille d'évaluation P4a](Evaluation.md)
 
 ## Problème
 
-Description du Problème.
+**Langage utilisé**
+
+Nous avons choisi d'utiliser le langage Java car il est plus adapté à notre organisation.
+
+**Description du problème**
+
+Analyse de performance de quatre structures identiques contenant des nombres mais fonctionnant différemment.
+
+Nous aurons plusieurs paramètres au démarrage :
+- Nombre de valeurs dans chaque tableau : chaque structure a une taille fixe de un million d'éléments générés aléatoirement. 
+- Nombre d'opérations : à chaque test, on augmente le nombre d'opérations de 100. Le nombre d'opérations varie de 100 à 5000.
+- Type de l'opération : AddTete, AddQueue, RemoveTete, RemoveMiddle ou Get.
+- Type de structure : nous utilisons des structures déjà existante (ArrayList, LinkedList, Table) et que nous avons créées nous-même (ChainedList composée de Link et d'un Cursor).
+
+Contrainte : il faut de l’abstraction, et au moins un tableau ET une liste chaînée (Maillons)
+
+
+**Description des paramètres exploratoires du problème**
+
+- Analyser la différence de temps d'éxécution CPU et de consommation de mémoire sur des opérations simples dans chaque structure (insérer, supprimer, sélectionner).
+
+**Organisation du projet**
 
-Description de tous les paramètres exploratoires du problème
 
 ## Dispositif expérimental
 
+### Organisation objet
+
+**Description de l'organisation des classes et interfaces**
+
+Nous avons utilisé trois packages différents : 
+- Un pour les structures déjà existantes, StandardStructure : ArrayList, LinkedList et Table.
+- Un pour celle que nous avons créée, PersonalStructure : ChainedList et ses composants, Link et Cursor.
+- Un pour ce qui est commun aux deux packages précédents, defaultpackage : Main et Structure.
+
+Pour les structures déjà existantes, nous avons préféré recréer une classe wrapper pour chacune d'entre elles afin de personnaliser les fonctions que nous voulions tester et adapter leur fonctionnement à chaque structure.
+
+**Diagramme de classes**
+
+![](/UML_P4a.png)
+
 ### Application
 
-[code source de l'application](chemin)
-```
-Description de l'application et des arguments
-```
+[code source de l'application](/Main.jar)
+
+**Description de l'application et des arguments**
+
+Pour utiliser notre application, il faut lui passer plusieurs paramètres dans l'ordre suivant : le type de structure que l'on souhaite évaluer, le nombre de valeurs (un million), la méthode que l'on va évaluer et le nombre d'opérations. 
+
+Le Main va ensuite créer une structure en fonction des paramètres qu'on lui a passé et la remplir de nombres aléatoires. Il va ensuite appeler la fonction choisie en utilisant un switch.
+
 
 ### Environnement de test
 
 Description de la plateforme de test
-```
-Extrait pertinent de /proc/cpuinfo
-```
+
+![](/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 toutes les opérations d'un coup
+- type : String de la structure courante. Il y a 4 structures (Tableau, Arraylist, Linkedlist et ChainedList) 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](prealable.png)
+#### Dézoomé
+![](/tpsExecutionCpu.PNG)
+#### Zoomé
+![](/tpsExecutionzoom.PNG)
 
 ### Consommation mémoire
 
-![plot](prealable-mem.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 agit 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 elle est 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 voit bien que sur les méthodes comme Add (tête, queue, random) où l'on constate que le temps CPU est le même partout, ou presque pour LinkedList et ChainedList 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 Remove (tête, middle) on constate un temps CPU énorme sur tableau, ce qui est logique. Lorsqu'une valeur de tableau est retirée, il faut que tous ses éléments soient décalés 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 LinkedList 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
 
 ### Hypothèse
 
-Expression précise et succincte d'une hypothèse.
+Nous avons décider de comparer le temps d'exécution et la consommation de la mémoire lorsqu'on ajoute ou qu'on enlève systématiquement un objet au début et à la fin de chacune de nos structures. 
+
+Nous avons également décider de comparer le temps d'éxecution et la consommation de la mémoire lorsqu'on souhaite trouver un index de manière standard (en avançant de 1 dans les structures tant qu'on n'a pas le bon index) et de manière dichotomique (diviser le nombre de valeur par deux puis comparer si la valeur est plus ou moins grande pour retirer ou ajouter la moitié des valeurs).
 
 ### 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.
@@ -76,3 +129,13 @@ Suite des commandes, ou script, à exécuter pour produire les données.
 ### Discussion des résultats expérimentaux
 
 ## Conclusion et travaux futurs
+
+Nos différentes observations sur les méthodes et les structures ont pu nous aider à voir que chaque structure se
+comporte différement selon la méthode appelée.
+
+Cependant, les résultat sont cohérents avec la structure (comme Get sur les liste chainées ou les Remove sur tableau)
+Un plus grand jeu de données aurait tout de même pu permettre une observation plus ample et précise des structures mais 
+les tendances étaient bien visibles, et sans artéfacte. 
+
+Un prochain objectif serait d'observer comment Random influe les performance des structures sur deux algorithmes de tri
+différents.

UML.drawio

+<mxfile host="app.diagrams.net" modified="2021-03-18T14:54:46.482Z" agent="5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.82 Safari/537.36" etag="yiMETbzFZLAocUIGTANi" version="14.4.9" type="device"><diagram id="R8-pWj9DbBJSb4AKZ-qf" name="Page-1">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</diagram></mxfile>
\ No newline at end of file