Commit 1f4b4b54 authored by MARRAKCHI_GHASSEN's avatar MARRAKCHI_GHASSEN
Browse files

Exercice 1 & 2

parent 70e1588f
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = arraylist.o analyzer.o main.o
CPP_O_FILE = ../__src/binary_heap.o ../__src/analyzer.o main_aleatoire.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o arraylist_analysis $(CPP_O_FILE) $(LIB)
$(CC) $(CXXFLAGS) -o main_aleatoire $(CPP_O_FILE) $(LIB)
clean:
rm -rf ../__src/*.o
rm -rf *.o
rm -rf *~
rm -rf arraylist_analysis
rm -rf main_aleatoire
\ No newline at end of file
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "../__src/analyzer.h"
#include "../__src/binary_heap.h"
int main(int argc, char ** argv){
// Création d'un vecteur de valeurs aléatoirement ordonnées
// On adoptera le même vecteur pour les deux expériences (TAS MIN & TAS MAX)
srand(time(0));
int* random_vector = create_random_vector(BINARY_HEAP_LENGTH);
// Affichage du tableau
fprintf(stderr, " Random Table : ");
for(int indice=0;indice<BINARY_HEAP_LENGTH;indice++){
fprintf(stderr, " %d _", random_vector[indice]);
}
fprintf(stderr, " \n");
/* TAS BINAIRE MAX */
// Tas Binaire de taille fixe
binary_heap_t * h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MAX);
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
analyzer_t * swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
analyzer_t * memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
struct timespec before, after;
clockid_t clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
int insertion;
for(int i = BINARY_HEAP_LENGTH + 1; i > 1 ; i--){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, random_vector[i-1]);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!!! Aléatoire - TAS MAX INTERROMPU !!!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_random_tas_max.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_random_tas_max.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_random_tas_max.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
fprintf(stderr, "************************************\n");
fprintf(stderr, "***** Aléatoire - TAS MAX FINI *****\n");
fprintf(stderr, "************************************\n");
/* TAS BINAIRE MIN */
// Tas Binaire de taille fixe
h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MIN);
// Analyse du temps pris par les opérations.
time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
insertion = FALSE;
for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, random_vector[i-1]);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!!! Aléatoire - TAS MIN INTERROMPU !!!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_random_tas_min.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_random_tas_min.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_random_tas_min.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
free(random_vector);
fprintf(stderr, "************************************\n");
fprintf(stderr, "***** Aléatoire - TAS MIN FINI *****\n");
fprintf(stderr, "************************************\n");
return EXIT_SUCCESS;
}
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = ../__src/binary_heap.o ../__src/analyzer.o main_croissant.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o main_croissant $(CPP_O_FILE) $(LIB)
clean:
rm -rf ../__src/*.o
rm -rf *.o
rm -rf *~
rm -rf main_croissant
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "../__src/analyzer.h"
#include "../__src/binary_heap.h"
int main(int argc, char ** argv){
/* TAS BINAIRE MAX */
// Tas Binaire de taille fixe
binary_heap_t * h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MAX);
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
analyzer_t * swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
analyzer_t * memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
struct timespec before, after;
clockid_t clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
int insertion;
for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, i);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!!! Croissant - TAS MAX INTERROMPU !!!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_increasing_tas_max.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_increasing_tas_max.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_increasing_tas_max.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
fprintf(stderr, "************************************\n");
fprintf(stderr, "***** Croissant - TAS MAX FINI *****\n");
fprintf(stderr, "************************************\n");
/* TAS BINAIRE MIN */
// Tas Binaire de taille fixe
h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MIN);
// Analyse du temps pris par les opérations.
time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
insertion = FALSE;
for(int i = 1; i < BINARY_HEAP_LENGTH + 1 ; i++){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, i);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!!! Croissant - TAS MIN INTERROMPU !!!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_increasing_tas_min.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_increasing_tas_min.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_increasing_tas_min.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
fprintf(stderr, "************************************\n");
fprintf(stderr, "***** Croissant - TAS MIN FINI *****\n");
fprintf(stderr, "************************************\n");
return EXIT_SUCCESS;
}
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = ../__src/binary_heap.o ../__src/analyzer.o main_decroissant.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o main_decroissant $(CPP_O_FILE) $(LIB)
clean:
rm -rf ../__src/*.o
rm -rf *.o
rm -rf *~
rm -rf main_decroissant
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "../__src/analyzer.h"
#include "../__src/binary_heap.h"
int main(int argc, char ** argv){
/* TAS BINAIRE MAX */
// Tas Binaire de taille fixe
binary_heap_t * h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MAX);
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
analyzer_t * swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
analyzer_t * memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
struct timespec before, after;
clockid_t clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
int insertion;
for(int i = BINARY_HEAP_LENGTH + 1; i > 1 ; i--){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, i);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!! Decroissant - TAS MAX INTERROMPU !!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_decreasing_tas_max.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_decreasing_tas_max.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_decreasing_tas_max.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
fprintf(stderr, "************************************\n");
fprintf(stderr, "**** Decroissant - TAS MAX FINI ****\n");
fprintf(stderr, "************************************\n");
/* TAS BINAIRE MIN */
// Tas Binaire de taille fixe
h = binary_heap_create(BINARY_HEAP_LENGTH, BINARY_HEAP_MIN);
// Analyse du temps pris par les opérations.
time_analysis = analyzer_create();
// Analyse des swap faits par les opérations.
swap_analysis = analyzer_create();
// Analyse de l'espace mémoire inutilisé.
memory_analysis = analyzer_create();
// Mesure de la durée d'une opération.
clk_id = CLOCK_REALTIME;
// utilisé comme booléen pour savoir si un ajout a été effectué.
insertion = FALSE;
for(int i = BINARY_HEAP_LENGTH + 1; i > 1 ; i--){
fprintf(stderr, "Itération %d\n", i);
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
insertion = binary_heap_append(h, i);
clock_gettime(clk_id, &after);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
fprintf(stderr, "!!!! Decroissant - TAS MIN INTERROMPU !!!!\n");
fprintf(stderr, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
return EXIT_FAILURE;
}
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// Enregistrement des swaps de l'opération.
// S'il y a eu des swap, il a fallu décaler un certain nombre d'élement les élements.
analyzer_append(swap_analysis, swap_number());
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,binary_heap_length(h)-binary_heap_size(h));
fprintf(stderr, "A LA FIN DE L'ITER : ");
print_binary_heap(h);
}
// Affichage de quelques statistiques sur l'expérience.
fprintf(stderr, "Total cost: %Lf\n", get_total_cost(time_analysis));
fprintf(stderr, "Average cost: %Lf\n", get_average_cost(time_analysis));
fprintf(stderr, "Variance: %Lf\n", get_variance(time_analysis));
fprintf(stderr, "Standard deviation: %Lf\n", get_standard_deviation(time_analysis));
// Sauvegarde les données de l'expérience.
save_values(time_analysis, "../../plots/fixed_binary_heap_time_c_decreasing_tas_min.plot");
save_values(swap_analysis, "../../plots/fixed_binary_heap_swap_c_decreasing_tas_min.plot");
save_values(memory_analysis, "../../plots/fixed_binary_heap_memory_c_decreasing_tas_min.plot");
// Nettoyage de la mémoire avant la sortie du programme
binary_heap_destroy(h);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
fprintf(stderr, "************************************\n");
fprintf(stderr, "**** Decroissant - TAS MIN FINI ****\n");
fprintf(stderr, "************************************\n");
return EXIT_SUCCESS;
}
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = ../__src/binary_heap.o ../__src/analyzer.o main_test_structure.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o main_test_structure $(CPP_O_FILE) $(LIB)
clean:
rm -rf ../__src/*.o
rm -rf *.o
rm -rf *~
rm -rf main_test_structure
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "../__src/analyzer.h"
#include "../__src/binary_heap.h"
int main(int argc, char ** argv){
/* ENTREE DES VALURS DE L'UTILSATEUR */
// Vecteur des valeurs
int vecteur_valeur[5] = {0};
// Saisie des valeurs par l'utilisateur
for(int i=0; i<5 ; i++){
fflush(stdin);
printf("Saisissez une valeur : ");
scanf("%d", vecteur_valeur + i);
}
/* EXECUTION DES DIFFERENTS SCENARIOS */
// Tas Binaire MIN de taille fixe
binary_heap_t * h = binary_heap_create(5, BINARY_HEAP_MIN);
// Insertion d'une valeur par l'utilisateur
// utilisé comme booléen pour savoir si un ajout a été effectué.
char insertion;
// Scenario TAS MIN
fprintf(stdout, "---------------\n");
fprintf(stdout, "--- TAS MIN ---\n");
fprintf(stdout, "---------------\n");
// Insertion
for(int i=0; i<5 ; i++){
insertion = binary_heap_append(h, vecteur_valeur[i]);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
return EXIT_FAILURE;
}
print_binary_heap(h);
}
// Destruction
binary_heap_destroy(h);
// Tas Binaire MAX de taille fixe
h = binary_heap_create(5, BINARY_HEAP_MAX);
// Insertion d'une valeur par l'utilisateur
// utilisé comme booléen pour savoir si un ajout a été effectué.
insertion = FALSE;
// Scenario TAS MAX
fprintf(stdout, "---------------\n");
fprintf(stdout, "--- TAS MAX ---\n");
fprintf(stdout, "---------------\n");
// Insertion
for(int i=0; i<5 ; i++){
insertion = binary_heap_append(h, vecteur_valeur[i]);
if(!insertion){
fprintf(stderr, "Insertion non effectuée\n");
return EXIT_FAILURE;
}
print_binary_heap(h);
}
// Destruction
binary_heap_destroy(h);
return EXIT_SUCCESS;
}
#include "binary_heap.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int global_swap_number = 0;
binary_heap_t * binary_heap_create(int length, int type){