Skip to content

GitLab

Commit 96b36d36 authored by Jeremie MALUEKI NGOMBI's avatar Jeremie MALUEKI NGOMBI
Browse files

Exercice 2

parent 1b20a080
Pipeline #4652 failed with stage
in 7 seconds
Hide whitespace changes
Inline Side-by-side
.gitignore
View file @ 96b36d36
*/*~
Python/__pycache__/*
Sujets/*
CPP/src/*
CPP/include/*
Corrections/*
Java/*.class
Java/.idea
plots/plot_files/*
*/*~
Python/__pycache__/*
Sujets/*
CPP/src/*
CPP/include/*
Corrections/*
Java/*.class
Java/.idea
plots/plot_files/*
plots/png/*
\ No newline at end of file
.gitlab-ci.yml
View file @ 96b36d36
image: alpine
stages:
- test
sda:test:
script:
- echo "Exercice 1"
- ls -lF AUTHORS.md
- echo "Exercice 2"
- ls -lF plots/fixed_binary_heap_extract_*.pdf
- echo "Exercice 3"
- ls -lF plots/dynamic_binary_heap_*.pdf
- echo "Exercice 4"
- ls -lF RAPPORT.md
image: alpine
stages:
- test
sda:test:
script:
- echo "Exercice 1"
- ls -lF AUTHORS.md
- echo "Exercice 2"
- ls -lF plots/fixed_binary_heap_extract_*.pdf
- echo "Exercice 3"
- ls -lF plots/dynamic_binary_heap_*.pdf
- echo "Exercice 4"
- ls -lF RAPPORT.md
C/Makefile
View file @ 96b36d36
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = arraylist.o analyzer.o main_random.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o arraylist_analysis $(CPP_O_FILE) $(LIB)
clean:
rm -rf *.o
rm -rf *~
rm -rf arraylist_analysis
CC= gcc
CXXFLAGS= -Wall -ansi --pedantic -O3
CPP_O_FILE = arraylist.o analyzer.o main.o
LIB = -lm
all: $(CPP_O_FILE)
$(CC) $(CXXFLAGS) -o arraylist_analysis $(CPP_O_FILE) $(LIB)
clean:
rm -rf *.o
rm -rf *~
rm -rf arraylist_analysis
C/analyzer.c
View file @ 96b36d36
#include"analyzer.h"
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
analyzer_t * analyzer_create(){
analyzer_t * res = (analyzer_t *) malloc( sizeof(analyzer_t) );
res->capacity = 4;
res->cost = (double *) malloc( sizeof(double) * res->capacity );
res->cumulative_cost = (long double *) malloc( sizeof(long double) * res->capacity );
res->cumulative_square = 0.;
res->size = 0;
return res;
}
void analyzer_destroy(analyzer_t * a){
if( a != NULL ){
free( a->cost );
free( a->cumulative_cost );
free( a );
}
}
void analyzer_append(analyzer_t * a, double x){
if( a!=NULL ){
if( a->size >= (a->capacity * 3)/4 ){
a->capacity *= 2;
a->cost = (double *) realloc(a->cost, sizeof(double) * a->capacity*2);
a->cumulative_cost = (long double *) realloc(a->cumulative_cost, sizeof(long double) * a->capacity*2);
}
a->cost[a->size] = x;
a->cumulative_cost[a->size] = (a->size) ? a->cumulative_cost[a->size-1]+x : x;
a->cumulative_square += x*x;
a->size++;
}
}
long double get_total_cost(analyzer_t * a){
return (a->size) ? a->cumulative_cost[a->size-1] : -1;
}
long double get_amortized_cost(analyzer_t * a, size_t pos){
if(pos >= 0 && pos < a->size)
return (pos)? a->cumulative_cost[pos]/pos : a->cumulative_cost[pos];
return -1;
}
long double get_average_cost(analyzer_t * a){
if(a->size)
return a->cumulative_cost[a->size - 1]/a->size;
return -1;
}
long double get_variance(analyzer_t * a){
long double mean, mean_square;
if(a->size){
mean = get_average_cost(a);
mean_square = mean * mean;
return a->cumulative_square - mean_square;
}
return -1;
}
long double get_standard_deviation(analyzer_t * a){
if(a->size)
return sqrt(get_variance(a));
return -1;
}
void save_values(analyzer_t * a, char * path){
FILE * f;
int i;
if( (f = fopen(path, "w")) != NULL ){
for (i = 0; i < a->size; ++i){
fprintf(f,"%d %lf %Lf\n", i, a->cost[i], get_amortized_cost(a, i));
}
}else{
fprintf(stderr, "Could not save values in file %s", path);
}
}
void plot_values(analyzer_t * a){
int i;
for (i = 0; i < a->size; ++i){
printf("%d %lf %Lf\n", i, a->cost[i], get_amortized_cost(a, i));
}
}
#include"analyzer.h"
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
analyzer_t * analyzer_create(){
analyzer_t * res = (analyzer_t *) malloc( sizeof(analyzer_t) );
res->capacity = 4;
res->cost = (double *) malloc( sizeof(double) * res->capacity );
res->cumulative_cost = (long double *) malloc( sizeof(long double) * res->capacity );
res->cumulative_square = 0.;
res->size = 0;
return res;
}
void analyzer_destroy(analyzer_t * a){
if( a != NULL ){
free( a->cost );
free( a->cumulative_cost );
free( a );
}
}
void analyzer_append(analyzer_t * a, double x){
if( a!=NULL ){
if( a->size >= (a->capacity * 3)/4 ){
a->capacity *= 2;
a->cost = (double *) realloc(a->cost, sizeof(double) * a->capacity*2);
a->cumulative_cost = (long double *) realloc(a->cumulative_cost, sizeof(long double) * a->capacity*2);
}
a->cost[a->size] = x;
a->cumulative_cost[a->size] = (a->size) ? a->cumulative_cost[a->size-1]+x : x;
a->cumulative_square += x*x;
a->size++;
}
}
long double get_total_cost(analyzer_t * a){
return (a->size) ? a->cumulative_cost[a->size-1] : -1;
}
long double get_amortized_cost(analyzer_t * a, size_t pos){
if(pos >= 0 && pos < a->size)
return (pos)? a->cumulative_cost[pos]/pos : a->cumulative_cost[pos];
return -1;
}
long double get_average_cost(analyzer_t * a){
if(a->size)
return a->cumulative_cost[a->size - 1]/a->size;
return -1;
}
long double get_variance(analyzer_t * a){
long double mean, mean_square;
if(a->size){
mean = get_average_cost(a);
mean_square = mean * mean;
return a->cumulative_square - mean_square;
}
return -1;
}
long double get_standard_deviation(analyzer_t * a){
if(a->size)
return sqrt(get_variance(a));
return -1;
}
void save_values(analyzer_t * a, char * path){
FILE * f;
int i;
if( (f = fopen(path, "w")) != NULL ){
for (i = 0; i < a->size; ++i){
fprintf(f,"%d %lf %Lf\n", i, a->cost[i], get_amortized_cost(a, i));
}
}else{
fprintf(stderr, "Could not save values in file %s", path);
}
}
void plot_values(analyzer_t * a){
int i;
for (i = 0; i < a->size; ++i){
printf("%d %lf %Lf\n", i, a->cost[i], get_amortized_cost(a, i));
}
}
C/analyzer.h
View file @ 96b36d36
#ifndef __ANALYZER_H__
#define __ANALYZER_H__
#include <stddef.h>
/**
Structure utilisée pour faire des statistiques élémentaires
sur une séquence d'opérations.
*/
typedef struct analyzer_s{
// Coût de chaque opération. Peut représenter du temps ou une autre mesure.
double * cost;
// Coût cumulatif. La case i contient la somme des coûts des i premières opérations.
// Permet de calculer le coût amorti d'une opération.
long double * cumulative_cost;
// Carré du coût cumulatif. Sert à calculer la variance. On ne garde que la dernière valeur.
long double cumulative_square;
// Capacité de stockage des tableaux
size_t capacity;
// Nombre d'éléments dans chaque tableaux.
size_t size;
} analyzer_t;
/**
Fonction d'initialisation d'une analyse.
Complexité en temps/espace, pire et meilleur cas : O(1)
@return Un pointeur sur une structure analyzer_t nouvellement allouée.
*/
analyzer_t * analyzer_create();
/**
Fonction de libération de la mémoire occupée par une analyse.
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 analyzer_destroy(analyzer_t * a);
/**
Ajoute un coût, une valeur à l'analyse.
Complexité en temps/espace, pire cas : O(size)
Complexité en temps/espace, meilleur cas : O(1)
Complexité amortie : O(1)
@param a est l'analyse à laquelle on souhaite ajouter une valeur.
@param cost est la valeur que l'on souhaite ajouter.
*/
void analyzer_append(analyzer_t * a, double cost);
/**
Renvoie la somme des coûts enregistrés dans cette analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la somme des coûts enregistrés dans cette analyse.
*/
long double get_total_cost(analyzer_t * a);
/**
Renvoie le coût amorti d'une opération.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@param pos est l'indice de l'opération pour laquelle on veut connaître le coût amorti.
@returns le coût amorti d'une opération.
*/
long double get_amortized_cost(analyzer_t * a, size_t pos);
/**
Renvoie la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_average_cost(analyzer_t * a);
/**
Renvoie la variance des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la variance des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_variance(analyzer_t * a);
/**
Renvoie l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_standard_deviation(analyzer_t * a);
/**
Sauvegarde la liste des coûts et des coûts amortis dans un fichier.
Complexité en temps, meilleur/pire cas : O(size)
@param a est l'analyse que l'on souhaite sauvegarder.
@param path est le chemin du fichier dans lequel la sauvegarde est faite.
*/
void save_values(analyzer_t * a, char * path);
/**
Affiche la liste des coûts et des coûts amortis sur la sortie standard.
Complexité en temps, meilleur/pire cas : O(size)
@param a est l'analyse que l'on souhaite sauvegarder.
*/
void plot_values(analyzer_t * a);
#endif
#ifndef __ANALYZER_H__
#define __ANALYZER_H__
#include <stddef.h>
/**
Structure utilisée pour faire des statistiques élémentaires
sur une séquence d'opérations.
*/
typedef struct analyzer_s{
// Coût de chaque opération. Peut représenter du temps ou une autre mesure.
double * cost;
// Coût cumulatif. La case i contient la somme des coûts des i premières opérations.
// Permet de calculer le coût amorti d'une opération.
long double * cumulative_cost;
// Carré du coût cumulatif. Sert à calculer la variance. On ne garde que la dernière valeur.
long double cumulative_square;
// Capacité de stockage des tableaux
size_t capacity;
// Nombre d'éléments dans chaque tableaux.
size_t size;
} analyzer_t;
/**
Fonction d'initialisation d'une analyse.
Complexité en temps/espace, pire et meilleur cas : O(1)
@return Un pointeur sur une structure analyzer_t nouvellement allouée.
*/
analyzer_t * analyzer_create();
/**
Fonction de libération de la mémoire occupée par une analyse.
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 analyzer_destroy(analyzer_t * a);
/**
Ajoute un coût, une valeur à l'analyse.
Complexité en temps/espace, pire cas : O(size)
Complexité en temps/espace, meilleur cas : O(1)
Complexité amortie : O(1)
@param a est l'analyse à laquelle on souhaite ajouter une valeur.
@param cost est la valeur que l'on souhaite ajouter.
*/
void analyzer_append(analyzer_t * a, double cost);
/**
Renvoie la somme des coûts enregistrés dans cette analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la somme des coûts enregistrés dans cette analyse.
*/
long double get_total_cost(analyzer_t * a);
/**
Renvoie le coût amorti d'une opération.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@param pos est l'indice de l'opération pour laquelle on veut connaître le coût amorti.
@returns le coût amorti d'une opération.
*/
long double get_amortized_cost(analyzer_t * a, size_t pos);
/**
Renvoie la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la moyenne des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_average_cost(analyzer_t * a);
/**
Renvoie la variance des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns la variance des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_variance(analyzer_t * a);
/**
Renvoie l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
Complexité en temps/espace, pire cas : O(1)
@param a est une analyse.
@returns l'écart-type des coûts de toutes les opérations enregistrées dans l'analyse.
*/
long double get_standard_deviation(analyzer_t * a);
/**
Sauvegarde la liste des coûts et des coûts amortis dans un fichier.
Complexité en temps, meilleur/pire cas : O(size)
@param a est l'analyse que l'on souhaite sauvegarder.
@param path est le chemin du fichier dans lequel la sauvegarde est faite.
*/
void save_values(analyzer_t * a, char * path);
/**
Affiche la liste des coûts et des coûts amortis sur la sortie standard.
Complexité en temps, meilleur/pire cas : O(size)
@param a est l'analyse que l'on souhaite sauvegarder.
*/
void plot_values(analyzer_t * a);
#endif
C/arraylist.c
View file @ 96b36d36
#include "arraylist.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( a->size >= a->capacity){
fprintf(stderr, "Tas déja plein\n");
}
a->swap = 0;
int i=a->size+1;
a->data[i] = x;
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;
}
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);
}
size_t arraylist_swap(arraylist_t * a){
if(a!=NULL)
return a->swap;
return 0;
#include "arraylist.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( a->size >= a->capacity){
fprintf(stderr, "Tas déja plein\n");
}
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;