Commit 2cd1def3 authored by Moïse Destin's avatar Moïse Destin
Browse files

Exo 3 raw

parent 5c0dbc1e
Pipeline #4682 passed with stage
in 9 seconds
No preview for this file type
......@@ -3,10 +3,19 @@
<component name="ChangeListManager">
<list default="true" id="298fa7eb-9511-4983-9e33-1e1f5e3f9ebe" name="Changes" comment="">
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
<change beforePath="$PROJECT_DIR$/Java/Tas.java" beforeDir="false" afterPath="$PROJECT_DIR$/Java/Tas.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/RAPPORT.md" beforeDir="false" afterPath="$PROJECT_DIR$/RAPPORT.md" afterDir="false" />
<change beforePath="$PROJECT_DIR$/Java/ArrayList.java" beforeDir="false" afterPath="$PROJECT_DIR$/Java/ArrayList.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/Java/Main.java" beforeDir="false" afterPath="$PROJECT_DIR$/Java/Main.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/Java/TasMainAjoutSup.java" beforeDir="false" afterPath="$PROJECT_DIR$/Java/TasStaticIncreaseDecrease.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/launch_analysis_ajout_supp_prob.sh" beforeDir="false" afterPath="$PROJECT_DIR$/launch_analysis_ajout_supp_prob.sh" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/fixed_binary_heap_amortized_time_java_decreasing.pdf" beforeDir="false" afterPath="$PROJECT_DIR$/plots/fixed_binary_heap_amortized_time_java_decreasing.pdf" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_memory_java_croissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_memory_java_croissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_memory_java_decroissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_memory_java_decroissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_memory_java_random.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_memory_java_random.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_swap_java_croissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_swap_java_croissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_swap_java_decroissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_swap_java_decroissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_swap_java_random.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_swap_java_random.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_time_java_croissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_time_java_croissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_time_java_decroissant.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_time_java_decroissant.plot" afterDir="false" />
<change beforePath="$PROJECT_DIR$/plots/dynamic_array_time_java_random.plot" beforeDir="false" afterPath="$PROJECT_DIR$/plots/dynamic_array_time_java_random.plot" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
......@@ -77,7 +86,7 @@
<workItem from="1637312628002" duration="11337000" />
<workItem from="1637691394538" duration="66000" />
<workItem from="1638457678589" duration="11318000" />
<workItem from="1638478890764" duration="6397000" />
<workItem from="1638478890764" duration="13638000" />
</task>
<servers />
</component>
......
......@@ -29,9 +29,78 @@ public class ArrayList<T> {
enlarge_capacity();
}
data[size++] = x;
entasserDeBasEnHaut(size-1);
return memory_allocation;
}
private void entasserDeBasEnHaut(int position_courant) {
while (isParentExist(position_courant) && (int)data[position_courant] < (int)data[parent(position_courant)]) {
echanger(position_courant, parent(position_courant));
position_courant = parent(position_courant);
}
}
private void echanger(int position_1, int position_2)
{
int tmp = (int)data[position_1];
data[position_1] = (int)data[position_2];
data[position_2] = tmp;
this.nombreEchange++;
}
// retourne la cle de plus petite valeur
public int supprimerValeurMinimale(){
if(this.size == 0)
throw new UnsupportedOperationException("le tas vide !");
int elementSupprimer = (int)data[0];
data[0] = data[size-1];
size--;
parcourirTasDeHautEnBas(0);
return elementSupprimer;
}
public void parcourirTasDeHautEnBas(int position){
while (isEnfantGaucheExist(position)){
int plusPetitEnfantIndex = enfantGauche(position); // on l'initiallise avec l'enfant du gauche, plus tard, on verifiera si droite est plus petit
if(isEnfantDroiteExist(position) && (int)data[enfantDroite(position)] < (int)data[enfantGauche(position)])
plusPetitEnfantIndex = enfantDroite(position); // c'est l'enfant du droite le plus petit, du coup apres un enchange, on aura plus a s'inquiter de la gauche
if((int)data[position] > (int)data[plusPetitEnfantIndex]){
echanger(position, plusPetitEnfantIndex);
}
position = plusPetitEnfantIndex;
}
}
private int parent(int pos) { return (pos-1) / 2; } // en index 2 dans un taille 3, 2-1/2
private boolean isParentExist(int pos) { return parent(pos) >= 0; } // l'index 0 nous donnera un element entier negatif
public int enfantGauche(int position){
return (2 * position)+1;
}
public boolean isEnfantGaucheExist(int position){
return enfantGauche(position) < size;
}
public int enfantDroite(int position){
return (2 * position) + 2;
}
public boolean isEnfantDroiteExist(int position){
return enfantDroite(position) < size;
}
/**
Supprime la dernière valeur du tableau.
Complexité en temps, pire cas : O(size)
......@@ -109,8 +178,18 @@ public class ArrayList<T> {
data = java.util.Arrays.copyOf(data, capacity/2);
capacity /= 2;
}
// Tableau dynamique en Java. Sa capacité réelle est masquée, mais on peut avoir un contrôle dessus.
public int getNombreEchange() {
return nombreEchange;
}
public void setNombreEchange(int nombreEchange) {
this.nombreEchange = nombreEchange;
}
private int nombreEchange = 0;
// Tableau dynamique en Java. Sa capacité réelle est masquée, mais on peut avoir un contrôle dessus.
private Object[] data;
// Capacité réelle du tableau data.
private int capacity;
......
......@@ -17,6 +17,7 @@ public class Main {
boolean memory_allocation;
for(i = 0; i < 1000000 ; i++){
// Ajout d'un élément et mesure du temps pris par l'opération.
before = System.nanoTime();
......
import java.util.ArrayList;
public class TasDynamique {
private ArrayList<Integer> monTas;
private int positionDansTas; // controle reaching capacity d'insertion
private int nombreEchange = 0;
private int nombreEchangePourSuppression = 0;
/**
* initialiser tas
*/
public TasDynamique(){
this.monTas = new ArrayList<Integer>();
}
private int parent(int pos) { return (pos-1) / 2; } // en index 2 dans un taille 3, 2-1/2
private boolean isParentExist(int pos) { return parent(pos) >= 0; } // l'index 0 nous donnera un element entier negatif
private void echanger(int position_1, int position_2)
{
int tmp = monTas.get(position_1);
monTas.set(position_1, monTas.get(position_2));
monTas.set(position_2, tmp);
this.nombreEchange++;
}
/**
* ajoute un nouverau element dans le tas
* dependemment du chiffre on peut remonter jusqu au root
*/
public void insererElement(int x){
monTas.add(x);
entasserDeBasEnHaut(monTas.size() - 1);
}
private void entasserDeBasEnHaut(int position_courant) {
while (isParentExist(position_courant) && monTas.get(position_courant) < monTas.get(parent(position_courant)) ) {
echanger(position_courant, parent(position_courant));
position_courant = parent(position_courant);
}
}
/**
* afficher tas
*
*/
public void afficherTas()
{
System.out.print("Tas = ");
// for (int i = 0; i < positionDansTas; i++)
// System.out.print(monTas[i] +" ");
// for (int i = 0; i < (positionDansTas / 2); i++) {
// System.out.print("Parent : " + monTas[i]);
// if (enfantGauche(i) < positionDansTas)
// System.out.print(" Left : " + monTas[enfantGauche(i)]);
// if (enfantDroite(i) < positionDansTas)
// System.out.print(" Right :" + monTas[enfantDroite(i)]);
// System.out.println();
// }
System.out.println();
}
// retourne la cle de plus petite valeur
public int supprimerValeurMinimale(){
if(this.monTas.size() == 0)
throw new UnsupportedOperationException("le tas vide !");
int elementSupprimer = monTas.get(0);
monTas.set(0, monTas.size() -1 );
monTas.remove(monTas.size() - 1);
parcourirTasDeHautEnBas(0);
return elementSupprimer;
}
public void parcourirTasDeHautEnBas(int position){
while (isEnfantGaucheExist(position)){
int plusPetitEnfantIndex = enfantGauche(position); // on l'initiallise avec l'enfant du gauche, plus tard, on verifiera si droite est plus petit
if(isEnfantDroiteExist(position) && monTas.get(enfantDroite(position)) < monTas.get(enfantGauche(position)))
plusPetitEnfantIndex = enfantDroite(position); // c'est l'enfant du droite le plus petit, du coup apres un enchange, on aura plus a s'inquiter de la gauche
if(monTas.get(position) > monTas.get(plusPetitEnfantIndex)){
echanger(position, plusPetitEnfantIndex);
this.nombreEchangePourSuppression++;
}
position = plusPetitEnfantIndex;
}
}
public int enfantGauche(int position){
return (2 * position)+1;
}
public boolean isEnfantGaucheExist(int position){
return enfantGauche(position) < positionDansTas;
}
public int enfantDroite(int position){
return (2 * position) + 2;
}
public boolean isEnfantDroiteExist(int position){
return enfantDroite(position) < positionDansTas;
}
public int getNombreEchange() {
return nombreEchange;
}
public int getTasSize(){
return monTas.size();
}
public int getNombreDelementStocker() {
return positionDansTas;
}
public int getNombreEchangePourSuppression() {
return nombreEchangePourSuppression;
}
public int getPositionDansTas() {
return positionDansTas;
}
}
public class TasDynamiqueDecrease {
public static void main(String[] args) {
int i, time_ind = 0, pop_ind = 0;
// Tableau dynamique.
ArrayList<Integer> tas = new ArrayList<Integer>();
// Analyse du temps pris par les opérations.
Analyzer time_analysis = new Analyzer();
// Analyse du nombre de copies faites par les opérations.
Analyzer swap_analysis = new Analyzer();
// Analyse de l'espace mémoire inutilisé.
Analyzer memory_analysis = new Analyzer();
long before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
boolean memory_allocation;
for(i = 100000; i >= 0 ; i--){
// Ajout d'un élément et mesure du temps pris par l'opération.
before = System.nanoTime();
tas.append(i);
after = System.nanoTime();
// Enregistrement du temps pris par l'opération
time_analysis.append(after - before);
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
swap_analysis.append( tas.getNombreEchange());
// Enregistrement de l'espace mémoire non-utilisé.
memory_analysis.append( tas.size() - tas.capacity() );
}
// Affichage de quelques statistiques sur l'expérience.
System.err.println("Total cost : "+time_analysis.get_total_cost());
System.err.println("Average cost : "+time_analysis.get_average_cost());
System.err.println("Variance :"+time_analysis.get_variance());
System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../plots/dynamic_array_time_java_decroissant.plot");
swap_analysis.save_values("../plots/dynamic_array_swap_java_decroissant.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_java_decroissant.plot");
}
}
public class TasDynamiqueIncrease {
public static void main(String[] args) {
int i, time_ind = 0, pop_ind = 0;
// Tableau dynamique.
ArrayList<Integer> tas = new ArrayList<Integer>();
// Analyse du temps pris par les opérations.
Analyzer time_analysis = new Analyzer();
// Analyse du nombre de copies faites par les opérations.
Analyzer swap_analysis = new Analyzer();
// Analyse de l'espace mémoire inutilisé.
Analyzer memory_analysis = new Analyzer();
long before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
boolean memory_allocation;
for(i = 0; i < 100000 ; i++){
// Ajout d'un élément et mesure du temps pris par l'opération.
before = System.nanoTime();
tas.append(i);
after = System.nanoTime();
// Enregistrement du temps pris par l'opération
time_analysis.append(after - before);
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
swap_analysis.append( tas.getNombreEchange());
// Enregistrement de l'espace mémoire non-utilisé.
memory_analysis.append( tas.size() - tas.capacity() );
}
// Affichage de quelques statistiques sur l'expérience.
System.err.println("Total cost : "+time_analysis.get_total_cost());
System.err.println("Average cost : "+time_analysis.get_average_cost());
System.err.println("Variance :"+time_analysis.get_variance());
System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../plots/dynamic_array_time_java_croissant.plot");
swap_analysis.save_values("../plots/dynamic_array_swap_java_croissant.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_java_croissant.plot");
}
}
import java.util.Random;
public class TasDynamiqueIncreaseDecrease {
public static void main(String[] args) {
int i, time_ind = 0, pop_ind = 0;
// Tableau dynamique.
ArrayList<Integer> tas = new ArrayList<Integer>();
// Analyse du temps pris par les opérations.
Analyzer time_analysis = new Analyzer();
// Analyse du nombre de copies faites par les opérations.
Analyzer swap_analysis = new Analyzer();
// Analyse de l'espace mémoire inutilisé.
Analyzer memory_analysis = new Analyzer();
long before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
boolean memory_allocation;
double probabilite = 0.5;
double random_number;
for(i = 1; i <= 100000 ; i++){
random_number = Math.round(randomFloat(0, 1) * 10) / 10.0;
// Ajout d'un élément et mesure du temps pris par l'opération.
before = System.nanoTime();
if(tas.size() == 0 || random_number <= probabilite) // make sure to not delete when table empty
tas.append(new Random().nextInt(100000-1) + 1);
else
tas.supprimerValeurMinimale();
after = System.nanoTime();
// Enregistrement du temps pris par l'opération
time_analysis.append(after - before);
// Enregistrement du nombre de copies efféctuées par l'opération.
memory_analysis.append( tas.size() - tas.capacity() );
}
// Affichage de quelques statistiques sur l'expérience.
System.err.println("Total cost : "+time_analysis.get_total_cost());
System.err.println("Average cost : "+time_analysis.get_average_cost());
System.err.println("Variance :"+time_analysis.get_variance());
System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../plots/dynamic_binary_heap_extract_time_java.plot");
memory_analysis.save_values("../plots/dynamic_binary_heap_extract_memory_java.plot");
}
public static double randomFloat(double min, double max){
return (double) (min + Math.random() * (max - min));
}
}
import java.util.Random;
public class TasDynamiqueRandom {
public static void main(String[] args) {
int i, time_ind = 0, pop_ind = 0;
// Tableau dynamique.
ArrayList<Integer> tas = new ArrayList<Integer>();
// Analyse du temps pris par les opérations.
Analyzer time_analysis = new Analyzer();
// Analyse du nombre de copies faites par les opérations.
Analyzer swap_analysis = new Analyzer();
// Analyse de l'espace mémoire inutilisé.
Analyzer memory_analysis = new Analyzer();
long before, after;
// Booléen permettant de savoir si une allocation a été effectuée.
boolean memory_allocation;
Random random = new Random();
for(i = 0; i < 100000 ; i++){
// Ajout d'un élément et mesure du temps pris par l'opération.
before = System.nanoTime();
tas.append(randomNumber(random, 0, 100000));
after = System.nanoTime();
// Enregistrement du temps pris par l'opération
time_analysis.append(after - before);
// Enregistrement du nombre de copies efféctuées par l'opération.
// S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
swap_analysis.append( tas.getNombreEchange());
// Enregistrement de l'espace mémoire non-utilisé.
memory_analysis.append( tas.size() - tas.capacity() );
}
// Affichage de quelques statistiques sur l'expérience.
System.err.println("Total cost : "+time_analysis.get_total_cost());
System.err.println("Average cost : "+time_analysis.get_average_cost());
System.err.println("Variance :"+time_analysis.get_variance());
System.err.println("Standard deviation :"+time_analysis.get_standard_deviation());
// Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
time_analysis.save_values("../plots/dynamic_array_time_java_random.plot");
swap_analysis.save_values("../plots/dynamic_array_swap_java_random.plot");
memory_analysis.save_values("../plots/dynamic_array_memory_java_random.plot");
}
public static int randomNumber(Random random, int min, int max){
return random.nextInt(max - min + 1) + min;
}
}
import java.util.Random;
public class TasMainAjoutSup {
public class TasStaticIncreaseDecrease {
public static void main(String[] args) {
int i, time_ind = 0, pop_ind = 0;
// Tableau dynamique.
......
......@@ -11,7 +11,7 @@ cd Java
javac *
echo "${RED} Exécution des benchmarks en Java ${NC}"
java TasMainAjoutSup
java TasStaticIncreaseDecrease
echo "${RED} Nettoyage ${NC}"
rm *.class
......
RED='\033[0;31m'
NC='\033[0m' # No Color
# Compilation et exécution en Java:
echo "${RED} Compilation du code source en Java ${NC}"
cd Java
javac *
echo "${RED} Exécution des benchmarks en Java ${NC}"
java TasDynamiqueDecrease
echo "${RED} Nettoyage ${NC}"
rm *.class
#
cd ..
# Observation des résultats
### Dans le répertoire plots, lisez le contenu du fichier plot_result
cd plots
more plot_dynamic_decrease
#
#### puis lancez ce script avec gnuplot
#
gnuplot plot_dynamic_decrease
RED='\033[0;31m'
NC='\033[0m' # No Color
# Compilation et exécution en Java:
echo "${RED} Compilation du code source en Java ${NC}"
cd Java
javac *
echo "${RED} Exécution des benchmarks en Java ${NC}"
java TasDynamiqueIncrease
echo "${RED} Nettoyage ${NC}"
rm *.class
#
cd ..
# Observation des résultats
### Dans le répertoire plots, lisez le contenu du fichier plot_result
cd plots
more plot_dynamic_increase
#
#### puis lancez ce script avec gnuplot
#
gnuplot plot_dynamic_increase
RED='\033[0;31m'
NC='\033[0m' # No Color
# Compilation et exécution en Java:
echo "${RED} Compilation du code source en Java ${NC}"
cd Java
javac *
echo "${RED} Exécution des benchmarks en Java ${NC}"
java TasDynamiqueIncreaseDecrease
echo "${RED} Nettoyage ${NC}"
rm *.class
#
cd ..
# Observation des résultats
### Dans le répertoire plots, lisez le contenu du fichier plot_result
cd plots
more plot_dynamic_increase_decrease
#
#### puis lancez ce script avec gnuplot
#