version semi-finale

antes_colony/Makefile

+CC=gcc
+
+CFLAGS=-Wall -Wextra -std=c11 -g -fsanitize=leak -fsanitize=address -fsanitize=address
+
+LDFLAGS=-lSDL2 -lm -O3
+
+VPATH:=fourmi/ graphe/ matrix/ stack/
+
+all: tp_fourmi
+
+tp_fourmi: fourmi.o graphe.o stack.o matrix.o main.o
+	$(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+
+
+
+matrix.o: matrix.h
+
+stack.o: stack.h
+
+fourmi.o: fourmi.h
+
+graphe.o: graphe.h
+
+
+main.o: graphe.h
+
+execute:
+
+	./tp_fourmi
+
+cls:
+
+	clear
+
+clean:
+
+	rm -rf *.o tp_fourmi
+
+	$(MAKE) cls
+
+
+
+rebuild:
+
+	$(MAKE) clean
+	$(MAKE) tp_fourmi
\ No newline at end of file

antes_colony/fourmi/fourmi.c

+#include "fourmi.h"
+
+
+frmi create_fourmi()
+{
+    frmi fr = malloc(sizeof(f));
+    fr->path = malloc(sizeof(stack));
+    stack_init(fr->path, 100);
+    fr->distance = 0;
+    fr->ttl = 7;
+    return fr;
+}
+
+void destroy_fourmi(frmi f)
+{
+    stack_destroy(f->path);
+    free(f->path);
+    free(f);
+}

antes_colony/fourmi/fourmi.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "../matrix/matrix.h"
+#include "../stack/stack.h"
+
+#ifndef _FOURMI_
+#define _FOURMI_
+#define food_address 3
+
+typedef struct _fourmi
+{
+    stack *path;
+    int distance;
+    int ttl;
+    int depose_pheromone;
+}f;
+
+typedef f *frmi;
+
+frmi create_fourmi();
+
+void destroy_fourmi(frmi f);
+
+// // typedef struct _graph{
+// //     int numnodes;
+// //     matrix *edges;
+// //     matrix *pheromone;
+// // } g;
+// // //pile deux à deux pour une coordonnée
+
+// // typedef g *graph;
+
+// // typedef struct _fourmi
+// // {
+// //     stack *chemin;
+// // }f;
+
+// // typedef f *fourmi;
+
+// // graph create_graph(int numnodes);
+
+// // int has_edge(graph g, int from_node, int to_node);
+
+// // void add_edge(graph g, int from_node, int to_node, int distance);
+
+// // void pheromone_depose(fourmi f);
+
+// // void pheromone_dissipation(graph g);
+
+// // void algorithme_des_fourmils(int fourmiliere, int nourriture, graph g);
+
+// // void create_graph_vis(graph g);
+
+// // void destroy_graph(graph g);
+
+// // void display_graph_vis();
+
+// // void create_graph_vis(graph g);
+
+#endif
\ No newline at end of file

antes_colony/graphe/graphe.c

+#include "graphe.h"
+#define RHO 0.5
+graph create_graph(int num)
+{
+    graph gr = malloc(sizeof(g));
+    if (gr == NULL)
+    {
+        return NULL;
+    }
+    gr->num = num;
+    // init edges (links) matrix
+    matrix *mat = malloc(sizeof(matrix));
+    matrix_init(mat, num, num, 0);
+    gr->edges = mat;
+
+    // init pheromon matrix
+    matrix *mat2 = malloc(sizeof(matrix));
+    matrix_init(mat2, num, num, 1);
+    gr->pheromone = mat2;
+    printf("rand %d, \n", rand());
+    return gr;
+}
+
+int has_edge(graph g, int from_node, int to_node)
+{
+    assert(g != NULL);
+    assert(from_node < g->num);
+    assert(to_node < g->num);
+    return g->edges->data[from_node][to_node];
+}
+
+void add_edge(graph g, int from_node, int to_node, double distance)
+{
+    assert(g != NULL);
+    assert(from_node < g->num);
+    assert(to_node < g->num);
+    if (has_edge(g, from_node, to_node))
+    {
+        return;
+    }
+
+    g->edges->data[from_node][to_node] = distance;
+}
+
+int nb_voisin(graph g, int noeud)
+{
+    int nb_noeud = 0;
+    for (int i = 0; i < g->num; i++)
+    {
+        if (has_edge(g, noeud, i))
+        {
+            nb_noeud++;
+        }
+    }
+    return nb_noeud;
+}
+
+double ph_x_dist(graph g, int from, int to)
+{
+
+    double ph_x_dst = g->pheromone->data[from][to] * (1 / g->edges->data[from][to]);
+    // printf("phx : %f", g->pheromone->data[1][0]);
+
+    return ph_x_dst;
+}
+
+stack ants_path(stack frmi, int path)
+{
+    stack_push(&frmi, path);
+    return frmi;
+}
+
+void pheromone_dissipation(graph g)
+{
+    for (int from = 0; from < g->num; from++)
+    {
+        for (int to = 0; to < g->num; to++)
+        {
+    
+                g->pheromone->data[from][to] = (1-RHO)*g->pheromone->data[from][to];
+            
+        }
+    }
+}
+
+int path_probability_taken(graph g, int noeud)
+{
+    printf("rentré par : %d\n", noeud);
+    double tab[g->num];
+    double tab_cumul[g->num];
+    // initialisation des tableaux à 0
+    for (int k = 0; k < g->num; k++)
+    {
+        tab[k] = 0;
+        tab_cumul[k] = 0;
+    }
+    // mettre les phéromones aux places du tableau pour le choix de l'indicee
+    double somme_pour_proba = 0;
+    for (int r = 0; r < g->num; r++)
+    {
+        if (has_edge(g, noeud, r))
+        {
+            somme_pour_proba += ph_x_dist(g, noeud, r);
+        }
+    }
+    printf("dénominateur : %f \n", somme_pour_proba);
+    // printf("%d somme proab\n", (int)somme_pour_proba);
+    for (int i = 0; i < g->num; i++)
+    {
+        if (has_edge(g, noeud, i))
+        {
+            tab[i] = (g->pheromone->data[noeud][i] * (1.0 / g->edges->data[noeud][i])) / somme_pour_proba;
+            printf("valeur dans tab[%d]: %f\n", i, tab[i]);
+        }
+    }
+    // Calcul nombre total de phéromone
+    double sum_phero = 0;
+    for (int j = 0; j < g->num; j++)
+    {
+        sum_phero += tab[j];
+    }
+    printf("somme total phéromone : %f\n", sum_phero);
+
+    // somme cumulative du tableau
+    for (int x = g->num - 1; x >= 0; x--)
+    {
+        for (int y = 0; y <= x; y++)
+        {
+            tab_cumul[x] += tab[y];
+        }
+        printf("valeur dans tabcumul[%d]: %f\n", x, tab[x]);
+    }
+
+    // print tableau
+    // for (int a = 0; a < g->num; a++)
+    // {
+    //     printf("[%f]", tab[a]);
+    // }
+    printf("cumul : ");
+    for (int b = 0; b < g->num; b++)
+    {
+        printf("[%f]", tab_cumul[b]);
+    }
+    printf("\n");
+    // printf("\n");
+
+    // calcul de la probabilité
+
+    double chemin_probabiliste = (double)rand() / (double)RAND_MAX; // nb entre 0 et 1
+    printf("%f, \n", chemin_probabiliste);
+    printf("nombre aléatoire tiré : %f\n", chemin_probabiliste);
+    // if(chemin_probabiliste == 0)
+    // {
+    //     chemin_probabiliste = 1;
+    // }
+    for (int z = 0; z < g->num; z++)
+    {
+        if (chemin_probabiliste <= tab_cumul[z])
+        {
+            printf("passe par %d -> %d\n", noeud, z);
+            // printf("le nombre de phéromone %d et la probabilité est %d et z est %d et tab_cumul est %d\n", sum_phero, chemin_probabiliste, z, tab_cumul[z]);
+            return z;
+        }
+    }
+    // chemin_probabiliste = chemin_probabiliste % (sum_phero +1);
+    printf("\n");
+    // printf("le nombre de phéromone %d et la probabilité est %d\n", sum_phero, chemin_probabiliste);
+    return 0;
+}
+
+double pheromone_depose(double distance)
+{
+    return 1.0000 / distance;
+}
+
+void random_path(graph g, int noeud, frmi f)
+{
+    // f->ttl--;
+    // condition d'arret si on arrive au noeud final ou si le ttl est à 0
+    if (noeud == 6 || f->ttl <= 0)
+    {
+        return;
+    }
+    ////////////////////////////////////////////////////////////////////////
+    // calcul chemin aléatoire et renvoi l'indice du chemin à prendre
+    int chemin_aleatoire;
+    // do
+    // {
+    chemin_aleatoire = path_probability_taken(g, noeud);
+    // } while (!has_edge(g, noeud, chemin_aleatoire));
+    //-----------------------------------------------------------------
+
+    // stocke la distance parcourue dans la fourmi
+    f->distance += g->edges->data[noeud][chemin_aleatoire];
+    // push le chemin  parcouru dans la stack de la fourmi
+    stack_push(f->path, noeud);
+    stack_push(f->path, chemin_aleatoire);
+    // la récursivité de l'algorithme (parcours graphe en profondeur)
+    random_path(g, chemin_aleatoire, f);
+    printf("phero depose %f\n", pheromone_depose(f->distance));
+    // if(f->ttl == 0)
+    // {
+    //     return;
+    // }
+    g->pheromone->data[noeud][chemin_aleatoire] = ((1-RHO)*g->pheromone->data[noeud][chemin_aleatoire])+ pheromone_depose(f->distance);
+    printf("déposé comme phéromone : %f\n", g->pheromone->data[noeud][chemin_aleatoire]);
+    printf("f->distance = %d\n", f->distance);
+    // print_stack(*f->path);
+    // if(noeud == 0)
+    // {
+    //     pheromone_dissipation(g);
+    // }
+}
+
+void create_graph_vis(graph g)
+{
+    FILE *file = fopen("test2.dot", "w");
+    int affiche = 0;
+    fprintf(file, "digraph Test {\n");
+    for (int from = 0; from < g->num; from++)
+    {
+        for (int to = 0; to < g->num; to++)
+        {
+            if (g->edges->data[from][to])
+            {
+                fprintf(file, "%d->%d[penwidth=2, label= %f]\n", from, to, g->edges->data[from][to]);
+            }
+        }
+        affiche++;
+    }
+
+    fprintf(file, "}");
+
+    fclose(file);
+}
+
+void shortest_path(graph g, frmi f, int noeud)
+{
+    printf("%d noeud", noeud);
+    if (noeud == 6)
+    {
+        return;
+    }
+    double bigger = 0;
+    int index = 0;
+    for (int i = 0; i < g->num; i++)
+    {
+
+        if (g->pheromone->data[noeud][i] > bigger || g->pheromone->data[noeud][i] != 1.0)
+        {
+            bigger = g->pheromone->data[noeud][i];
+            index = i;
+        }
+        if (i == g->num - 1)
+        {
+            printf("s\n\n");
+
+            shortest_path(g, f, index);
+            stack_push(f->path, noeud);
+            stack_push(f->path, index);
+        }
+    }
+}
+
+void display_graph_vis()
+{
+
+    system("dot -Tpng -O test2.dot");
+    system("xdg-open test2.dot.png");
+}
+
+void destroy_graph(graph g)
+{
+    printf("distance_pheromone : %.0f\n", ph_x_dist(g, 0, 1));
+    printf("phero : %f\n", g->pheromone->data[0][1]);
+    if (g->edges->data == NULL)
+    {
+        return;
+    }
+
+    matrix_destroy(g->edges);
+
+    matrix_destroy(g->pheromone);
+    free(g);
+}
\ No newline at end of file

antes_colony/graphe/graphe.h

+#include <stdio.h>
+#include <stdbool.h>
+#include <time.h>
+#include "../matrix/matrix.h"
+#include "../stack/stack.h"
+#include "../fourmi/fourmi.h"
+#ifndef _GRAPHE_
+#define _GRAPHE_
+
+typedef struct _graph
+{
+    int num;
+    matrix *edges;
+    matrix *pheromone;
+} g;
+
+typedef g *graph;
+
+graph create_graph(int num);
+
+int has_edge(graph g, int from_node, int to_node);
+
+void add_edge(graph g, int from_node, int to_node, double distance);
+
+int nb_voisin(graph g, int noeud);
+
+void random_path(graph g, int noeud, frmi f);
+
+void shortest_path(graph g, frmi f, int noeud);
+
+// void first_walk(graph g, int index, stack *s);
+// void walk(graph g, int index);
+void create_graph_vis(graph g);
+
+void display_graph_vis();
+
+void destroy_graph(graph g);
+
+#endif
\ No newline at end of file

antes_colony/main.c

+#include "graphe/graphe.h"
+// #include "stack/stack.h"
+
+int main()
+{
+    double testestset = 0;
+    testestset = ((0.5)*1.0)+(45.0/434.0);
+    printf("test calcul %f\n",testestset);
+    srand(time(NULL));
+    graph g1 = create_graph(7);
+    stack stack;
+    stack_init(&stack, 50);
+
+    // printf("\n");
+    // matrix_print(*g1->pheromone);
+    // printf("\nadded edge\n\n");
+    add_edge(g1, 4, 3, 1.0);
+    add_edge(g1, 1, 3, 2.0);
+    add_edge(g1, 2, 3, 2.0);
+    add_edge(g1, 4, 1, 3.0);
+    add_edge(g1, 0, 1, 5.0);
+    add_edge(g1, 0, 4, 1.0);
+    add_edge(g1, 0, 2, 1.0);
+    add_edge(g1, 0, 3, 8.0);
+    add_edge(g1, 3, 5, 1.0);
+    add_edge(g1, 5, 6, 1.0);
+    add_edge(g1, 2, 5, 2.0);
+    add_edge(g1, 1, 6, 4.0);
+    add_edge(g1, 0, 5, 5.0);
+    matrix_print(*g1->pheromone);
+    for (int i = 0; i < 10000; i++)
+    {
+        frmi f = create_fourmi();
+        random_path(g1, 0, f);
+        destroy_fourmi(f);
+    }
+    
+    printf("\n length path matrix \n");
+    matrix_print(*g1->edges);
+    printf("\npheromone matrix \n");
+    matrix_print(*g1->pheromone);
+    // printf("\npheromone changed\n\n");
+    // pheromone_dissipation(g1);
+    // matrix_print(*g1->pheromone);
+    // algorithme_des_fourmils(1, 3, g1);
+
+    printf("====================================================");
+    // first_walk(g1, 0, &stack);
+    printf("\n%d a %d voisins \n", 0, nb_voisin(g1, 0));
+
+    printf("====================================================");
+
+    create_graph_vis(g1);
+    display_graph_vis();
+    frmi eclaireuse = create_fourmi();
+    // shortest_path(g1, eclaireuse, 0);
+    // printf("shortest path is : ");
+    // print_stack(*eclaireuse->path);
+    // printf("\n");
+    // destroy_fourmi(eclaireuse);
+    
+    destroy_graph(g1);
+    stack_destroy(&stack);
+
+    return 0;
+}
\ No newline at end of file

antes_colony/matrix/matrix.c

+#include "matrix.h"
+
+error_code matrix_alloc(matrix *mat, int li, int co)
+{
+    mat->data = malloc(li * sizeof(double*));
+    if(mat->data == NULL)
+    {
+        return err;
+    }
+    for(int row = 0; row < li; row++)
+    {        
+        mat->data[row] = malloc(co * sizeof(double));
+        if(mat->data[row] == NULL)
+        {
+            return err;
+        }
+    }
+    return ok;
+}
+
+error_code matrix_init(matrix *mat, int li, int co, double val)
+{
+    if( matrix_alloc(mat, li, co) == err) return err;
+    mat->rows = li;
+    mat->cols = co;
+    for(int row = 0; row < li; row++)
+    {
+        for(int col = 0; col < co; col++)
+        {
+            mat->data[row][col] = val;
+        }
+    }
+    return ok;
+}
+
+error_code matrix_print(const matrix mat)
+{
+    printf("    0 1 2 3 4 5 6\n");
+    printf("    - - - - -\n");
+    for(int row = 0; row < mat.rows; row++)
+    {
+        printf("%d | ", row);
+        for(int col = 0; col < mat.cols; col++)
+        {
+            printf("%f ", mat.data[row][col]);
+        }
+        printf("\n");
+    }
+    return ok;
+}
+
+error_code matrix_destroy(matrix *mat)
+{
+    for(int row = 0; row < mat->rows; row++)
+    {        
+        free(mat->data[row]);
+    }
+    free(mat->data);
+    mat->rows = -1;
+    mat->cols = -1;
+    mat->data = NULL;
+    free(mat);
+    return ok;
+}
+
+// error_code matrix_init_from_array(matrix *mat, int li, int co, int data[], int s) //data [0] = mat->data[0][0] data[3] = mat->data[1][1]
+// {
+//     if(s != li*co)
+//     {
+//         return err;
+//     }
+//     for(int row = 0; row < li; row++)
+//     {
+//         for(int col = 0; col < co; col++)
+//         {
+//             mat->data[row][col] = data[col + (row * li)];
+//         }
+//     }
+//     return ok;
+// }
+
+// error_code matrix_clone(matrix *cloned, const matrix mat)
+// {
+//     for(int row = 0; row < mat.rows; row++)
+//     {
+//         for(int col = 0; col < mat.cols; col++)
+//         {
+//             cloned->data[row][col] = mat.data[row][col];
+//         }
+//     }
+//     return ok;
+// }
+
+// error_code matrix_transpose(matrix *transposed, const matrix mat)
+// {
+//     for(int row = 0; row < mat.rows; row++)
+//     {
+//         for(int col = 0; col < mat.cols; col++)
+//         {
+//             transposed->data[col][row] = mat.data[row][col];
+//         }
+//     }
+//     return ok;
+// }
+// error_code matrix_extract_submatrix(matrix *sub, const matrix mat,int li0, int li1, int co0, int co1)
+// {
+//     int row = li1 - li0;
+//     int col = co1 - co0;
+//     if(row < sub->rows || col < sub->cols || row > sub->rows || col > sub->cols)
+//     {
+//         return err;
+//     }
+//     for(int i = li0; i < li1; i++)
+//     {
+//         for(int j = co0; j < co1; j++)
+//         {
+//             sub->data[i-li0][j-co0] = mat.data[i][j];
+//         }
+//     }
+//     return ok;
+// }
+
+// bool matrix_is_equal(matrix mat1, matrix mat2)
+// {
+//     int estVrai = 1;
+//     assert(estVrai == 1);
+//     if(mat1.rows != mat2.rows)
+//     {
+//         return false;
+//     }
+//     else if(mat1.cols != mat2.cols)
+//     {
+//         return false;
+//     }
+//     else
+//     {
+//         for(int row = 0; row < mat1.rows; row++)
+//     {
+//         for(int col = 0; col < mat1.cols; col++)
+//         {
+//             if(mat1.data[row][col] != mat2.data[row][col])
+//             {
+//                 estVrai = 0;
+//             }
+            
+//         }
+//     }
+//     if(estVrai == 1)
+//     {
+//         return true;
+//     }
+//     else
+//     {
+//         return false;
+//     }
+//     }
+// }
+
+// error_code matrix_get(int *elem, const matrix mat, int ix, int iy)
+// {
+//     if(ix >= mat.rows || iy >= mat.cols)
+//     {
+//         return err;
+//     }
+//     else
+//     {
+//         *elem = mat.data[ix][iy];
+//         return ok;
+//     }
+// }
+
+// error_code matrix_set(matrix *mat, int ix, int iy, int elem)
+// {
+//     if(ix >= mat->cols || iy >= mat->cols)
+//     {
+//         return err;
+//     }
+//     else
+//     {
+//         mat->data[ix][iy] = elem;
+//         return ok;
+//     }
+// }
\ No newline at end of file

antes_colony/matrix/matrix.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#ifndef _MATRIX_
+#define _MATRIX_
+
+typedef enum _error_code {
+    ok, err
+} error_code;
+
+typedef struct _matrix {
+    int rows; // number of rows
+    int cols; // number of columns
+    double** data; // un pointeur sur un tableau de ligne n
+} matrix;
+
+error_code matrix_alloc(matrix *mat, int li, int co);
+
+error_code matrix_init(matrix *mat, int m, int n, double val);
+
+error_code matrix_print(const matrix mat);
+
+error_code matrix_destroy(matrix *mat);
+
+error_code matrix_init_from_array(matrix *mat, int li, int co, int data[], int s);
+
+error_code matrix_clone(matrix *cloned, const matrix mat);
+
+error_code matrix_transpose(matrix *transposed, const matrix mat);
+
+error_code matrix_extract_submatrix(matrix *sub, const matrix mat,int li0, int li1, int co0, int co1);
+
+bool matrix_is_equal(matrix mat1, matrix mat2);
+
+error_code matrix_get(int *elem, const matrix mat, int ix, int iy);
+
+error_code matrix_set(matrix *mat, int ix, int iy, int elem);
+
+#endif
\ No newline at end of file

antes_colony/stack/stack.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "stack.h"
+
+void stack_init(stack *s, int max_capacity)
+{
+    s->size = max_capacity;
+    s->data = malloc(max_capacity * sizeof(int));
+    s->top = -1;
+}
+
+void print_stack(stack s)
+{
+    if(stack_is_empty(s)){
+        printf("stack is empty\n");
+    }else {
+
+          for(int i = 0; i < s.top+1; i++){ 
+            printf("[%d] ", s.data[i]);
+        }
+        printf("\n");
+    }
+  
+}
+
+void stack_push(stack *s, int value)
+{
+    if(s->top == s->size-1)
+    {
+        printf("stack full\n");
+        return;
+    }
+    else
+    {
+        s->top++;
+        s->data[s->top] = value;
+    }
+    
+}
+
+void stack_pop(stack *s, int *val) //échoue si vide
+{
+    if(stack_is_empty(*s))
+    {
+        printf("empty stack\n");
+        return;
+    }
+    else
+    {
+        *val = s->data[s->top];
+        s->top--;
+    }
+    
+}
+
+void stack_peek(stack s, int *val)//return the top of the stack without pooping                                
+{                                   // error if stakc is empty or NULL
+    *val = s.data[s.top];
+}
+
+bool stack_is_empty(stack s)//check if stack is empty
+{ 
+    return s.top < 0;
+}
+
+void stack_destroy(stack *s)
+{
+    s->top = -1;
+    free(s->data);
+}
+
+void stack_to_stack(stack *stack_emet, stack *stack_dest)
+{
+    if (stack_is_empty(*stack_emet)){
+        printf("stack empty");
+        return;
+    }
+    int valeur;
+    stack_pop(stack_emet, &valeur);
+    stack_push(stack_dest, valeur);
+}
\ No newline at end of file

antes_colony/stack/stack.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#ifndef _STACK_
+#define _STACK_
+
+typedef struct _stack {
+    int size;
+    int top;
+    int *data;
+} stack;
+
+void stack_init(stack *s, int max_apacity);
+
+void print_stack(stack s);
+
+void stack_push(stack *s, int value);
+
+void stack_pop(stack *s, int *val);
+
+void stack_peek(stack s, int *val);
+
+bool stack_is_empty(stack s);
+
+void stack_to_stack(stack *stack_emet, stack *stack_dest);
+
+void stack_destroy(stack *s);
+
+#endif
+

antes_colony/stack_stack/stack_stack.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "stack.h"
+
+typedef struct _stack_stack {
+    int size;
+    int top;
+    stack *data;
+} stack_stack;
\ No newline at end of file

antes_colony/stack_stack/stack_stack.h

+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "stack.h"
+
+void stack_init(stack *s, int max_capacity)
+{
+    s->size = max_capacity;
+    s->data = malloc(max_capacity * sizeof(int));
+    s->top = -1;
+}
+
+void print_stack(stack s)
+{
+    if(stack_is_empty(s)){
+        printf("stack is empty\n");
+    }else {
+
+          for(int i = 0; i < s.top+1; i++){ 
+            printf("[%d] ", s.data[i]);
+        }
+        printf("\n");
+    }
+  
+}
+
+void stack_push(stack *s, int value)
+{
+    if(s->top == s->size-1)
+    {
+        printf("stack full\n");
+        return;
+    }
+    else
+    {
+        s->top++;
+        s->data[s->top] = value;
+    }
+    
+}
+
+void stack_pop(stack *s, int *val) //échoue si vide
+{
+    if(stack_is_empty(*s))
+    {
+        printf("empty stack\n");
+        return;
+    }
+    else
+    {
+        *val = s->data[s->top];
+        s->top--;
+    }
+    
+}
+
+void stack_peek(stack s, int *val)//return the top of the stack without pooping                                
+{                                   // error if stakc is empty or NULL
+    *val = s.data[s.top];
+}
+
+bool stack_is_empty(stack s)//check if stack is empty
+{ 
+    return s.top < 0;
+}
+
+void stack_destroy(stack *s)
+{
+    s->top = -1;
+    free(s->data);
+}
+
+void stack_to_stack(stack *stack_emet, stack *stack_dest)
+{
+    if (stack_is_empty(*stack_emet)){
+        printf("stack empty");
+        return;
+    }
+    int valeur;
+    stack_pop(stack_emet, &valeur);
+    stack_push(stack_dest, valeur);
+}
\ No newline at end of file

antes_colony/test.dot

+digraph Test {
+0->1->3->1->6->25;
+1->1->3->1->6->25;
+2->1->3->1->6->25;
+3->1->3->1->6->25;
+4->1->3->1->6->25;
+5->1->3->1->6->25;
+6->1->3->1->6->25;
+7->1->3->1->6->25;
+8->1->3->1->6->25;
+4->3->1->3->9;
+1->3->1->6->25;
+}

antes_colony/test2.dot

+digraph Test {
+0->1[penwidth=2, label= 5.000000]
+0->2[penwidth=2, label= 1.000000]
+0->3[penwidth=2, label= 8.000000]
+0->4[penwidth=2, label= 1.000000]
+0->5[penwidth=2, label= 5.000000]
+1->3[penwidth=2, label= 2.000000]
+1->6[penwidth=2, label= 4.000000]
+2->3[penwidth=2, label= 2.000000]
+2->5[penwidth=2, label= 2.000000]
+3->5[penwidth=2, label= 1.000000]
+4->1[penwidth=2, label= 3.000000]
+4->3[penwidth=2, label= 1.000000]
+5->6[penwidth=2, label= 1.000000]
+}
\ No newline at end of file