Commit cdf94d39 authored by Jeremie MALUEKI NGOMBI's avatar Jeremie MALUEKI NGOMBI
Browse files

plots

parent 96b36d36
Pipeline #4679 failed with stage
in 7 seconds
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = arraylist.o analyzer.o main.o
CPP_O_FILE = arraylist.o analyzer.o main_dynamic.o
LIB = -lm
......
#include "dynamic_heap.h"
#include<stdio.h>
#include <math.h>
#include<stdlib.h>
arraylist_t * arraylist_create(int capacity){
arraylist_t * res = (arraylist_t *) malloc( sizeof(arraylist_t) );
res->data = (int *) malloc( sizeof(int) * capacity );
res->capacity = capacity;
res->size = 0;
res->swap = 0;
return res;
}
void arraylist_destroy(arraylist_t * a){
if( a != NULL ){
if( a->data != NULL )
free( a->data );
free( a );
}
}
char arraylist_append(arraylist_t * a, int x){
char memory_allocation = FALSE;
if( a!=NULL ){
if( arraylist_do_we_need_to_enlarge_capacity(a)){
arraylist_enlarge_capacity(a);
}
int i=a->size+1;
a->data[i] = x;
a->swap = 0;
while ((i>0) && (a->data[i] < a->data[i/2]))
{
int tmp=a->data[i];
a->data[i]=a->data[i/2];
a->data[i/2]=tmp;
a->swap++;
i=i/2;
}
a->size++;
}
return memory_allocation;
}
void tasser (arraylist_t *a, int i){
int g = 2*i;
int d = 2*i+1;
int cle = i;
if (g < a->size && a->data[g] < a->data[cle]){
cle = g;
}
if (d < a->size && a->data[d] < a->data[cle]){
cle = g;
}
if (cle != i){
swap(&a->data[i],&a->data[cle]);
tasser(a,cle);
}
}
int extractMin (arraylist_t * a){
if (a!=NULL){
if (a->size<=0)
{
fprintf(stderr,"tas vide\n");
}
if(arraylist_do_we_need_to_reduce_capacity(a)){
arraylist_reduce_capacity(a);
}
if(a->size == 1){
a->size--;
return a->data[1];
}
int min = a->data[1];
a->data[1] = a->data[a->size];
tasser(a,1);
a->size--;
return min;
}
}
char arraylist_pop_back(arraylist_t * a){
char memory_reduction = FALSE;
if( a!=NULL && a->size>0 ){
if( arraylist_do_we_need_to_reduce_capacity(a) ){
memory_reduction = TRUE;
arraylist_reduce_capacity(a);
}
a->size--;
}
return memory_reduction;
}
int arraylist_get(arraylist_t * a, int pos){
if( a != NULL && pos >0 && pos < a->size ){
return a->data[pos];
}
printf("Wrong parameter pos=%d or NULL list", pos);
return -1;
}
size_t arraylist_size(arraylist_t * a){
return ( a!=NULL) ? a->size : -1;
}
size_t arraylist_capacity(arraylist_t * a){
return ( a!=NULL) ? a->capacity : -1;
}
char arraylist_do_we_need_to_enlarge_capacity(arraylist_t * a){
return a->size == a->capacity ? TRUE: FALSE;
}
void arraylist_enlarge_capacity(arraylist_t * a){
a->capacity *= 2;
a->data = (int *) realloc(a->data, sizeof(int) * a->capacity);
}
char arraylist_do_we_need_to_reduce_capacity(arraylist_t * a){
return ( a->size <= a->capacity/4 && a->size >4 )? TRUE: FALSE;
}
void arraylist_reduce_capacity(arraylist_t * a){
a->capacity /= 2;
a->data = (int *) realloc(a->data, sizeof(int) * a->capacity);
}
void swap(int *x, int *y)
{
int temp = *x;
*x = *y;
*y = temp;
}
size_t arraylist_nbswap(arraylist_t * a){
if(a!=NULL)
return a->swap;
return 0;
}
\ No newline at end of file
#ifndef __ARRAYLIST_H
#define __ARRAYLIST_H
#define FALSE 0
#define TRUE 1
#include <stddef.h>
/**
Tableau dynamique d'entiers.
*/
typedef struct arraylist_s{
// Pointeur vers la zone de mémoire où les entiers seront stockées.
int * data;
// Taille réelle, ou capacité de stockage, du tableau.
size_t capacity;
// Nombre d'éléments stockés dans le tableau.
size_t size;
//nombre de swap effectué
size_t swap;
} arraylist_t;
/**
Fonction d'initialisation d'un tableau dynamique.
Complexité en temps/espace, pire et meilleur cas : O(1)
@param capacity est la capacité que l'on souhaite donner a l'arraylist
@return Un pointeur sur un tableau dynamique nouvellement alloué.
*/
arraylist_t * arraylist_create(int capacity);
/**
Fonction de libération de la mémoire occupée par un tableau dynamique.
Complexité en temps/espace, pire et meilleur cas : O(1)
@param a est un pointeur vers l'espace mémoire que la fonction va libérer.
*/
void arraylist_destroy(arraylist_t * a);
/**
Ajoute une valeur dans le tableau.
Complexité en temps/espace, pire cas : O(size)
Complexité en temps/espace, meilleur cas : O(1)
Complexité amortie : O(1)
@param a est le tableau auquel on souhaite ajouter une valeur.
@param x est la valeur que l'on souhaite ajouter
@returns VRAI si le tableau a été agrandit, FAUX sinon
*/
char arraylist_append(arraylist_t * a, int x);
/**
* Renvoie le nombre d'échanges(swap) effectué lors d'une opération
* @param a est le tableau auquel on souhaite connaitre le nombre d'échange effectué
* @returns le nombre d'échanges effectué
*/
size_t arraylist_nbswap(arraylist_t * a);
/**
* Extrait la racine (le min) du tas min.
* @param a le tableau auquel on souhaite extraire le min.
* @returns l'entier min du tas
*/
int extractMin (arraylist_t * a);
/**
Supprime la dernière valeur du tableau.
Complexité en temps, pire cas : O(size)
Complexité en temps, meilleur cas : O(1)
Complexité amortie : O(1)
@param a est le tableau auquel on souhaite ajouter une valeur.
@returns VRAI si le tableau a été réduit, FAUX sinon
*/
char arraylist_pop_back(arraylist_t * a);
/**
Renvoie la valeur située à la position donnée par l'utilisateur.
Complexité en temps/espace, pire cas : O(1)
@param a est un pointeur vers un tableau.
@param pos est la l'indice de la case on l'utilisateur veut connaître la valeur.
@returns la valeur située à la position donnée par l'utilisateur.
*/
int arraylist_get(arraylist_t * a, int pos);
/**
Renvoie le nombre d'éléments stockés dans le tableau.
Complexité en temps/espace, pire cas : O(1)
@param a est un pointeur vers un tableau.
@returns le nombre d'éléments stockés dans le tableau.
*/
size_t arraylist_size(arraylist_t * a);
/**
Renvoie la capacité de stockage du tableau.
Complexité en temps/espace, pire cas : O(1)
@param a est un pointeur vers un tableau.
@returns la capacité de stockage du tableau.
*/
size_t arraylist_capacity(arraylist_t * a);
/**
Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
@param a est un pointeur vers un tableau.
@returns VRAI si le tableau doit être agrandi, FAUX sinon.
*/
char arraylist_do_we_need_to_enlarge_capacity(arraylist_t * a);
/**
Cette fonction augmente la capacité du tableau.
@param a est un pointeur vers un tableau.
*/
void arraylist_enlarge_capacity(arraylist_t * a);
/**
Cette fonction détermine la règle selon laquelle un espace mémoire plus petit sera alloué ou non.
@param a est un pointeur vers un tableau.
@returns VRAI si le tableau doit être réduit, FAUX sinon.
*/
char arraylist_do_we_need_to_reduce_capacity(arraylist_t * a);
/**
Cette fonction réduit la capacité du tableau.
@param a est un pointeur vers un tableau.
*/
void arraylist_reduce_capacity(arraylist_t * a);
void swap(int *x, int *y);
#endif
......@@ -27,13 +27,13 @@ int main(int argc, char ** argv){
for(i = 0; i < 1000000 ; i++){
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
if (aleatoire() < 0.5)// p =0.5
if (aleatoire() < 0.75)// p =0.25
{
arraylist_append(a, rand()%1000000);
}
else
{
if (a-> size !=0)
if (a->size !=0)
{
extractMin(a);
}
......
#include<stdio.h>
#include <time.h>
#include<stdlib.h>
#include "dynamic_heap.h"
#include "analyzer.h"
int main(int argc, char ** argv){
int i;
// Tableau dynamique.
arraylist_t * a = arraylist_create(1000000);
// Analyse du temps pris par les opérations.
analyzer_t * time_analysis = analyzer_create();
// Analyse du nombre de copies faites 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 une allocation a été effectuée.
char memory_allocation;
srand(time(NULL));
float aleatoire(){return (float)rand()/(float)RAND_MAX;}
for(i = 0; i < 1000000 ; i++){
// Ajout d'un élément et mesure du temps pris par l'opération.
clock_gettime(clk_id, &before);
if (aleatoire() < 0.75)// p =0.5
{
arraylist_append(a, rand()%1000000);
}
else
{
if (a->size !=0)
{
extractMin(a);
}
}
clock_gettime(clk_id, &after);
// Enregistrement du temps pris par l'opération
analyzer_append(time_analysis, after.tv_nsec - before.tv_nsec);
// 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.
analyzer_append(swap_analysis, arraylist_nbswap(a) );
// Enregistrement de l'espace mémoire non-utilisé.
analyzer_append(memory_analysis,arraylist_capacity(a)-arraylist_size(a));
}
// 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/dynamic_binary_heap_extract_time_C.plot");
save_values(swap_analysis, "../plots/dynamic_binary_heap_extract_swap_C.plot");
save_values(memory_analysis, "../plots/dynamic_binary_heap_extract_wasted_memory_C.plot");
// Nettoyage de la mémoire avant la sortie du programme
arraylist_destroy(a);
analyzer_destroy(time_analysis);
analyzer_destroy(swap_analysis);
analyzer_destroy(memory_analysis);
return EXIT_SUCCESS;
}
## Que se passe t-il lorsque l'on ajoute des opérations de suppression? En temps? En mémoire?
à completer
## La complexité amortie des opérations d’ajout et de suppression/extraction a t-elle changé sur les expériences utilisant un tableau dynamique ? Pourquoi ?
à completer
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment