plots

C/Makefile

 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
 
 

C/dynamic_heap.c

+#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

C/dynamic_heap.h

+#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
+ 
+ 

C/main.c

@@ -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);
       }

C/main_dynamic.c

+#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;
+}

RAPPORT.md

+## 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