From ed6dc05d70d0a4c93dd792e7c919d9299292194b Mon Sep 17 00:00:00 2001
From: Syauqi_AlifIhsan <syauqi.alif-ihsan9@etu.univ-lorraine.fr>
Date: Tue, 8 Apr 2025 00:10:19 +0200
Subject: [PATCH] =?UTF-8?q?fichier=20rang=C3=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
include/db.h | 22 +++++
include/job.h | 48 ++++++++++
include/list.h | 33 +++++++
include/list_elm.h | 24 +++++
include/outils.h | 9 ++
include/rank.h | 10 ++
makefile | 38 ++++++++
obj/db.o | Bin 0 -> 10856 bytes
obj/io.o | Bin 0 -> 13864 bytes
readme.md | 0
src/db.c | 74 +++++++++++++++
src/io.c | 141 ++++++++++++++++++++++++++++
src/job.c | 55 +++++++++++
src/job_2.c | 111 ++++++++++++++++++++++
src/job_3.c | 55 +++++++++++
src/list.c | 103 +++++++++++++++++++++
src/list_1 (1).c | 74 +++++++++++++++
src/list_2.c | 226 +++++++++++++++++++++++++++++++++++++++++++++
src/list_elm.c | 52 +++++++++++
src/main (1).c | 32 +++++++
src/outils.c | 13 +++
src/rank.c | 19 ++++
22 files changed, 1139 insertions(+)
create mode 100644 include/db.h
create mode 100644 include/job.h
create mode 100644 include/list.h
create mode 100644 include/list_elm.h
create mode 100644 include/outils.h
create mode 100644 include/rank.h
create mode 100644 makefile
create mode 100644 obj/db.o
create mode 100644 obj/io.o
create mode 100644 readme.md
create mode 100644 src/db.c
create mode 100644 src/io.c
create mode 100644 src/job.c
create mode 100644 src/job_2.c
create mode 100644 src/job_3.c
create mode 100644 src/list.c
create mode 100644 src/list_1 (1).c
create mode 100644 src/list_2.c
create mode 100644 src/list_elm.c
create mode 100644 src/main (1).c
create mode 100644 src/outils.c
create mode 100644 src/rank.c
diff --git a/include/db.h b/include/db.h
new file mode 100644
index 0000000..c4a0157
--- /dev/null
+++ b/include/db.h
@@ -0,0 +1,22 @@
+#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
new file mode 100644
index 0000000..a3bbc2b
--- /dev/null
+++ b/include/job.h
@@ -0,0 +1,48 @@
+#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
new file mode 100644
index 0000000..f843d10
--- /dev/null
+++ b/include/list.h
@@ -0,0 +1,33 @@
+#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
new file mode 100644
index 0000000..621dd32
--- /dev/null
+++ b/include/list_elm.h
@@ -0,0 +1,24 @@
+#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
new file mode 100644
index 0000000..79f54e3
--- /dev/null
+++ b/include/outils.h
@@ -0,0 +1,9 @@
+#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
new file mode 100644
index 0000000..9ba383b
--- /dev/null
+++ b/include/rank.h
@@ -0,0 +1,10 @@
+#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
new file mode 100644
index 0000000..8d48e77
--- /dev/null
+++ b/makefile
@@ -0,0 +1,38 @@
+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
new file mode 100644
index 0000000000000000000000000000000000000000..02a8690f0be0218bc1f329379cdd0383219ac9fd
GIT binary patch
literal 10856
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
Wj{&@x1DpN}Q1@R(Rtya*WFY`*tHvDw
literal 0
HcmV?d00001
diff --git a/obj/io.o b/obj/io.o
new file mode 100644
index 0000000000000000000000000000000000000000..10bee52ae486bc83610bea63e627baa252d403ca
GIT binary patch
literal 13864
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
E05cv}JOBUy
literal 0
HcmV?d00001
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000..e69de29
diff --git a/src/db.c b/src/db.c
new file mode 100644
index 0000000..b26b108
--- /dev/null
+++ b/src/db.c
@@ -0,0 +1,74 @@
+#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
new file mode 100644
index 0000000..aafeda6
--- /dev/null
+++ b/src/io.c
@@ -0,0 +1,141 @@
+#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
new file mode 100644
index 0000000..dc5002c
--- /dev/null
+++ b/src/job.c
@@ -0,0 +1,55 @@
+#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
new file mode 100644
index 0000000..76c8897
--- /dev/null
+++ b/src/job_2.c
@@ -0,0 +1,111 @@
+#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
new file mode 100644
index 0000000..6ac6944
--- /dev/null
+++ b/src/job_3.c
@@ -0,0 +1,55 @@
+#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
new file mode 100644
index 0000000..7032f0b
--- /dev/null
+++ b/src/list.c
@@ -0,0 +1,103 @@
+#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
new file mode 100644
index 0000000..ef9df30
--- /dev/null
+++ b/src/list_1 (1).c
@@ -0,0 +1,74 @@
+#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
new file mode 100644
index 0000000..ed867d3
--- /dev/null
+++ b/src/list_2.c
@@ -0,0 +1,226 @@
+#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
new file mode 100644
index 0000000..aa173df
--- /dev/null
+++ b/src/list_elm.c
@@ -0,0 +1,52 @@
+#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
new file mode 100644
index 0000000..5bb714b
--- /dev/null
+++ b/src/main (1).c
@@ -0,0 +1,32 @@
+#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
new file mode 100644
index 0000000..99f432b
--- /dev/null
+++ b/src/outils.c
@@ -0,0 +1,13 @@
+#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
new file mode 100644
index 0000000..1d1438c
--- /dev/null
+++ b/src/rank.c
@@ -0,0 +1,19 @@
+#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
--
GitLab