diff --git a/include/db.h b/include/db.h
deleted file mode 100644
index c4a0157965486762021e1b9c034fa14b4cbceff9..0000000000000000000000000000000000000000
--- a/include/db.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#pragma once
-
-#include "list.h"
-
-/* file mode : text or binary */
-typedef enum file_mode { TEXT, BINARY } file_mode_t;
-
-/**
- * @brief read a list from a text or binary file acording to the mode
- * @param mode : TEXT or BIN
- * @param data_read_fct : ptr to fct that reads datum from file fd ; fct's parameters : (fd, mode)
- * @param del_fct : ptr to fct that deallocate datum's memory, ; fct's parameter (datum)
- */
-list_t * read_list ( file_mode_t mode, void * (*read_fct) (), void (*del_fct) () );
-
-
-/**
- * @brief write a list into a text or binary file acording to the mode
- * @param mode : TEXT or BIN
- * @param data_write_fct : ptr to fct that writes datum into file fd ; fct's parameters : (datum, fd, mode)
- */
-void write_list ( list_t * L, file_mode_t mode, void (*write_fct) () );
\ No newline at end of file
diff --git a/include/job.h b/include/job.h
deleted file mode 100644
index a3bbc2b114cb92c6687a2d6d9ceccee5f6dd5374..0000000000000000000000000000000000000000
--- a/include/job.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#pragma once
-
-#include "list.h"
-#include <stdbool.h>
-
-#define UNDEF -2
-
-/** Des redondances possibles avec d'autres TAs ! */
-typedef struct {
- char * title; // Nom de la tâche
- double life; // Durée de la tâche
- int input_degree; // Son degré de dépendance
- int output_degree; // Les tâches qui en dépendent
- int rank; // Rang de la tâche
- int dyn_input_degree; // Facilité de prog
- list_t * precedence; // Les tâches précédentes
- list_t * posteriority; // Les tâches ultérieures
- double au_plus_tot; // Date au plus tôt
- double au_plus_tard; // Date au plus tard
- double marge_totale; // Marge totale
- double marge_libre; // Marge libre
- bool critique; // Une tâche critique ?
-} job_t;
-
-job_t * new_empty_job();
-job_t * new_job(char * title);
-void free_job(job_t ** ptrJ);
-void view_job ( job_t * J );
-char * get_job_title(job_t * J);
-void set_job_title(job_t * J, char * title);
-double get_job_life(job_t * J);
-void set_job_life(job_t * J, double life);
-int get_job_iDegree(job_t * J);
-void set_job_iDegree(job_t * J, int iDegree);
-void incr_job_iDegree(job_t * J);
-void decr_job_iDegree(job_t * J);
-
-int get_job_oDegree(job_t * J);
-void set_job_oDegree(job_t * J, int oDegree);
-void incr_job_oDegree(job_t * J);
-void decr_job_oDegree(job_t * J);
-int get_job_rank(job_t * J);
-void set_rank(job_t * J, int rank);
-int titleJobCmp(job_t * J1, job_t * J2);
-int iDegreeJobCmp(job_t * J1, job_t * J2);
-int oDegreeJobCmp(job_t * J1, job_t * J2);
-int rangJobCmp(job_t * J1, job_t * J2);
-
diff --git a/include/list.h b/include/list.h
deleted file mode 100644
index f843d10bb956cb20e37e5af99f31ca144aece881..0000000000000000000000000000000000000000
--- a/include/list.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include "list_elm.h"
-
-typedef struct list {
- list_elm_t * head;
- list_elm_t* tail;
- int numelm;
-} list_t;
-
-list_t * new_list();
-void del_list ( list_t * * L, void (*ptrf) () );
-bool empty_list ( list_t * L );
-
-list_elm_t * get_head ( list_t * L );
-list_elm_t * get_tail ( list_t * L );
-void view_list ( list_t * L, void (*ptrf)() );
-
-void cons ( list_t * L, void * data );
-void queue ( list_t * L, void * data );
-void ordered_insert ( list_t * L, void * data, int (*cmpFct)() );
-
-int get_numelm(list_t * L);
-
-// void take_out(struct list_t * L, void * D);
-void quick_sort(list_t * L, int (*cmpFct)());
-void find(list_t * L, void ** ptrKey, int (*cmpFct)(), void (*delFct)());
-void del_list(list_t ** ptrL, void (*ptrf) ());
-void clean(list_t * L);
-bool is_empty(list_t * L);
-
-
diff --git a/include/list_elm.h b/include/list_elm.h
deleted file mode 100644
index 621dd3228dcc74a6159166ec3c348991527dc1b6..0000000000000000000000000000000000000000
--- a/include/list_elm.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-typedef struct list_elm {
- void * data;
- struct list_elm * suc, * pred;
-} list_elm_t;
-
-list_elm_t * new_list_elm ( void * data );
-/**
- * @brief delete the list element E and optionnaly its datum
- * @param ptrf : a ptr to fct that deallocates datum's memory ;
- * if ptrf is NULL, datum is not freed
- */
-void del_list_elm( list_elm_t * * E, void (*ptrf)() );
-
-list_elm_t * get_suc ( list_elm_t * E );
-list_elm_t * get_pred ( list_elm_t * E );
-void * get_data ( list_elm_t * E );
-
-void set_suc ( list_elm_t * E, list_elm_t * S );
-void set_pred ( list_elm_t * E, list_elm_t * P );
-void set_data ( list_elm_t * E, void * data );
-
-void view_list_elm ( list_elm_t * E, void (*ptrf)() );
diff --git a/include/outils.h b/include/outils.h
deleted file mode 100644
index 79f54e3f28be988e287dc41050e54cee63b19905..0000000000000000000000000000000000000000
--- a/include/outils.h
+++ /dev/null
@@ -1,9 +0,0 @@
-#pragma once
-
-#define EPSILON 0.00000001// ε = 10^{-8}
-
-/** Integer comparaison */
-int int_cmp ( int * a, int * b );
-
-/** Double comparaison */
-int double_cmp ( double * a, double * b );
\ No newline at end of file
diff --git a/include/rank.h b/include/rank.h
deleted file mode 100644
index 9ba383b24053103aa527f09ea8211159fc5249cb..0000000000000000000000000000000000000000
--- a/include/rank.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "list.h"
-
-
-void ranking(list_t * G);
-void prune(list_t * G);
-
-void marges(list_t * G);
-
diff --git a/makefile b/makefile
deleted file mode 100644
index 8d48e778bd0e09ecba2dbe7ccc818215b82d12eb..0000000000000000000000000000000000000000
--- a/makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-BDIR = bin
-IDIR = include
-ODIR = obj
-SDIR = src
-
-CC = gcc
-# Le déboggage en toutes circonstances grâce à :: -D _DEBUG_
-# que l'on peutarêter à tout moment grâce à :: -U _DEBUG_
-CFLAGS = -Wall -I$(IDIR) -g -c
-LFLAGS = -lm
-
-PROG = $(BDIR)/mpm
-
-_DEPS = job.h list.h list_elm.h outils.h #rank.h
-DEPS = $(patsubst %,$(IDIR)/%,$(_DEPS))
-
-_OBJS = db.o io.o job.o list.o list_elm.o main.o outils.o #rank.o
-OBJS = $(patsubst %,$(ODIR)/%,$(_OBJS))
-
-.PHONY : run all dirs clean delete
-
-run : all
- ./$(PROG)
-
-all : dirs $(OBJS)
- $(CC) -o $(PROG) $(OBJS) $(LFLAGS)
-
-dirs :
- mkdir -p $(ODIR) $(BDIR)
-
-$(ODIR)/%.o : $(SDIR)/%.c $(DEPS)
- $(CC) $(CFLAGS) -o $@ $<
-
-clean :
- rm -rf $(ODIR)
-
-delete : clean
- rm -rf $(BDIR)
\ No newline at end of file
diff --git a/obj/db.o b/obj/db.o
deleted file mode 100644
index 02a8690f0be0218bc1f329379cdd0383219ac9fd..0000000000000000000000000000000000000000
Binary files a/obj/db.o and /dev/null differ
diff --git a/obj/io.o b/obj/io.o
deleted file mode 100644
index 10bee52ae486bc83610bea63e627baa252d403ca..0000000000000000000000000000000000000000
Binary files a/obj/io.o and /dev/null differ
diff --git a/readme.md b/readme.md
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/src/db.c b/src/db.c
deleted file mode 100644
index b26b108f88d3de9266f593a5df1baf651a47eb7d..0000000000000000000000000000000000000000
--- a/src/db.c
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include "db.h"
-#include "list.h"
-#include "list_elm.h"
-
-list_t * read_list( file_mode_t mode, void * (*read_fct) (), void (*del_fct) () ) {
- FILE * fd;
- char fname[20];
- list_t * L = new_list();
-
- if (mode == TEXT) {// Open file in TEXT mode
- printf( "\t\tRead list from text file (.txt)\n\tfile name :" );
- scanf( "%s", fname );
- fd = fopen( fname, "rt" );
- }
- else {// open file in BIN mode
- printf( "\t\tRead list from binary file (.bin)\n\tfile name :" );
- scanf( "%s", fname );
- fd = fopen( fname, "rb" );
- }
- //todo
- void * datum;
- while ((datum = read_fct(fd, mode)) != NULL) {
- queue(L, datum);
- }
-
-
- list_elm_t * E = get_tail(L);
- if (E != NULL && empty_list(E->data)) {
- list_elm_t * T = get_pred(E);
- if (T != NULL) {
- set_suc(T, NULL);
- L->tail = T;
- } else {
- L->head = L->tail = NULL;
- }
- del_list_elm(&E, del_fct);
- }
-
- /** TODO parcourir le fichier pour y collecter les formulaires et les ranger dans la L
- ATTENTION :
- il est **possible** que vous créiez un élément de trop (un formulaire vide) en fin de liste.
- Il faut alors penser à le supprimer grâce au code suivant :
- E = get_tail (L);
- struct elmlist * T = getPred(E);
- set_suc(T, NULL);
- L->tail = T;
- del_elmlist(E, ptr_del);
- */
-
-
- fclose(fd);
- return L;
- }
-void write_list( list_t * L, file_mode_t mode, void (*write_fct) () ) {
- FILE * fd;
- char fname[20];
- if (mode == TEXT) {
- printf( "\t\tWrite list to text file (.txt)\n\tfile name :"), scanf( "%s", fname );
- fd = fopen( fname, "wt" );
- } else {
- printf("\t\tWrite list to binary file (.bin)\n\tfile name :"), scanf( "%s", fname );
- fd = fopen(fname, "wb" );
- }
-
- for (list_elm_t * elm = get_head(L); elm != NULL; elm = elm->suc){
- write_fct(elm->data, mode, fd);
- }
- /// @todo Parcourir L et écrire les formulaires grâce à data_write_fct
- fclose(fd);
-}
-
diff --git a/src/io.c b/src/io.c
deleted file mode 100644
index aafeda62a9a41ca88b3ba9f9d4967632e3076d27..0000000000000000000000000000000000000000
--- a/src/io.c
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "list.h"
-#include "list_elm.h"
-#include "job.h"
-#include "list.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <assert.h>
-
-list_t * read_graph ( char * filename ) {
- FILE * fd = fopen ( filename, "rt" );
- list_t * G = new_list ( );
- assert ( fd && G );
- char job_name [ BUFSIZ ];
-
- while ( !feof ( fd ) ) {
-
- fscanf ( fd, " %s", job_name);
- if ( !strcmp (job_name, "NIL" ) ) continue;
-
- job_t * J = new_job ( job_name );
-
- /** @note
- À l'appel J pointe sur le job que l'on vient de créer.
-
- FIND retrouve le job J dans la liste G des jobs grâce à la fonction titleJobCmp.
- Si ce job n'est pas dans la liste G alors
- le job pointé par J est enregistré dans G
- Si ce job est déjà dans G alors
- le job pointé par J est supprimé grâce à free_job
- puis le pointeur de J est réassigné sur le job trouvé dans G
- */
- find ( G, ( void ** ) &J, &titleJobCmp, &free_job );
-
- fscanf ( fd, "%lf", &(J->life) );
-
- /** @note
- Enregistrement des préséances
- */
- job_t * predJ;
- fscanf( fd, " %s", job_name );
- while ( strcmp ( job_name, "NIL" ) ) {
- predJ = new_job ( job_name );
- //SOUVIENS SI &TITTLEJOBCMP = &SETJOBTITLE
- find ( G, (void **) &predJ, &titleJobCmp, &free_job );
-
- ordered_insert ( predJ->posteriority, J, &titleJobCmp );
- incr_job_oDegree ( predJ );
-
- ordered_insert ( J->precedence, predJ, &titleJobCmp );
- incr_job_iDegree ( J );
-
- fscanf ( fd, " %s", job_name );
- }
-
- /** @note valeurs par défaut des autres champs */
- J->dyn_input_degree = J->input_degree;
- J->rank = UNDEF;
- J->au_plus_tard = UNDEF;
- J->au_plus_tot = UNDEF;
- J->marge_totale = UNDEF;
- J->critique = false;
- }
-
- view_list(G,&view_job);
- return G;
-}
-
-static void partition(list_t * L, elmlist_t * pivot, list_t * val_inf, list_t * val_sup, int (*cmpFct)(void*, void*)) {
- for (elmlist_t * cur = L->head; cur != NULL; cur = cur->suc) {
- if (cmpFct(get_data(cur), get_data(pivot)) < 0)
- queue(val_inf, get_data(cur));
- else
- queue(val_sup, get_data(cur));
- }
-}
-
-void quick_sort(list_t * L, int (*cmpFct)(void*, void*)) {
- assert(L && cmpFct);
-
- if (L->numelm > 1) {
- //CONFIRMER LE STRUCT
- struct list_elm_t * pivot = get_head(L);
- L->head = get_suc(pivot);
- pivot->pred = NULL;
- pivot->suc = NULL;
-
-
- /** @note
- * La listes des données inférieures à pivot
- * La listes des données supérieures à pivot
- */
- list_t * val_inf_pivot = new_list();
- list_t * val_sup_pivot = new_list();
-
- /** @note Déplacement des données de L dans val_inf_pivot et val_sup_pivot */
- partition(L,pivot,val_inf_pivot,val_sup_pivot,cmpFct);
-
- /** @note On supprimer les éléments de L sans supprimer ni L ni les jobs */
- // elmlist_t * S;
- // for(elmlist_t * E = L->head; E; E = S){
- // S = E->suc;
- // free(E);
- // }
-
- /** @note
- * Si la partie inf est vide alors L commence par le pivot
- * Sinon on tri grâce à cmpFct la partie inf puis on ajoute en queue le pivot
- */
-
-
- if (is_empty(val_inf_pivot)) {
- L->head = pivot;
- L->tail = pivot;
- L->numelm = 1;
- } else {
- quick_sort(val_inf_pivot, cmpFct);
- L->head = val_inf_pivot->head;
- L->tail = val_inf_pivot->tail;
- L->numelm = val_inf_pivot->numelm;
- pivot->pred = L->tail;
- L->tail->suc = pivot;
- L->tail = pivot;
- L->numelm += 1;
- }
- /** @note
- * Si la partie sup n'est pas vide alors
- * On la trie puis on la concatène à la partie inf
- */
- if (!is_empty(val_sup_pivot)) {
- quick_sort(val_sup_pivot, cmpFct);
- val_sup_pivot->head->pred = pivot;
- set_suc(pivot, val_sup_pivot->head);
- L->tail = val_sup_pivot->tail;
- L->numelm += val_sup_pivot->numelm;
- }
- free(val_inf_pivot);
- free(val_sup_pivot);
- }
-}
\ No newline at end of file
diff --git a/src/job.c b/src/job.c
deleted file mode 100644
index dc5002cc6077faf394d4d51de9d51c15c954ea54..0000000000000000000000000000000000000000
--- a/src/job.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-#include "job.h"
-#include "list.h"
-
-job_t * new_empty_job ( ) {
- job_t * J = calloc ( 1, sizeof (job_t ) );
- assert( J );
- J->precedence = new_list ( );
- J->posteriority = new_list ( );
- J->rank = UNDEF;
- J->au_plus_tard = UNDEF;
- J->au_plus_tot = UNDEF;
- J->marge_totale = UNDEF;
- J->critique = false;
- return J;
-}
-job_t * new_job ( char * title ) {
- job_t * J = new_empty_job ( );
- J->title = strdup ( title );
- return J;
-}
-void free_job(job_t ** ptrJ ) {
- assert ( ptrJ && *ptrJ );
- if( (*ptrJ)->title ) free ( (*ptrJ)->title );
- free ( *ptrJ );
- *ptrJ = NULL;
-}
-
-void view_job ( job_t * J ) {
- printf ( "JOB %s\n\tpreceeded by [", get_job_tilte ( J ) );
- for(elmlist_t * E = get_head ( J->precedence ); E; E = get_suc ( E ) ) {
- printf ( " %s", get_job_tilte ( get_data ( E ) ) );
- }
- printf ( " ]\n" );
- // if ( !get_numelm ( J->posteriority ) ) printf ( "\t" );
- printf ( "\tfollowed by [" );
- for(elmlist_t * E = get_head(J->posteriority); E; E = get_suc(E)){
- printf(" %s", get_job_tilte(get_data(E)));
- }
- printf ( " ]\n" );
- printf ( "\tiDeg=%d\toDeg=%d\tlife=%2.2lf", J->input_degree, J->output_degree, J->life );
- printf ( "\trank=" );
- if ( J->rank == UNDEF ) printf ( "U" ); else printf ( "%d", J->rank );
- printf ( "\tearly=" );
- if(J->au_plus_tot == UNDEF ) printf("U"); else printf ( "%2.2lf",J->au_plus_tot );
- printf ( "\tlate=" );
- if(J->au_plus_tard == UNDEF ) printf("U"); else printf ( "%2.2lf",J->au_plus_tard );
- printf ( "\ttotale= " );
- if ( J->marge_totale == UNDEF ) printf("U"); else printf ( "%2.2lf", J->marge_totale );
- printf ( "\tcritical= " );
- if ( J->critique ) printf("Y\n"); else printf ( "N\n" );
-}
diff --git a/src/job_2.c b/src/job_2.c
deleted file mode 100644
index 76c8897c629fe8bdff813c648b4eab6e91f69d3c..0000000000000000000000000000000000000000
--- a/src/job_2.c
+++ /dev/null
@@ -1,111 +0,0 @@
-#include "job.h"
-#include "list.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-
-job_t * new_empty_job(){
- job_t * J = calloc ( 1, sizeof (job_t ) );
- assert( J );
- J->precedence = new_list ( );
- J->posteriority = new_list ( );
- J->rank = UNDEF;
- J->au_plus_tard = UNDEF;
- J->au_plus_tot = UNDEF;
- J->marge_totale = UNDEF;
- J->critique = false;
- return J;
-}
-
-job_t * new_job(char * title){
- job_t * J = new_empty_job ( );
- J->title = strdup ( title );
- return J;
-}
-
-void free_job(job_t ** ptrJ){
- assert ( ptrJ && *ptrJ );
- if( (*ptrJ)->title ) free ( (*ptrJ)->title );
- free ( *ptrJ );
- *ptrJ = NULL;
-}
-
-void view_job ( job_t * J ) {
- printf ( "JOB %s\n\tpreceeded by [", get_job_tilte ( J ) );
- for(elmlist_t * E = get_head ( J->precedence ); E; E = get_suc ( E ) ) {
- printf ( " %s", get_job_tilte ( get_data ( E ) ) );
- }
- printf ( " ]\n" );
- // if ( !get_numelm ( J->posteriority ) ) printf ( "\t" );
- printf ( "\tfollowed by [" );
- for(elmlist_t * E = get_head(J->posteriority); E; E = get_suc(E)){
- printf(" %s", get_job_tilte(get_data(E)));
- }
- printf ( " ]\n" );
- printf ( "\tiDeg=%d\toDeg=%d\tlife=%2.2lf", J->input_degree, J->output_degree, J->life );
- printf ( "\trank=" );
- if ( J->rank == UNDEF ) printf ( "U" ); else printf ( "%d", J->rank );
- printf ( "\tearly=" );
- if(J->au_plus_tot == UNDEF ) printf("U"); else printf ( "%2.2lf",J->au_plus_tot );
- printf ( "\tlate=" );
- if(J->au_plus_tard == UNDEF ) printf("U"); else printf ( "%2.2lf",J->au_plus_tard );
- printf ( "\ttotale= " );
- if ( J->marge_totale == UNDEF ) printf("U"); else printf ( "%2.2lf", J->marge_totale );
- printf ( "\tcritical= " );
- if ( J->critique ) printf("Y\n"); else printf ( "N\n" );
-}
-
-char * get_job_title(job_t * J) {
- assert(J);
- return J->title;
-}
-
-void titleJobCmp(job_t * J, char * title){
-
-
-
-}
-
-void set_job_title(job_t * J, char * title) {
- assert(J && title);
- if(J->title)
- free(J->title);
- J->title = strdup(title);
-}
-
-
-double get_job_life(job_t * J) {
- assert(J);
- return J->life;
-}
-
-
-void set_job_life(job_t * J, double life) {
- assert(J);
- J->life = life;
-}
-
-
-int get_job_iDegree(job_t * J) {
- assert(J);
- return J->input_degree;
-}
-
-
-void set_job_iDegree(job_t * J, int iDegree) {
- assert(J);
- J->input_degree = iDegree;
-}
-
-
-void incr_job_iDegree(job_t * J) {
- assert(J);
- J->input_degree++;
-}
-
-
-void decr_job_iDegree(job_t * J) {
- assert(J);
- J->input_degree--;
-}
\ No newline at end of file
diff --git a/src/job_3.c b/src/job_3.c
deleted file mode 100644
index 6ac6944036af9438a4d02686609d6536ca115c44..0000000000000000000000000000000000000000
--- a/src/job_3.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "job.h"
-#include <assert.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-//TOUS EST CHANGee
-int get_job_oDegree(job_t * J) {
- assert(J);
- return J->output_degree;
-}
-
-void set_job_oDegree(job_t * J, int oDegree) {
- assert(J);
- J->output_degree = oDegree;
-}
-
-void incr_job_oDegree(job_t * J) {
- assert(J);
- J->output_degree++;
-}
-
-void decr_job_oDegree(job_t * J) {
- assert(J);
- J->output_degree--;
-}
-
-int get_job_rank(job_t * J) {
- assert(J);
- return J->rank;
-}
-
-void set_rank(job_t * J, int rank) {
- assert(J);
- J->rank = rank;
-}
-
-int titleJobCmp(job_t * J1, job_t * J2) {
- assert(J1 && J2);
- return strcmp(J1->title, J2->title);
-}
-
-int iDegreeJobCmp(job_t * J1, job_t * J2) {
- assert(J1 && J2);
- return J1->input_degree - J2->input_degree;
-}
-
-int oDegreeJobCmp(job_t * J1, job_t * J2) {
- assert(J1 && J2);
- return J1->output_degree - J2->output_degree;
-}
-
-int rangJobCmp(job_t * J1, job_t * J2) {
- assert(J1 && J2);
- return J1->rank - J2->rank;
-}
diff --git a/src/list.c b/src/list.c
deleted file mode 100644
index 7032f0b3d1614b7d525cfd25a625e16e40eeca66..0000000000000000000000000000000000000000
--- a/src/list.c
+++ /dev/null
@@ -1,103 +0,0 @@
-#include <stdlib.h>
-#include <assert.h>
-#include "list.h"
-#include "list_elm.h"
-
-list_t * new_list() {
- list_t * L = calloc(1, sizeof(list_t));
- assert(L);
- L->head = NULL;
- L->tail = NULL;
- L->numelm = 0;
- return L;
-}
-
-void del_list(list_t ** L, void (*ptr_del)(void *)) {
- assert(L && *L);
- list_t * list = *L;
- list_elm_t * E = list->head;
- while (E) {
- list_elm_t * temp = E;
- E = E->suc;
- if(ptr_del) {
- ptr_del(temp->data);
- }
- free(temp);
- }
- free(*L);
- *L = NULL;
-}
-
-bool empty_list(list_t * L) {
- assert(L);
- return L->numelm == 0;
-}
-
-list_elm_t * get_head(list_t * L) {
- assert(L);
- return L->head;
-}
-
-list_elm_t * get_tail(list_t * L) {
- assert(L);
- return L->tail;
-}
-
-void view_list(list_t * L, void (*ptr_view)(void *)) {
- assert(L && ptr_view);
- for (list_elm_t * E = L->head; E != NULL; E = get_suc(E)) {
- ptr_view(E->data);
- }
-}
-
-void cons(list_t * L, void * data) {
- list_elm_t * E = new_list_elm(data);
- E->suc = L->head;
- if (L->head != NULL) {
- L->head->pred = E;
- }
- L->head = E;
- if (L->tail == NULL) {
- L->tail = E;
- }
- L->numelm++;
-}
-
-void queue(list_t * L, void * data) {
- list_elm_t * E = new_list_elm(data);
- if(empty_list(L)) {
- L->head = E;
- L->tail = E;
- } else {
- L->tail->suc = E;
- E->pred = L->tail;
- L->tail = E;
- }
- L->numelm++;
-}
-
-void insert_after(list_t * L, void * data, list_elm_t * elm) {
- if(elm == NULL) return;
- list_elm_t * E = new_list_elm(data);
- E->suc = elm->suc;
- E->pred = elm;
- if(elm->suc != NULL) {
- elm->suc->pred = E;
- } else {
- L->tail = E;
- }
- elm->suc = E;
- L->numelm++;
-}
-
-void ordered_insert(list_t * L, void * data, int (*cmpFct)(void*, void*)) {
- if(empty_list(L) || cmpFct(L->head->data, data) > 0) {
- cons(L, data);
- } else {
- list_elm_t * current = L->head;
- while(get_suc(current) != NULL && cmpFct(get_suc(current)->data, data) <= 0) {
- current = get_suc(current);
- }
- insert_after(L, data, current);
- }
-}
diff --git a/src/list_1 (1).c b/src/list_1 (1).c
deleted file mode 100644
index ef9df30293f795e48da03e19b70ddab29d65bed9..0000000000000000000000000000000000000000
--- a/src/list_1 (1).c
+++ /dev/null
@@ -1,74 +0,0 @@
-#include "list_1 (1).h"
-#include "list"
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <assert.h>
-
-typedef struct{
- elmlist_t * head;
- elmlist_t * tail;
- int numelm;
- } list_t ;
- // Create an empty list
- list_t * new_list(){
- list_t * t = calloc(1, sizeof(list_t));
- assert(t);
- return t;
- }
- // Delete list, its elements and possibly the data
- //DOIT CONFIRMER LE STRUCT
- void del_list(list_t ** ptrL, void (*ptrf) ()){
- assert(ptrL && *ptrL);
- list_t * L = *ptrL;
- if(ptrf){
- for(elmlist_t * E = L->head; E; ){
- elmlist_t * T = E;
- E = E->suc;
- (*ptrf)(T->data);
- free(T);
- }
- }
- } else {
- for(elmlist_t * E = L->head; E ; ){
- elmlist_t * T = E;
- E = E->suc;
- free(T);
- }
- free(*ptrL);
- (*ptrL) = NULL;
-}
- // Clean list; delete its elments but keep data and the list
- void clean(list_t * L){
- assert(L);
- elmlist_t *curr = L->head;
- while (curr != NULL) {
- elmlist_t *temp = curr;
- curr = curr->suc;
- free(temp);
- }
- L->head = NULL;
- L->tail = NULL;
- L->numelm = 0;
-}
- // Is list L empty ?
- bool is_empty(list_t * L){
- assert(L);
- if (L->numelm == 0) return true;
- return false;
- }
-
- elmlist_t * get_head(list_t * L){
- assert(L);
- L = L->head;
- return L;
- }
-
- elmlist_t * get_tail(list_t * L){
- assert(L);
- L = L->tail;
- return L;
- }
-
-
-
\ No newline at end of file
diff --git a/src/list_2.c b/src/list_2.c
deleted file mode 100644
index ed867d3c8d7217ea6321afb1404c48dbfb069be8..0000000000000000000000000000000000000000
--- a/src/list_2.c
+++ /dev/null
@@ -1,226 +0,0 @@
-#include "list_1 (1).h"
-#include "list.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <assert.h>
-
-// Gimme the number of elements of L
-int get_numelm(struct list_t * L){
- assert(L);
- return L->numelm;
-}
-// Take out the data D of the list L if it is present
-void take_out(struct list_t * L, void * D){
- assert(L);
- elmlist_t * current = L->head;
- while (current != NULL) {
- if (get_data(current) == D) {
- elmlist_t * p = get_pred(current);
- elmlist_t * s = get_suc(current);
- // Update predecessor’s successor
- if (p) set_suc(p, s);
- else L->head = s; // current was head
- // Update successor’s predecessor
- if (s) set_pred(s, p);
- else L->tail = p; // current was tail
- free(current);
- L->numelm--;
- return;
- }
- current = get_suc(current);
- }
-}
-
-// Add a element holding data to the head of L
-void cons(struct list_t * L, void * data){
- elmlist_t * E = calloc(1, sizeof(elmlist_t));
- assert(L && E);
- set_data(E, data);
- set_suc(E, L->head);
- set_head(L, E);
- if(is_empty(L)) L->tail = E;
- L->numelm += 1;
- }
-
-
-
-
-// Add a element holding data to the tail of L
-void queue(struct list_t * L, void * data){
- assert(L);
- elmlist_t * E = calloc(1, sizeof(elmlist_t));
- assert(E);
- set_data(E, data);
- E->suc = NULL;
- if (is_empty(L)) {
- E->pred = NULL;
- L->head = E;
- L->tail = E;
- } else {
- E->pred = L->tail;
- L->tail->suc = E;
- L->tail = E;
- }
- L->numelm++;
- }
-// Insert in L a element holding data wrt order given by cmp_ptrf
-void ordered_insert(struct list_t * L, void * data, int (*cmp_ptrf)()){
- assert(L && cmp_ptrf);
- elmlist_t * E = calloc(1, sizeof(elmlist_t));
- assert(E);
- set_data(E, data);
- // if list is empty, simply add the element
- if (is_empty(L)) {
- E->pred = E->suc = NULL;
- L->head = L->tail = E;
- L->numelm++;
- return;
- }
-}
-
-// Elements qui sont moins = val_inf et le reste val_sup.
-static void partition(list_t * L, elmlist_t * pivot, list_t * val_inf, list_t * val_sup, int (*cmpFct)(void*, void*)) {
- for (elmlist_t * cur = L->head; cur != NULL; cur = cur->suc) {
- if (cmpFct(get_data(cur), get_data(pivot)) < 0)
- queue(val_inf, get_data(cur));
- else
- queue(val_sup, get_data(cur));
- }
-}
-
-void quick_sort(list_t * L, int (*cmpFct)(void*, void*)) {
- assert(L && cmpFct);
-
- if (L->numelm > 1) {
-
- elmlist_t * pivot = get_head(L);
- L->head = get_suc(pivot);
- pivot->pred = NULL;
- pivot->suc = NULL;
-
-
- /** @note
- * La listes des données inférieures à pivot
- * La listes des données supérieures à pivot
- */
- list_t * val_inf_pivot = new_list();
- list_t * val_sup_pivot = new_list();
-
- /** @note Déplacement des données de L dans val_inf_pivot et val_sup_pivot */
- partition(L,pivot,val_inf_pivot,val_sup_pivot,cmpFct);
-
- /** @note On supprimer les éléments de L sans supprimer ni L ni les jobs */
- // elmlist_t * S;
- // for(elmlist_t * E = L->head; E; E = S){
- // S = E->suc;
- // free(E);
- // }
-
- /** @note
- * Si la partie inf est vide alors L commence par le pivot
- * Sinon on tri grâce à cmpFct la partie inf puis on ajoute en queue le pivot
- */
-
-
- if (is_empty(val_inf_pivot)) {
- L->head = pivot;
- L->tail = pivot;
- L->numelm = 1;
- } else {
- quick_sort(val_inf_pivot, cmpFct);
- L->head = val_inf_pivot->head;
- L->tail = val_inf_pivot->tail;
- L->numelm = val_inf_pivot->numelm;
- pivot->pred = L->tail;
- L->tail->suc = pivot;
- L->tail = pivot;
- L->numelm += 1;
- }
- /** @note
- * Si la partie sup n'est pas vide alors
- * On la trie puis on la concatène à la partie inf
- */
- if (!is_empty(val_sup_pivot)) {
- quick_sort(val_sup_pivot, cmpFct);
- val_sup_pivot->head->pred = pivot;
- pivot->suc = val_sup_pivot->head;
- L->tail = val_sup_pivot->tail;
- L->numelm += val_sup_pivot->numelm;
- }
- free(val_inf_pivot);
- free(val_sup_pivot);
- }
-}
-
-// void quick_sort(list_t * L, int (*cmpFct)()){
-
-// if (L == NULL || L->numelm < 2)
-// return;
-
-
-// elmlist_t * pivotNode = L->head;
-// void * pivotData = pivotNode->data;
-
-
-// list_t * less = new_list();
-// list_t * greater = new_list();
-
-
-// for (elmlist_t * cur = L->head; cur != NULL; cur = cur->suc) {
-
-// if (cur == pivotNode)
-// continue;
-
-// if (cmpFct(cur->data, pivotData) < 0)
-// queue(less, cur->data);
-// else
-// queue(greater, cur->data);
-// }
-
-
-// clean(L);
-
-
-// quick_sort(less, cmpFct);
-// quick_sort(greater, cmpFct);
-
-// for (elmlist_t * node = less->head; node != NULL; node = node->suc)
-// queue(L, node->data);
-
-
-// queue(L, pivotData);
-
-// for (elmlist_t * node = greater->head; node != NULL; node = node->suc)
-// queue(L, node->data);
-
-// free(less);
-// free(greater);
-// }
-
-
-
-
-
-void view_list(list_t * L, void (*ptrf)()) {
- assert(L && ptrf);
- elmlist_t * curr = L->head;
- while (curr) {
- ptrf(get_data(curr));
- curr = curr->suc;
- }
-
-}
-// Return un ptr vers element else NULL
-void find(list_t * L, void ** ptrKey, int (*cmpFct)(), void (*delFct)()) {
- assert(L && ptrKey && cmpFct);
- elmlist_t * curr = L->head;
- while (curr) {
- if (cmpFct(get_data(curr), *ptrKey) == 0) {
- if (delFct)
- delFct(ptrKey);
- *ptrKey = get_data(curr);
- return;
- }
- curr = curr->suc;
- }
-}
diff --git a/src/list_elm.c b/src/list_elm.c
deleted file mode 100644
index aa173dfff979ad64483a740e38fcb96bc7977d6b..0000000000000000000000000000000000000000
--- a/src/list_elm.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <stdlib.h>
-#include <assert.h>
-#include "list_elm.h"
-
-list_elm_t * new_list_elm ( void * data ){
- list_elm_t * E = calloc(1,sizeof(list_elm_t));
- assert(E);
- E->data = data;
- return E;
-}
-
-void del_list_elm( list_elm_t * * E, void (*ptrf)() ){
- assert(E && *E);
- if (ptrf) {
- ptrf((*E)->data);
- }
- free(*E);
- *E = NULL;
-}
-
-list_elm_t * get_suc ( list_elm_t * E ){
- assert(E);
- return E->suc;
-}
-list_elm_t * get_pred ( list_elm_t * E );
-void * get_data ( list_elm_t * E ){
- assert(E);
- return E->data;
-}
-
-void set_suc ( list_elm_t * E, list_elm_t * S ){
- assert(E);
- E->suc = S;
-}
-
-void set_pred ( list_elm_t * E, list_elm_t * P ){
- assert(E);
- E->pred = P;
-}
-
-void set_data ( list_elm_t * E, void * data ){
- assert(E);
- E->data = data;
-}
-
-void view_list_elm ( list_elm_t * E, void (*ptrf)() ){
- assert(E && ptrf);
- for(elmlist_t * courant = E->head; courant; courant = get_suc(E)){
- void * data = E->data;
- (*ptrf)(data);
- }
-}
\ No newline at end of file
diff --git a/src/main (1).c b/src/main (1).c
deleted file mode 100644
index 5bb714ba220f0f322ccdfd5505a945425a638a11..0000000000000000000000000000000000000000
--- a/src/main (1).c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "job.h"
-#include "list.h"
-#include "list_elm.h"
-
-
-int main(int argc, char ** argv){
- if(argc < 2) exit(-1);
-
- list_t * G = read_graph(argv[1]);
- printf("Liste des tâches lue\n");
- view_list(G, &view_job);
-
- printf("Liste des tâches triée par degré d'entrée croissant\n");
- quick_sort(G, &iDegreeJobCmp);
- view_list(G,&view_job);
-
- printf("Liste des tâches triée par rang croissant\n");
- ranking(G);
- view_list(G,&view_job);
-
- printf("Prune edges\n");
- prune(G);
- view_list(G,&view_job);
-
- printf("\nMarges totales des tâches\n");
- marges(G);
- view_list(G,&view_job);
- return 0;
-}
diff --git a/src/outils.c b/src/outils.c
deleted file mode 100644
index 99f432bab42df93f3d155dcc5895506e8cd65ec4..0000000000000000000000000000000000000000
--- a/src/outils.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "outils.h"
-
-
-
-/** Integer comparaison */
-int int_cmp(int * a, int * b){
- return *a - *b;
-}
-
-/** Double comparaison */
-int double_cmp(double * a, double * b){
- return ((*a - *b) < -EPSILON) ? -1 : ((*a -*b) > +EPSILON) ? +1 : 0;
-}
diff --git a/src/rank.c b/src/rank.c
deleted file mode 100644
index 1d1438c50d0035f3b9bfc0ed377f7f0d82cbb2ac..0000000000000000000000000000000000000000
--- a/src/rank.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "rank.h"
-#include "list_1 (1).h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-
-
-void ranking(list_t * G){
-
-}
-void prune(list_t * G){
-assert(G);
-
-}
-
-void marges(list_t * G){
-assert(G);
-
-}
\ No newline at end of file