diff --git a/README.md b/README.md
index e2e069560266ea20de062d7ee702020d83d9407d..2f16f28afefdbe9e9abf6fd603e6e476375d9877 100644
--- a/README.md
+++ b/README.md
@@ -96,23 +96,23 @@ Description de la démarche systématique et de l'espace d'exploration pour chaq
### Analyse des résultats préalables
- - On remarque ici une nette différence de temps lors de l'utilisation d'une Hashset dans n'importe quelle situation et pourtant, à travers l'étude de la mémoire utilisé on voit que la `Hashset` et plus gourmand, et donc répondras à une demande de rapidité et non de consommation minimale.
- - De plus on voit aussi que l'`ArrayList` est un peu plus rapide que la `LinkedList` peut importe la situation, sans pour autant demander de la mémoire supplémentaire. Elle est donc à privilégier.
+On remarque ici une nette différence de temps lors de l'utilisation d'une Hashset dans n'importe quelle situation et pourtant, à travers l'étude de la mémoire utilisé on voit que la `Hashset` et plus gourmand, et donc répondras à une demande de rapidité et non de consommation minimale.
+De plus on voit aussi que l'`ArrayList` est un peu plus rapide que la `LinkedList` peut importe la situation, sans pour autant demander de la mémoire supplémentaire. Il faut donc privilégier l'`ArrayList` à la `LinkedList` dans toutes situations.
### Discussion des résultats préalables
-Le `HashSet` est beaucoup plus rapide que les deux autres structures étudiées pour tous les tests car les valeurs qu'il contient sont triées. Cependant sur d'autres opération telles que l'insertion, sa construction lui sera fatale car elle doit réaliser un certain nombre de comparaisons afin de trouver à quelle position l'élément doit être inséré.
-Cela va également augmenter drastiquement sa consommation mémoire, ce qui est probablement dû à la classification des données.
+Le `HashSet` est beaucoup plus rapide que les deux autres structures étudiées pour tous les tests car les valeurs qu'il contient sont triées. Cependant elle se retrouve beaucoup plus gourmande pour ces opérations et doit donc être utilisée pour répondre à une problématique de rapidité plûtot que d'optimisation mémoire.
Quant à la `LinkedList`, elle réside sur un principe de liste chaînée et donc de maillons, c'est donc pour cela qu'elle devient rapidement gourmande par rapport aux autres structures notamment lorsqu'elle atteint une taille assez conséquente.
-Enfin, l'`ArrayList` est une liste polyvalente alliant un temps d'éxecution faible, sans pour autant devenir gourmande en mémoire, ce qui explique qu'elle soit couramment utilisé, sans compter son principe de fonctionnement trivial.
+Enfin, l'`ArrayList` est une liste polyvalente alliant un temps d'éxecution relativement faible, sans pour autant devenir gourmande en mémoire, ce qui explique qu'elle soit couramment utilisé, sans compter son principe de fonctionnement trivial.
## Etude approfondie
### Hypothèse
-Dans les tests précédents, nous avons remarqué que les performances de la structure `HashSet` sont vraiment intéressantes et rapides. malgré sa consommation de ressources supplémentaires, la durée très courte d'execution rends la structure la plus efficace sur de courtes utilisations. Mais alors notre génération de valeurs fut aléatoire, et nous pouvons nous demander comment les structures réagissent lors de l'utilisation de tableaux triées. Nous posons donc l'hypothèse que les ressources mémoire des structures testées (`HashSet`,`ArrayList`,`LinkedList`) seront réduites dans le cadre de l'utilisation de tableaux triés.
+Dans les tests précédents, nous avons remarqué que les performances de la structure `HashSet` sont vraiment intéressantes et rapides. malgré sa consommation de ressources supplémentaires, la durée très courte d'éxecution rends la structure la plus efficace sur de courtes utilisations. Mais alors notre génération de valeurs fut aléatoire, et nous pouvons nous demander comment les structures réagissent lors de l'utilisation de tableaux triées. Nous posons donc l'hypothèse que les ressources mémoire des structures testées (`HashSet`,`ArrayList`,`LinkedList`) seront réduites dans le cadre de l'utilisation de tableaux triés.
+Nous utiliserons des structures remplies de **500.000** éléments, pour pouvoir comparer nos xpérimentations avec nos valurs précédentes.
### Protocole expérimental de vérification de l'hypothèse
@@ -146,7 +146,6 @@ Usage : ./script.sh Hypothese | tee ../data/perf_hypothese.dat
Usage : ./graphique_hypothese.R
(vérifier que le fichier data/perf_hypothese.dat à été rempli à l'aide du script shell)
```
-
Nous avons juste changer le remplissage des différentes structures pour la rendre ordonnée et croissante :
```java
public static Collection add(Collection c, int size) {
@@ -169,9 +168,7 @@ public static Collection add(Collection c, int size) {
### Analyse des résultats expérimentaux
-Tout d'abord nous remarquons que la structure `LinkedList` as gagné en temps d'éxécution global mais au niveau de la mémoire, il n'y as aucun changement particulier.
-
-De plus, on
+Nous remarquons déjà par les axes de nos graphes qu'au niveau du temps de traitement, les plus grands temps sont passés de plus de 5 min à moins de 30 secondes, pour toutes les structures testées.
### Discussion des résultats expérimentaux
diff --git a/shellscript/script.sh b/shellscript/script.sh
index 6850945402df70054d833d38fa38c8ef9d5f183c..acc196e1c35d27c0854e113a50d4f9fa9f56de08 100755
--- a/shellscript/script.sh
+++ b/shellscript/script.sh
@@ -5,12 +5,7 @@ structType[1]="LinkedList"
structType[2]="HashSet"
size=500000
-
-operationSize[0]=5000
-operationSize[1]=10000
-operationSize[2]=20000
-operationSize[3]=30000
-operationSize[4]=50000
+count=10000
operationType[0]="Ajout"
operationType[1]="Présence"
@@ -23,13 +18,10 @@ cd ../src
echo -e "Size\tOperation\tOpSize\tType\tTime\tMemory"
for operation in ${operationType[*]}; do
- for opSize in ${operationSize[*]}; do
- for type in ${structType[*]}; do
-
- res=$((/usr/bin/time -f "\t%U\t%M" /usr/bin/java Main $type $size $operation $opSize) 2>&1)
- echo -e "$size\t$operation\t$opSize\t$type\t$res"
-
- done
+ for type in ${structType[*]}; do
+
+ res=$((/usr/bin/time -f "\t%U\t%M" /usr/bin/java Main $type $size $operation) 2>&1)
+ echo -e "$size\t$operation\t$count\t$type\t$res"
done
done
cd ../graphs
diff --git a/shellscript/script_hypo.sh b/shellscript/script_hypo.sh
index e09db9b1ff8a198ec574eeeb52cb42bcdbdb9256..0a5ed17e5bb2544a2c018d63f88459f4cae5564f 100755
--- a/shellscript/script_hypo.sh
+++ b/shellscript/script_hypo.sh
@@ -5,12 +5,7 @@ structType[1]="LinkedList"
structType[2]="HashSet"
size=500000
-
-operationSize[0]=5000
-operationSize[1]=10000
-operationSize[2]=20000
-operationSize[3]=30000
-operationSize[4]=50000
+count=10000
operationType[0]="Ajout"
operationType[1]="Présence"
@@ -22,13 +17,11 @@ cd ../src
echo -e "Size\tOperation\tOpSize\tType\tTime\tMemory"
for operation in ${operationType[*]}; do
- for opSize in ${operationSize[*]}; do
- for type in ${structType[*]}; do
-
- res=$((/usr/bin/time -f "\t%U\t%M" /usr/bin/java Hypothese $type $size $operation $opSize) 2>&1)
- echo -e "$size\t$operation\t$opSize\t$type\t$res"
-
- done
+ for type in ${structType[*]}; do
+
+ res=$((/usr/bin/time -f "\t%U\t%M" /usr/bin/java Hypothese $type $size $operation) 2>&1)
+ echo -e "$size\t$operation\t$count\t$type\t$res"
+
done
done
cd ../graphs
diff --git a/src/Hypothese.java b/src/Hypothese.java
index 8e9da22ddee2ff5ca3835298f65971d90ba9f087..96ace7b8df6169518f7fb32295e46c170f4ac38a 100644
--- a/src/Hypothese.java
+++ b/src/Hypothese.java
@@ -1,4 +1,7 @@
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
/**
* Hypothese
@@ -29,22 +32,22 @@ public class Hypothese {
}
public static void main(String[] args) {
- if (args.length < 4) {
- System.out.println("Usage : java Main StructureType Length Operation \n");
+ if (args.length < 3) {
+ System.out.println("Usage : java Main StructureType Length \n");
System.exit(1);
}
switch (args[0]) {
default: {
- list = new OwnArrayList<Integer>();
+ list = new ArrayList<Integer>();
break;
}
case "LinkedList": {
- list = new OwnLinkedList<Integer>();
+ list = new LinkedList<Integer>();
break;
}
case "HashSet": {
- list = new OwnHashSet<Integer>();
+ list = new HashSet<Integer>();
break;
}
}
diff --git a/src/ListInterface.java b/src/ListInterface.java
deleted file mode 100644
index cbe74f7826c78959cd2481337b6b50b8ad637d9a..0000000000000000000000000000000000000000
--- a/src/ListInterface.java
+++ /dev/null
@@ -1,40 +0,0 @@
-import java.util.Collection;
-
-/**
- * ListInterface
- */
-public interface ListInterface<E> extends Collection<E>{
-
- /**
- * Checks if the value is inside our List
- * @param i value to check
- * @return boolean value of the presence of the value
- */
- public abstract boolean contains(Object i);
-
- /**
- * Remove the value at a certain index
- * @param i index to remove
- * @return status of the removal
- */
- public abstract boolean remove(Integer i);
-
- /**
- * Get the first value of our List
- * @return the first value of our List
- */
- public abstract E getFirst();
-
- /**
- * Get the last value of our List
- * @return the last value of our List
- */
- public abstract E getLast();
-
- /**
- * add a value to our List
- * @param elem value to add
- * @return status of the adding
- */
- public abstract boolean add(E elem);
-}
diff --git a/src/Main.java b/src/Main.java
index eb9ea0e234e5697f7b6f4c7ff328980a6ceecd58..683ff471cba3e42900c2a90c3a260b6ebfb0d5d2 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -1,12 +1,38 @@
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
import java.util.Random;
public class Main {
+
+ private static Collection list;
+ private static Random r = new Random();
+ private static final int DEFAULT_COUNT = 10000;
+
+
+ public static Collection add(Collection c, int size) {
+ for (int i = 0; i < size; i++) {
+ c.add(r.nextInt());
+ }
+ return c;
+ }
+
+ public static void contains(Collection c, int size) {
+ for (int i = 0; i < size; i++) {
+ c.contains(i);
+ }
+ }
+
+ public static void remove(Collection c, int size) {
+ for (int i = 0; i < size; i++) {
+ c.remove(i);
+ }
+ }
public static void main(String[] args) {
- ListInterface<Integer> list;
- Random r = new Random();
r.setSeed(System.currentTimeMillis());
if (args.length < 4) {
- System.out.println("Usage : java Main StructureType Length Operation AssociatedValue \n");
+ System.out.println("Usage : java Main StructureType Length Operation\n");
System.exit(1);
}
@@ -14,53 +40,35 @@ public class Main {
String type = args[0];
int size = Integer.parseInt(args[1]);
String op = args[2];
- int sizeOp = Integer.parseInt(args[3]);
//Création de la structure choisie (ArrayList, LinkedList ou HashSet) :
switch (type) {
default: {
- list = new OwnArrayList<Integer>();
+ list = new ArrayList<Integer>();
break;
}
case "LinkedList": {
- list = new OwnLinkedList<Integer>();
+ list = new LinkedList<Integer>();
break;
}
case "HashSet": {
- list = new OwnHashSet<Integer>();
+ list = new HashSet<Integer>();
break;
}
}
- //On remplie la structure de données aléatoires :
- for (int i = 0; i < size; ++i) {
- list.add(r.nextInt());
- }
-
//On effectue l'opération choisie (add, contains ou remove) :
switch (op) {
default: {
- for (int i = 0; i < sizeOp; ++i) {
- list.add(r.nextInt());
- }
+ add(list,size);
break;
}
case "Présence": {
- list.contains(sizeOp);
+ contains(add(list, DEFAULT_COUNT), size);
break;
}
case "Suppression": {
- for (int i = 0; i < sizeOp; ++i) {
- list.remove(sizeOp);
- }
- break;
- }
- case "getFirst": {
- System.out.println(list.getFirst());
- break;
- }
- case "getLast": {
- System.out.println(list.getLast());
+ remove(add(list, DEFAULT_COUNT), size);
break;
}
}
diff --git a/src/OwnArrayList.java b/src/OwnArrayList.java
deleted file mode 100644
index 270258dcaa47fad5ed42001adeab9036efd60736..0000000000000000000000000000000000000000
--- a/src/OwnArrayList.java
+++ /dev/null
@@ -1,32 +0,0 @@
-import java.util.ArrayList;
-
-/**
- * OwnArrayList
- */
-public class OwnArrayList<E> extends ArrayList<E> implements ListInterface<E>{
-
- @Override
- public E getFirst(){
- return super.get(0);
- }
-
- @Override
- public E getLast(){
- return super.get(super.size()-1);
- }
-
- @Override
- public boolean contains(Object i) {
- return super.contains(i);
- }
-
- @Override
- public boolean remove(Integer i) {
- return super.remove(i);
- }
-
- @Override
- public boolean add(E elem) {
- return super.add(elem);
- }
-}
diff --git a/src/OwnHashSet.java b/src/OwnHashSet.java
deleted file mode 100644
index 69d1a0f61cf03412ed89c6f0e3c991baff609950..0000000000000000000000000000000000000000
--- a/src/OwnHashSet.java
+++ /dev/null
@@ -1,36 +0,0 @@
-import java.util.HashSet;
-
-/**
- * OwnHashSet
- */
-public class OwnHashSet<E> extends HashSet<E> implements ListInterface<E> {
-
- @Override
- public E getFirst(){
- return super.iterator().next();
- }
-
- @Override
- public E getLast(){
- E lastElement = super.iterator().next();
- while(super.iterator().hasNext()){
- lastElement = super.iterator().next();
- }
- return lastElement;
- }
-
- @Override
- public boolean contains(Object i){
- return super.contains(i);
- }
-
- @Override
- public boolean remove(Integer i){
- return super.remove(i);
- }
-
- @Override
- public boolean add(E elem){
- return super.add(elem);
- }
-}
\ No newline at end of file
diff --git a/src/OwnLinkedList.java b/src/OwnLinkedList.java
deleted file mode 100644
index 1b83f390fb75a3cee439a483038a4d1a15be8ffb..0000000000000000000000000000000000000000
--- a/src/OwnLinkedList.java
+++ /dev/null
@@ -1,37 +0,0 @@
-import java.util.LinkedList;
-
-/**
- * OwnLinkedList
- */
-public class OwnLinkedList<E> extends LinkedList<E> implements ListInterface<E>{
-
- /**
- *
- */
- private static final long serialVersionUID = 1L;
-
- @Override
- public E getFirst(){
- return super.get(0);
- }
-
- @Override
- public E getLast(){
- return super.get(this.size()-1);
- }
-
- @Override
- public boolean contains(Object i){
- return super.contains(i);
- }
-
- @Override
- public boolean remove(Integer i){
- return super.remove(i);
- }
-
- @Override
- public boolean add(E elem){
- return super.add(elem);
- }
-}