From bf7ce450960790245edc005c66aee0db0b6fd5a1 Mon Sep 17 00:00:00 2001 From: untypequicode Date: Sun, 15 Dec 2024 17:15:36 +0100 Subject: [PATCH] Ajout de dequeue et bollarray avec leurs tests --- Anna et Ethan/shell_test.c | 376 +++++++++++++++++++++++++++++++++ Anna et Ethan/type_boolarray.c | 112 ++++++++++ Anna et Ethan/type_dequeue.c | 332 +++++++++++++++++++++++++++++ 3 files changed, 820 insertions(+) create mode 100644 Anna et Ethan/shell_test.c create mode 100644 Anna et Ethan/type_boolarray.c create mode 100644 Anna et Ethan/type_dequeue.c diff --git a/Anna et Ethan/shell_test.c b/Anna et Ethan/shell_test.c new file mode 100644 index 0000000..c0ad9b6 --- /dev/null +++ b/Anna et Ethan/shell_test.c @@ -0,0 +1,376 @@ +#include "shell_test.h" + +#include +#include + +#include "files.h" +#include "graphs.h" +#include "nfa.h" +#include "nfa_determi.h" +#include "nfa_tocode.h" +#include "parse_regexp.h" +#include "parser.h" +#include "shell_languages.h" +#include "shell_tools.h" +#include "type_boolarray.h" +#include "type_dequeue.h" + +// Cette fonction est appelée par le shell sur la commande "test". +// Vous pouvez y mettre le code que vous voulez tester. + +#define TEST_DEQUEUE true +#define TEST_BOOLARRAY false +#define NB_TESTS_OCCUR 1000 + +static void printf_dequeue(dequeue *dq, char *function, char *var, + int i_function, int i_result) { + if (function != NULL) + printf("%s(", function); + else + printf("%s\n", var); + if (function != NULL && i_function >= 0) printf("%d, ", i_function); + if (function != NULL) printf("%s)", var); + if (function != NULL && i_result >= 0) + printf(" = %d\n", i_result); + else if (function != NULL) + printf("\n"); + print_dequeue(dq); + printf("isempty_dequeue(%s) = %d\n", var, isempty_dequeue(dq)); + printf("size_dequeue(%s) = %d\n", var, size_dequeue(dq)); + printf("\n"); +} + +static void printf_boolarray(barray *ba, char *function, char *var, + int i_function, int i_result) { + if (function != NULL) + printf("%s(", function); + else + printf("%s\n", var); + if (function != NULL && i_function >= 0) printf("%d, ", i_function); + if (function != NULL) printf("%s)", var); + if (function != NULL && i_result >= 0) + printf(" = %d\n", i_result); + else if (function != NULL) + printf("\n"); + printf("Boolarray : "); + for (uint i = 0; i < getsize_barray(ba); i++) { + printf("%d ", getval_barray(ba, i)); + } + printf("\n"); + printf("getsize_barray(%s) = %d\n", var, getsize_barray(ba)); + printf("\n"); +} + +void test(void) { + // regexp *myexp; + + // Cette première affectation ne fonctionnera que si vous avez implémenté + // les fonctions du module regexp.h. + // myexp = parse_string_regexp("(a+bb)*"); + + // L'affichage de l'expression régulière est fait par la fonction reg_print, + // définie dans printing.c et déjà fournie. Vous pouvez la décommenter pour + // afficher l'expression régulière, après avoir implémenté les fonctions + // nécessaires dans regexp.c. + // reg_print(myexp); + + // Autre exemple, avec une construction directe de NFA. + // nfa* A = create_sing_epsilon(); + // nfa_view(A); + + // Tests de dequeue + if (TEST_DEQUEUE) { + dequeue *dq = create_dequeue(); + printf_dequeue(dq, NULL, "dq", 0, -1); + for (uint i = 11; i <= 20; i++) { + rigins_dequeue(i, dq); + // printf_dequeue(dq, "rigins_dequeue", "dq", i, -1); + } + for (uint i = 10; i > 0; i--) { + lefins_dequeue(i, dq); + // printf_dequeue(dq, "leftins_dequeue", "dq", i, -1); + } + printf("--------------------\n"); + printf( + "Test rigins_dequeue et leftins_dequeue\n"); // Test rigins_dequeue + // et leftins_dequeue + printf("--------------------\n"); + for (uint i = 0; i < size_dequeue(dq); i++) { + assert(lefread_dequeue(dq, i) == i + 1); + printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1); + } + for (uint i = 0; i < 20; i++) { + if (i % 2 == 0) { + uint tmp[i / 2]; + for (uint j = 0; j < i / 2; j++) { + // printf_dequeue(dq, "lefread_dequeue", "dq", -1, + // lefread_dequeue(dq, 0)); + tmp[j] = lefpull_dequeue(dq); + // printf_dequeue(dq, "lefpull_dequeue", + // "dq", -1, -1); + } + for (uint j = 0; j < i / 2; j++) { + lefins_dequeue(tmp[i / 2 - j - 1], dq); + // printf_dequeue(dq, "lefins_dequeue", "dq", tmp[j], -1); + } + } else { + uint tmp[i / 2]; + for (uint j = 0; j < i / 2; j++) { + // printf_dequeue(dq, "rigread_dequeue", "dq", -1, + // rigread_dequeue(dq, 0)); + tmp[j] = rigpull_dequeue(dq); + // printf_dequeue(dq, "rigpull_dequeue", "dq", -1, -1); + } + for (uint j = 0; j < i / 2; j++) { + rigins_dequeue(tmp[i / 2 - j - 1], dq); + // printf_dequeue(dq, "rigins_dequeue", "dq", tmp[j], -1); + } + } + } + printf("--------------------\n"); + printf( + "Test lefpull_dequeue et rigpull_dequeue\n"); // Test + // lefpull_dequeue et + // rigpull_dequeue + printf("--------------------\n"); + for (uint i = 0; i < size_dequeue(dq); i++) { + assert(lefread_dequeue(dq, i) == i + 1); + printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1); + } + printf("--------------------\n"); + printf( + "Test makeempty_dequeue et copy_dequeue_right in array [1, 20]\n"); // Test makeempty_dequeue et copy_dequeue_right + printf("--------------------\n"); + dequeue *dq2 = create_dequeue(); + for (uint i = 0; i < 10; i++) { + makeempty_dequeue(dq2); + // printf_dequeue(dq2, "makeempty_dequeue", "dq2", -1, -1); + copy_dequeue_right(dq2, dq, i); + // printf_dequeue(dq2, "copy_dequeue_right", "dq2", i, -1); + printf("----------"); + printf(" Test +%d ", i); + printf("----------\n"); + for (uint j = 0; j < size_dequeue(dq2); j++) { + assert(lefread_dequeue(dq2, j) == lefread_dequeue(dq, j) + i); + printf("assert(lefread_dequeue(dq2, %d) == %d) check\n", j, + lefread_dequeue(dq, j) + i); + } + } + printf("--------------------\n"); + printf("Test mem_dequeue in array [1, 20]\n"); // Test mem_dequeue + printf("--------------------\n"); + for (uint i = 0; i < 20; i++) { + uint value = rand() % 100; + // printf_dequeue(dq, "mem_dequeue", "dq2", value, + // mem_dequeue(value, dq)); + assert(mem_dequeue(value, dq) == (value > 0 && value <= 20)); + printf("assert(mem_dequeue(%d, dq) == %d) check\n", value, + (value > 0 && value <= 20)); + } + if (dq == NULL) delete_dequeue(dq2); + for (uint k = 0; k < NB_TESTS_OCCUR; k++) { + dq2 = create_dequeue(); + for (uint i = 0; i < 20; i++) { + lefins_dequeue(rand() % 100, dq2); + } + // printf_dequeue(dq2, "random", "dq2", -1, -1); + sort_dequeue_norepeat(dq2); + // printf_dequeue(dq2, "sort_dequeue_norepeat", "dq2", -1, -1); + printf("--------------------\n"); + printf( + "Test sort_dequeue_norepeat\n"); // Test sort_dequeue_norepeat + printf("--------------------\n"); + for (uint i = 0; i < size_dequeue(dq2) - 1; i++) { + assert(lefread_dequeue(dq2, i) < lefread_dequeue(dq2, i + 1)); + printf( + "%u - assert(lefread_dequeue(dq2, %d) < " + "lefread_dequeue(dq2, " + "%d)) " + "check\n", + k, i, i + 1); + } + // for (uint i = 0; i < 20; i++) { + // printf_dequeue(dq2, "mem_dequeue_sorted", "dq2", i, + // mem_dequeue_sorted(i, dq2)); + // } + printf("--------------------\n"); + printf("Test mem_dequeue_sorted\n"); // Test mem_dequeue_sorted + printf("--------------------\n"); + for (uint i = 0; i < 20; i++) { + assert(mem_dequeue_sorted(i, dq2) == mem_dequeue(i, dq2)); + printf("assert(mem_dequeue_sorted(%d, dq2) == %d) check\n", i, + mem_dequeue(i, dq2)); + } + if (dq2 == NULL) delete_dequeue(dq2); + } + printf("--------------------\n"); + printf("Test merge_sorted_dequeue\n"); // Test merge_sorted_dequeue + printf("--------------------\n"); + for (uint k = 0; k < NB_TESTS_OCCUR; k++) { + dq = create_dequeue(); + dq2 = create_dequeue(); + dequeue *dq3 = create_dequeue(); + for (uint i = 0; i < 10; i++) { + lefins_dequeue(rand() % 100, dq); + lefins_dequeue(rand() % 100, dq2); + } + sort_dequeue_norepeat(dq); + sort_dequeue_norepeat(dq2); + copy_dequeue_right(dq3, dq, 0); + merge_sorted_dequeue(dq3, dq2); + for (uint i = 0; i < size_dequeue(dq3) - 1; i++) { + assert(lefread_dequeue(dq3, i) < lefread_dequeue(dq3, i + 1)); + printf( + "%u - assert(lefread_dequeue(dq2, %d) < " + "lefread_dequeue(dq2, " + "%d)) " + "check\n", + k, i, i + 1); + } + for (uint i = 0; i < size_dequeue(dq3); i++) { + assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) || + mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2)); + printf( + "%u - assert(mem_dequeue_sorted(%d, dq) || " + "mem_dequeue_sorted(%d, dq2)) check\n", + k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i)); + } + for (uint i = 0; i < size_dequeue(dq); i++) { + assert(mem_dequeue_sorted(lefread_dequeue(dq, i), dq3)); + printf( + "%u - assert(mem_dequeue_sorted(leftread_dequeue(dq, %d), " + "dq3)) check\n", + k, i); + } + for (uint i = 0; i < size_dequeue(dq2); i++) { + assert(mem_dequeue_sorted(lefread_dequeue(dq2, i), dq3)); + printf( + "%u - assert(mem_dequeue_sorted(leftread_dequeue(dq2, %d), " + "dq3)) check\n", + k, i); + } + if (dq == NULL) delete_dequeue(dq); + if (dq2 == NULL) delete_dequeue(dq2); + if (dq3 == NULL) delete_dequeue(dq3); + } + printf("--------------------\n"); + printf( + "Test make_inter_sorted_dequeue\n"); // Test + // make_inter_sorted_dequeue + printf("--------------------\n"); + for (uint k = 0; k < NB_TESTS_OCCUR; k++) { + dq = create_dequeue(); + dq2 = create_dequeue(); + for (uint i = 0; i < 20; i++) { + lefins_dequeue(rand() % 100, dq); + lefins_dequeue(rand() % 100, dq2); + } + sort_dequeue_norepeat(dq); + sort_dequeue_norepeat(dq2); + dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2); + for (uint i = 0; i < size_dequeue(dq3); i++) { + assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) && + mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2)); + printf( + "%u - assert(mem_dequeue_sorted(%d, dq) && " + "mem_dequeue_sorted(%d, dq2)) check\n", + k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i)); + } + if (dq == NULL) delete_dequeue(dq); + if (dq2 == NULL) delete_dequeue(dq2); + if (dq3 == NULL) delete_dequeue(dq3); + } + printf("--------------------\n"); + printf("Test intersec_dequeue\n"); // Test + // intersec_dequeue + printf("--------------------\n"); + for (uint k = 0; k < NB_TESTS_OCCUR; k++) { + dq = create_dequeue(); + dq2 = create_dequeue(); + for (uint i = 0; i < 10; i++) { + lefins_dequeue(rand() % 100, dq); + lefins_dequeue(rand() % 100, dq2); + } + sort_dequeue_norepeat(dq); + sort_dequeue_norepeat(dq2); + bool result = intersec_dequeue(dq, dq2); + dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2); + assert(result == (size_dequeue(dq3) > 0)); + printf( + "%u - size_dequeue(make_inter_sorted_dequeue(dq, dq2)) check\n", + k); + if (dq == NULL) delete_dequeue(dq); + if (dq2 == NULL) delete_dequeue(dq2); + } + for (uint k = 0; k < NB_TESTS_OCCUR; k++) { + dq = create_dequeue(); + for (uint i = 0; i < 10; i++) { + lefins_dequeue(rand() % 100, dq); + } + sort_dequeue_norepeat(dq); + uint val = rand() % 100; + insert_dequeue(dq, val); + for (uint i = 0; i < size_dequeue(dq) - 1; i++) { + assert(lefread_dequeue(dq, i) < lefread_dequeue(dq, i + 1)); + printf( + "%u - assert(lefread_dequeue(dq2, %d) < " + "lefread_dequeue(dq2, " + "%d)) " + "check\n", + k, i, i + 1); + } + assert(mem_dequeue_sorted(val, dq)); + printf("%u - assert(mem_dequeue_sorted(%d, dq)) check\n", k, val); + if (dq == NULL) delete_dequeue(dq); + } + printf("--------------------\n"); + printf("Plus de %d tests effectués avec succès\n", NB_TESTS_OCCUR * 5); + } + // Tests de boolarray + if (TEST_BOOLARRAY) { + barray *ba = create_barray(10); + printf_boolarray(ba, NULL, "ba", 0, -1); + for (uint i = 0; i < 10; i++) { + if (i % 2 == 0) { + settrue_barray(ba, i); + printf_boolarray(ba, "settrue_barray", "ba", i, -1); + } else { + setfalse_barray(ba, i); + printf_boolarray(ba, "setfalse_barray", "ba", i, -1); + } + } + delete_barray(ba); + ba = create_barray(10); + for (uint i = 0; i < 10; i++) { + bool x = rand() % 2; + if (x) { + settrue_barray(ba, i); + printf_boolarray(ba, "settrue_barray", "ba", i, -1); + } else { + setfalse_barray(ba, i); + printf_boolarray(ba, "setfalse_barray", "ba", i, -1); + } + } + barray *ba2 = create_barray(10); + for (uint i = 0; i < 10; i++) { + bool x = rand() % 2; + if (x) { + settrue_barray(ba2, i); + } else { + setfalse_barray(ba2, i); + } + } + printf_boolarray(ba2, NULL, "ba2", -1, -1); + barray *ba3 = or_barray(ba, ba2); + printf_boolarray(ba3, "or_barray", "ba3", -1, -1); + delete_barray(ba3); + ba3 = and_barray(ba, ba2); + printf_boolarray(ba3, "and_barray", "ba3", -1, -1); + delete_barray(ba3); + delete_barray(ba2); + printf_boolarray(ba, NULL, "ba", -1, -1); + ba2 = copy_barray(ba); + printf_boolarray(ba2, "copy_barray", "ba", -1, -1); + delete_barray(ba); + } +} diff --git a/Anna et Ethan/type_boolarray.c b/Anna et Ethan/type_boolarray.c new file mode 100644 index 0000000..cea6ce5 --- /dev/null +++ b/Anna et Ethan/type_boolarray.c @@ -0,0 +1,112 @@ +#include "type_boolarray.h" + +barray *create_barray(uint size) { + barray *ptr = malloc(sizeof(barray)); + ptr->size = size; + if (size % 8 == 0) { + ptr->size_array = size / 8; + } else { + ptr->size_array = size / 8 + 1; + } + ptr->array = malloc(ptr->size_array * sizeof(uchar)); + for (uint i = 0; i < ptr->size_array; i++) { + ptr->array[i] = false; + } + + return ptr; +} + +uint getsize_barray(barray *ptr) { + if (ptr == NULL) { + ERROR("getsize_barray: ptr is NULL"); + } + return ptr->size; +} + +void delete_barray(barray *ptr) { + if (ptr == NULL) { + return; + } + if (ptr->array != NULL) { + free(ptr->array); + } + free(ptr); + return; +} + +void settrue_barray(barray *ptr, uint num_bool) { + if (ptr == NULL) { + ERROR("settrue_barray: ptr is NULL"); + } + if (num_bool >= ptr->size) { + ERROR("settrue_barray: cell is out of bounds"); + } + uint cell = num_bool / 8; + uint bit = num_bool % 8; + ptr->array[cell] |= 1 << bit; + return; +} + +void setfalse_barray(barray *ptr, uint num_bool) { + if (ptr == NULL) { + ERROR("setfalse_barray: ptr is NULL"); + } + if (num_bool >= ptr->size) { + ERROR("setfalse_barray: cell is out of bounds"); + } + uint cell = num_bool / 8; + uint bit = num_bool % 8; + ptr->array[cell] &= ~(1 << bit); + return; +} + +bool getval_barray(barray *ptr, uint num_bool) { + if (ptr == NULL) { + ERROR("getval_barray: ptr is NULL"); + } + if (num_bool >= ptr->size) { + ERROR("getval_barray: cell is out of bounds"); + } + uint cell = num_bool / 8; + uint bit = num_bool % 8; + return (ptr->array[cell] & 1 << bit); +} + +barray *or_barray(barray *ptr1, barray *ptr2) { + if (ptr1 == NULL || ptr2 == NULL) { + ERROR("or_barray: ptr is NULL"); + } + if (ptr1->size != ptr2->size) { + return NULL; + } + barray *ptr = create_barray(ptr1->size); + for (uint i = 0; i < ptr->size; i++) { + ptr->array[i] = ptr1->array[i] | ptr2->array[i]; + } + return ptr; +} + +barray *and_barray(barray *ptr1, barray *ptr2) { + if (ptr1 == NULL || ptr2 == NULL) { + ERROR("or_barray: ptr is NULL"); + } + if (ptr1->size != ptr2->size) { + return NULL; + } + barray *ptr = create_barray(ptr1->size); + for (uint i = 0; i < ptr->size; i++) { + ptr->array[i] = ptr1->array[i] & ptr2->array[i]; + } + return ptr; +} + +barray *copy_barray(barray *ptr) { + if (ptr == NULL) { + ERROR("copy_barray: ptr is NULL"); + } + barray *copy = create_barray(ptr->size); + for (uint i = 0; i < ptr->size_array; i++) { + copy->array[i] = ptr->array[i]; + } + return copy; +} diff --git a/Anna et Ethan/type_dequeue.c b/Anna et Ethan/type_dequeue.c new file mode 100644 index 0000000..a63472d --- /dev/null +++ b/Anna et Ethan/type_dequeue.c @@ -0,0 +1,332 @@ +/*****************************************/ +/* Implémentations des listes de sommets */ +/* Utilisation d'un tuyau par liste */ +/*****************************************/ + +#include "type_dequeue.h" + +#include +#include +#include + +#include "error.h" +#include "type_boolarray.h" + +/************************/ +/* Fonctions primitives */ +/************************/ + +/* Création */ +dequeue *create_dequeue(void) { + dequeue *ptr = malloc(sizeof(dequeue)); + ptr->array = malloc(sizeof(uint) * 1); + ptr->size_array = 1; + ptr->left = 0; + ptr->right = 0; + ptr->empty = true; + return ptr; +} + +/* Suppression */ +void delete_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("delete_dequeue : ptr NULL"); + if (ptr->array != NULL) free(ptr->array); + if (ptr != NULL) free(ptr); + ptr = NULL; +} + +/* Test du vide */ +bool isempty_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("isempty_dequeue : ptr NULL"); + return ptr->empty; +} + +/* Vidage d'un tuyau*/ +void makeempty_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("makeempty_dequeue : ptr NULL"); + if (ptr->array != NULL) free(ptr->array); + ptr->array = malloc(sizeof(uint) * 1); + ptr->size_array = 1; + ptr->left = 0; + ptr->right = 0; + ptr->empty = true; +} + +/* Taille */ +uint size_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("size_dequeue : ptr NULL"); + if (isempty_dequeue(ptr)) + return 0; + else if (ptr->right > ptr->left) + return ptr->right - ptr->left; + else if (ptr->right == ptr->left) + return ptr->size_array; + else + return ptr->size_array - ptr->left + ptr->right; +} + +/* Lecture */ +uint lefread_dequeue(dequeue *ptr, uint i) { + if (ptr == NULL) ERROR("lefread_dequeue : ptr NULL"); + if (isempty_dequeue(ptr)) ERROR("lefread_dequeue : ptr empty"); + if (i >= size_dequeue(ptr)) ERROR("lefread_dequeue : i out of bounds"); + return ptr->array[(ptr->left + i) % ptr->size_array]; +} + +uint rigread_dequeue(dequeue *ptr, uint i) { + if (ptr == NULL) ERROR("rigread_dequeue : ptr NULL"); + if (isempty_dequeue(ptr)) ERROR("rigread_dequeue : ptr empty"); + if (i >= size_dequeue(ptr)) ERROR("rigread_dequeue : i out of bounds"); + return ptr->array[(ptr->right - i - 1) % ptr->size_array]; +} + +static void grow_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("grow_dequeue : ptr NULL"); + while (ptr->left != 0) { + int temp = ptr->array[ptr->left]; + for (uint i = 0; i < ptr->size_array; i++) { + ptr->array[(ptr->left + i) % ptr->size_array] = + ptr->array[(ptr->left + i + 1) % ptr->size_array]; + } + ptr->array[(ptr->left - 1) % ptr->size_array] = temp; + ptr->left--; + ptr->right = (ptr->right - 1) % ptr->size_array; + } + ptr->right = ptr->size_array; + ptr->left = 0; + ptr->size_array *= 2; + ptr->array = realloc(ptr->array, ptr->size_array * sizeof(int)); + return; +} + +/* Insérer */ +void lefins_dequeue(uint val, dequeue *ptr) { + if (ptr == NULL) ERROR("lefins_dequeue : ptr NULL"); + if (ptr->left == ptr->right && !isempty_dequeue(ptr)) { + grow_dequeue(ptr); + } + ptr->left = (ptr->left - 1 + ptr->size_array) % ptr->size_array; + ptr->array[ptr->left] = val; + ptr->empty = false; + return; +} + +void rigins_dequeue(uint val, dequeue *ptr) { + if (ptr == NULL) ERROR("rigins_dequeue : ptr NULL"); + if (ptr->left == ptr->right && !isempty_dequeue(ptr)) { + grow_dequeue(ptr); + } + ptr->array[ptr->right] = val; + ptr->right = (ptr->right + 1) % ptr->size_array; + ptr->empty = false; + return; +} + +static void shrink_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("shrink_dequeue : ptr NULL"); + uint *aux = malloc((ptr->size_array / 2) * sizeof(uint)); + for (uint i = 0; i < size_dequeue(ptr); i++) { + aux[i] = ptr->array[(ptr->left + i) % ptr->size_array]; + } + free(ptr->array); + ptr->array = aux; + ptr->left = 0; + ptr->size_array = ptr->size_array / 2; + ptr->right = size_dequeue(ptr); + return; +} + +/* Retirer */ +uint lefpull_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("lefpull_dequeue : ptr NULL"); + if (isempty_dequeue(ptr)) ERROR("lefpull_dequeue : ptr empty"); + int val = ptr->array[ptr->left]; + ptr->left = (ptr->left + 1) % ptr->size_array; + if (size_dequeue(ptr) <= ptr->size_array / 4 && ptr->size_array > 1) { + shrink_dequeue(ptr); + } + if (ptr->left == ptr->right) ptr->empty = true; + return val; +} + +uint rigpull_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("rigpull_dequeue : ptr NULL"); + if (isempty_dequeue(ptr)) ERROR("rigpull_dequeue : ptr empty"); + ptr->right = (ptr->right - 1) % ptr->size_array; + int val = ptr->array[ptr->right]; + if (size_dequeue(ptr) <= ptr->size_array / 4 && ptr->size_array > 1) { + shrink_dequeue(ptr); + } + if (ptr->left == ptr->right) ptr->empty = true; + return val; +} + +/* Création d'une copie avec décalage */ +void copy_dequeue_right(dequeue *ptr1, dequeue *ptr2, uint val) { + if (ptr1 == NULL || ptr2 == NULL) ERROR("copy_dequeue_right : ptr NULL"); + if (isempty_dequeue(ptr2)) ERROR("copy_dequeue_right : ptr2 empty"); + for (uint i = 0; i < size_dequeue(ptr2); i++) { + lefread_dequeue(ptr2, i); + rigins_dequeue(lefread_dequeue(ptr2, i) + val, ptr1); + } + return; +} + +/* Teste si un élément appartient à une dequeue*/ +bool mem_dequeue(uint val, dequeue *ptr) { + if (ptr == NULL) ERROR("mem_dequeue : ptr NULL"); + for (uint i = 0; i < size_dequeue(ptr); i++) { + if (val == lefread_dequeue(ptr, i)) return true; + } + return false; +} + +/* Affichage */ +void print_dequeue(dequeue *ptr) { + if (ptr == NULL) ERROR("print_dequeue : ptr NULL"); + printf("Deque : "); + for (uint i = 0; i < size_dequeue(ptr); i++) { + printf("%d ", lefread_dequeue(ptr, i)); + } + printf("\n"); + return; +} + +/* Tri par ordre croissant et suppression des doublons */ +void sort_dequeue_norepeat(dequeue *ptr) { + if (ptr == NULL) ERROR("sort_dequeue_norepeat : ptr NULL"); + if (isempty_dequeue(ptr)) return; + if (size_dequeue(ptr) == 1) return; + for (uint i = 0; i < size_dequeue(ptr); i++) { + for (uint j = i + 1; j < size_dequeue(ptr); j++) { + if (lefread_dequeue(ptr, i) > lefread_dequeue(ptr, j)) { + int temp = lefread_dequeue(ptr, i); + ptr->array[(ptr->left + i) % ptr->size_array] = + lefread_dequeue(ptr, j); + ptr->array[(ptr->left + j) % ptr->size_array] = temp; + } + } + } + uint i; + for (i = 0; i < size_dequeue(ptr) && + lefread_dequeue(ptr, i) != rigread_dequeue(ptr, 0); + i++) { + uint count = 0; + while (i + count < size_dequeue(ptr) && + lefread_dequeue(ptr, i) == lefread_dequeue(ptr, i + count)) { + count++; + } + for (uint j = 1; j < count; j++) { + for (uint k = i; k < size_dequeue(ptr) - 1; k++) { + ptr->array[(ptr->left + k) % ptr->size_array] = + lefread_dequeue(ptr, k + 1); + } + } + } + ptr->right = (ptr->right - (size_dequeue(ptr) - i - 1)) % ptr->size_array; + return; +} + +/*****************************************************************/ +/* Fonctions spécifiques aux ensembles triés par ordre croissant */ +/*****************************************************************/ + +bool mem_dequeue_sorted(uint val, dequeue *ptr) { + if (ptr == NULL) ERROR("mem_dequeue_sorted : ptr NULL"); + if (isempty_dequeue(ptr)) return false; + int left = 0; + int right = size_dequeue(ptr) - 1; + while (left <= right) { + int mid = (left + right) / 2; + if (lefread_dequeue(ptr, mid) == val) return true; + if (lefread_dequeue(ptr, mid) < val) { + left = mid + 1; + } else { + right = mid - 1; + } + } + return false; +} + +void merge_sorted_dequeue(dequeue *ptr1, dequeue *ptr2) { + if (ptr1 == NULL || ptr2 == NULL) ERROR("merge_sorted_dequeue : ptr NULL"); + if (isempty_dequeue(ptr2)) return; + if (isempty_dequeue(ptr1)) { + copy_dequeue_right(ptr1, ptr2, 0); + return; + } + uint i = 0; + uint j = 0; + dequeue *temp = create_dequeue(); + while (i < size_dequeue(ptr1) && j < size_dequeue(ptr2)) { + if (lefread_dequeue(ptr1, i) <= lefread_dequeue(ptr2, j)) { + rigins_dequeue(lefread_dequeue(ptr1, i), temp); + i++; + } else { + rigins_dequeue(lefread_dequeue(ptr2, j), temp); + j++; + } + } + while (i < size_dequeue(ptr1)) { + rigins_dequeue(lefread_dequeue(ptr1, i), temp); + i++; + } + while (j < size_dequeue(ptr2)) { + rigins_dequeue(lefread_dequeue(ptr2, j), temp); + j++; + } + makeempty_dequeue(ptr1); + copy_dequeue_right(ptr1, temp, 0); + if (temp == NULL) delete_dequeue(temp); + for (i = 0; i < size_dequeue(ptr1) && + lefread_dequeue(ptr1, i) != rigread_dequeue(ptr1, 0); + i++) { + uint count = 0; + while (i + count < size_dequeue(ptr1) && + lefread_dequeue(ptr1, i) == lefread_dequeue(ptr1, i + count)) { + count++; + } + for (j = 1; j < count; j++) { + for (uint k = i; k < size_dequeue(ptr1) - 1; k++) { + ptr1->array[(ptr1->left + k) % ptr1->size_array] = + lefread_dequeue(ptr1, k + 1); + } + } + } + ptr1->right = + (ptr1->right - (size_dequeue(ptr1) - i - 1)) % ptr1->size_array; + return; +} + +dequeue *make_inter_sorted_dequeue(dequeue *ptr1, dequeue *ptr2) { + if (ptr1 == NULL || ptr2 == NULL) + ERROR("make_inter_sorted_dequeue : ptr NULL"); + dequeue *ptr = create_dequeue(); + for (uint i = 0; i < size_dequeue(ptr1); i++) { + if (mem_dequeue_sorted(lefread_dequeue(ptr1, i), ptr2)) { + rigins_dequeue(lefread_dequeue(ptr1, i), ptr); + } + } + return ptr; +} + +/* Insére un nouveau sommet dans une liste */ +void insert_dequeue(dequeue *ptr, uint val) { + if (ptr == NULL) ERROR("insert_dequeue : ptr NULL"); + if (mem_dequeue_sorted(val, ptr)) return; + dequeue *temp = create_dequeue(); + rigins_dequeue(val, temp); + merge_sorted_dequeue(ptr, temp); +} + +/* Teste si deux dequeues triées s'intersectent */ +bool intersec_dequeue(dequeue *ptr1, dequeue *ptr2) { + if (ptr1 == NULL || ptr2 == NULL) ERROR("intersec_dequeue : ptr NULL"); + if (isempty_dequeue(ptr1) || isempty_dequeue(ptr2)) return false; + for (uint i = 0; i < size_dequeue(ptr1); i++) { + if (mem_dequeue_sorted(lefread_dequeue(ptr1, i), ptr2)) { + return true; + } + } + return false; +}