gem-graph/gem-graph-client
gem-graph
/
gem-graph-client
3
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Activity

cleaning pile & list

This commit is contained in:
Jean Sirmai 2024-08-26 07:26:53 +02:00
parent e5d1c124e6
commit eb3bb2dc24
Signed by: jean
GPG Key ID: FB3115C340E057E3
5 changed files with 108 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
include/util.h
View File

@ -45,25 +45,29 @@ char *util_read_file (char *filename);
// Sinon vous encourez selon la loi jusqu'à trois ans de prison
// et jusqu'à 300 000 € de dommages et intérêts.
// Le piratage est illégal,
// de même que sont interdits: cracks, warez, sérials (sauf évaluation), etc.
// Est bien sûr autorisé tout ce qui concerne les logiciels gratuits, freewares et évaluation.
typedef struct pile {int valeur; struct pile *prec;} pile; // structure d'un élément
void util_pile_push (pile **, int); // empile une valeur sur la pile
int util_pile_pop (pile **); // pop retire la dernière valeur empilée
int util_pile_push (pile **, int); // empile une valeur sur la pile
int util_pile_pop (pile **); // retire la dernière valeur empilée
void util_pile_clear (pile **); // vide la pile
int util_pile_length (pile *p); // retourne le nombre d'éléments de la pile
void util_pile_view (pile *); // affiche la pile en commençant par le sommet
//------------------------------------------------------------------------------
typedef struct elem {int value; struct elem *prev; struct elem *next;} elem ;
typedef struct elem {int value; struct elem *prev; struct elem *next;} elem;
typedef struct {elem *first; elem *last;} dblist; // structure d'accès à la liste
void list_2x2_init (dblist *l); // initialisation
void list_2x2_push_back (dblist *l, int val); // ajout d'une valeur en fin de liste
void list_2x2_push_front (dblist *l, int val); // ajout d'une valeur en début de liste
int list_2x2_pop_back (dblist *l); // retrait d'une valeur en fin de liste
int list_2x2_pop_front (dblist *l); // retrait d'une valeur en début de liste
void list_2x2_view (dblist l); // affichage de toute la liste
void list_2x2_clear (dblist *l); // vidage de toute la liste
void util_list_2x2_init (dblist *l); // initialisation
int util_list_2x2_push_back (dblist *l, int val); // ajoute une valeur en fin de liste
int util_list_2x2_push_front (dblist *l, int val); // ajoute une valeur en début de liste
int util_list_2x2_pop_back (dblist *l); // retire une valeur en fin de liste
int util_list_2x2_pop_front (dblist *l); // retire une valeur en début de liste
int util_list_2x2_length (dblist l); // retourne le nombre d'éléments de la liste
void util_list_2x2_view (dblist l); // affiche les valeurs de toute la liste
void util_list_2x2_clear (dblist *l); // vide toute la liste
//------------------------------------------------------------------------------

25
src/fsm/measure.c
View File

@ -35,14 +35,14 @@
/******************************************************************************/
/* */
/* FFFFFFFFFFFF SSSS MM MM */
/* FF SS SS MMMM MMMM */
/* FFFFFFFFFFFF SSSSS MM MM */
/* FF SSS SS MMMM MMMM */
/* FF SS MM MM MM MM */
/* FFFFFFF SS MM MM MM MM */
/* FF SS MM MM MM */
/* FF SS MM MM */
/* FF SS SS MM MM */
/* FF SSSSS MM MM */
/* FF SSS MM MM */
/* FF SS SSS MM MM */
/* FF SSSSSS MM MM */
/* */
/******************************************************************************/
@ -74,17 +74,18 @@
// When a list of measurements is established, it is possible to evaluate
// if the results of a measurement are correlated with some other results.
// https://fr.wikibooks.org/wiki/Structures_de_donn%C3%A9es_en_C/Les_listes_simples
//------------------------------------------------------------------------------
// structure de données : chaque "item" comportera :
// - identifiant (clé) (+/- pointeur vers : date de création, auteur,...)
// - type de mesure
// (les 6 items suivants documentent l'ensemble de toutes les valeurs
// à recueillir pour de tous les types de mesure possibles;
// tous ne peuvent être simultanément utilisés
// mais ils occupent peu de place dans le tableau)
// les 6 items suivants peuvent documenter l'ensemble de toutes les valeurs
// à recueillir pour documenter tous les types de mesure possibles;
// tous ces items ne doivent pas être simultanément complétés
// mais, si un tableau etait utilisé, il y aurait peu de place perdue;
// - pointeur vers le premier groupe de règles (une au moins)
// - pointeur vers un second groupe de règles (une au moins)
// - pointeur vers des objets ou situations (un au moins)
@ -102,8 +103,6 @@ void fsm_add_measure (char *measure_name) {fsm_debug_msg (2, 0, measure_name, 2)
void fsm_measures_list_init ()
{
fsm_debug_msg (0,0, "fsm_measures_list_init()", 2); // sub_automaton 2
if (0) util_pile_test();
if (1) util_pile_test();
if (0) util_double_list_test();
}

50
src/util/list_2x2.c
View File

@ -31,13 +31,13 @@
#include "../../include/util.h"
void list_2x2_init(dblist *l)
void util_list_2x2_init (dblist *l)
{
l->first = NULL;
l->last = NULL;
}
void list_2x2_push_back(dblist *l, int val)
int util_list_2x2_push_back (dblist *l, int val)
{
elem *nouv = malloc (sizeof(elem));
if (! nouv) exit (EXIT_FAILURE);
@ -47,9 +47,10 @@ void list_2x2_push_back(dblist *l, int val)
if (l->last) l->last->next = nouv;
else l->first = nouv;
l->last = nouv;
return val;
}
void list_2x2_push_front(dblist *l, int val)
int util_list_2x2_push_front (dblist *l, int val)
{
elem *nouv = malloc(sizeof(elem));
if (! nouv) exit (EXIT_FAILURE);
@ -59,9 +60,10 @@ void list_2x2_push_front(dblist *l, int val)
if (l->first) l->first->prev = nouv;
else l->last = nouv;
l->first = nouv;
return val;
}
int list_2x2_pop_back(dblist *l)
int util_list_2x2_pop_back (dblist *l)
{
int val;
elem *tmp = l->last;
@ -74,7 +76,7 @@ int list_2x2_pop_back(dblist *l)
return val;
}
int list_2x2_pop_front(dblist *l)
int util_list_2x2_pop_front (dblist *l)
{
int val;
elem *tmp = l->first;
@ -87,17 +89,7 @@ int list_2x2_pop_front(dblist *l)
return val;
}
void list_2x2_view(dblist l)
{
elem *pelem = l.first;
while (pelem)
{
printf ("%d\n", pelem->value);
pelem = pelem->next;
}
}
void list_2x2_clear(dblist *l)
void util_list_2x2_clear (dblist *l)
{
elem *tmp;
elem *pelem = l->first;
@ -110,3 +102,29 @@ void list_2x2_clear(dblist *l)
l->first = NULL;
l->last = NULL;
}
int util_list_2x2_length (dblist l)
{
elem *pelem = l.first;
int cpt = 0;
while (pelem)
{
cpt ++;
pelem = pelem->next;
}
return cpt;
}
void util_list_2x2_view (dblist l)
{
printf ("view liste (n = %d)\n", util_list_2x2_length (l));
elem *pelem = l.first;
while (pelem)
{
printf ("> %d <\n", pelem->value);
pelem = pelem->next;
}
puts ("--------------");
}

32
src/util/pile.c
View File

@ -28,17 +28,17 @@
* * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "../../include/util.h"
void util_pile_push (pile **p, int Val)
int util_pile_push (pile **p, int Val)
{
pile *element = malloc (sizeof(pile));
if (!element) exit (EXIT_FAILURE); // Si l'allocation a échoué.
element->valeur = Val;
element->prec = *p;
*p = element; // Le pointeur pointe sur le dernier élément.
return Val;
}
int util_pile_pop (pile **p)
@ -58,30 +58,32 @@ void util_pile_clear (pile **p)
{
pile *tmp;
while (*p)
{
tmp = (*p)->prec;
free (*p);
*p = tmp;
}
{
tmp = (*p)->prec;
free (*p);
*p = tmp;
}
}
int util_pile_length (pile *p)
{
int n=0;
while (p)
{
n++;
p = p->prec;
}
{
n++;
p = p->prec;
}
return n;
}
void util_pile_view (pile *p)
{
printf ("view pile (n = %d)\n", util_pile_length (p));
while (p)
{
printf ("%d\n", p->valeur);
p = p->prec;
}
{
printf ("%d\n", p->valeur);
p = p->prec;
}
puts ("------");
}

73
src/util/tests.c
View File

@ -34,64 +34,51 @@
void util_pile_test()
{
pile *MaPile = NULL; // Impératif de l'initialiser à NULL
pile *exemple = NULL; // doit être initialisée à NULL
util_pile_push(&MaPile, 10);
util_pile_push(&MaPile, 25);
util_pile_push(&MaPile, 33);
util_pile_push(&MaPile, 12); // Empile 4 valeurs.
printf ("push > %d\n", util_pile_push (&exemple, 1));
printf ("push > %d\n", util_pile_push (&exemple, 2));
printf ("push > %d\n", util_pile_push (&exemple, 3));
printf ("push > %d\n", util_pile_push (&exemple, 4));
puts("Affichage de la pile :");
util_pile_view(MaPile); // Affiche la totalité de la pile.
puts("------");
util_pile_view (exemple);
printf("Nb d'elements : %d\n",util_pile_length(MaPile));
puts("------");
printf ("pop > %d\n", util_pile_pop (&exemple));
printf ("pop > %d\n", util_pile_pop (&exemple));
puts("Deux valeurs soutirées de la pile :");
printf("%d\n",util_pile_pop(&MaPile)); // Affiche deux valeurs
printf("%d\n",util_pile_pop(&MaPile)); // soutirées de la pile.
puts("------");
util_pile_view(exemple);
puts("Affichage de la pile :");
util_pile_view(MaPile); // Affiche la totalité de la pile.
puts("------");
printf ("clear pile\n"); util_pile_clear (&exemple);
util_pile_clear(&MaPile); // Vide la pile.
util_pile_push(&MaPile, 18); // Empile une valeur.
puts("Affichage de la pile apres vidage et ajout d'une valeur :");
util_pile_view(MaPile); // Affiche la totalité de la pile.
puts("------\n");
util_pile_clear(&MaPile); // Vider la pile avant de quitter.
util_pile_view(exemple);
}
void util_double_list_test()
{
dblist MaListe;
dblist exemple;
list_2x2_init(&MaListe);
util_list_2x2_init (&exemple);
list_2x2_push_front(&MaListe,10);
list_2x2_push_back(&MaListe,20);
list_2x2_push_back(&MaListe,40);
list_2x2_push_front(&MaListe,50);
printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 10));
printf ("push back > %d\n", util_list_2x2_push_back (&exemple, 100));
printf ("push back > %d\n", util_list_2x2_push_back (&exemple, 1000));
printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 1));
list_2x2_view(MaListe);
puts("--------------");
util_list_2x2_view (exemple);
printf("%d\n",list_2x2_pop_front(&MaListe));
printf("%d\n",list_2x2_pop_front(&MaListe));
printf("%d\n",list_2x2_pop_back(&MaListe));
puts("--------------");
printf ("pop back > %d\n", util_list_2x2_pop_back (&exemple));
printf ("pop back > %d\n", util_list_2x2_pop_back (&exemple));
printf ("pop back > %d\n", util_list_2x2_pop_back (&exemple));
printf ("pop back > %d\n", util_list_2x2_push_back (&exemple, 2));
list_2x2_push_back(&MaListe,30);
util_list_2x2_view (exemple);
printf("%d\n",list_2x2_pop_front(&MaListe));
printf("%d\n",list_2x2_pop_front(&MaListe));
puts("--------------");
printf ("push back > %d\n", util_list_2x2_push_back (&exemple, 3));
printf ("push front > %d\n", util_list_2x2_push_front (&exemple, 0));
list_2x2_clear(&MaListe);
util_list_2x2_view (exemple);
printf ("clear all\n"); util_list_2x2_clear (&exemple);
util_list_2x2_view (exemple);
}