From 0a9337e675ee73579f23b5ae47feabd9ae97c7b3 Mon Sep 17 00:00:00 2001 From: fanasina Date: Mon, 17 Jul 2023 00:35:57 +0200 Subject: [PATCH] first test isgood --- isgood | Bin 0 -> 42112 bytes src/permutation_t/permutation_t.c | 205 +++++++++++++++--------------- src/permutation_t/permutation_t.h | 69 +++++----- src/set_theoric_t/set_theoric_t.c | 26 ++-- src/set_theoric_t/set_theoric_t.h | 26 ++-- src/test_t/is_good.c | 13 ++ src/tools_t/tools_t.c | 130 ++++++++----------- src/tools_t/tools_t.h | 87 ++++--------- testool_t | Bin 0 -> 26680 bytes 9 files changed, 242 insertions(+), 314 deletions(-) create mode 100644 isgood create mode 100644 src/test_t/is_good.c create mode 100644 testool_t diff --git a/isgood b/isgood new file mode 100644 index 0000000000000000000000000000000000000000..51e3be2e9840d59e0466d43bcd1a53a16e6740cb GIT binary patch literal 42112 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 xI}9JCkBYz8{x)=%9Psize;\ + type j;\ + size_t *count_array_i = calloc(size, sizeof(size_t));\ + if(count_array_i == NULL){\ + printf("can't alloc count_array_i\n"); return false;}\ + for(size_t i = 0; i < size; ++i){\ + j = p->perm[i];\ + if((COMPARE_N_##type(&j, (type*)&size) >= 0) || count_array_i[j]){\ + free(count_array_i); return false; }\ + ++count_array_i[j];}\ + free(count_array_i);\ + return true; }\ + +GENERATE_PERMUTATION_FUNCTIONS_UNSIGNED(TYPE_U_CHAR) +GENERATE_PERMUTATION_FUNCTIONS_UNSIGNED(TYPE_U_INT) +GENERATE_PERMUTATION_FUNCTIONS_UNSIGNED(TYPE_U_L_INT) +GENERATE_PERMUTATION_FUNCTIONS_UNSIGNED(TYPE_SIZE_T) + + +#define GENERATE_PERMUTATION_FUNCTIONS(type)\ + PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size){\ + if (size == 0) return NULL;\ PERMUTATION_##type *p = malloc(sizeof(PERMUTATION_##type));\ p->size = size;\ p->perm = malloc(size * sizeof(type));\ return p; }\ +\ + PERMUTATION_TYPE_SIZE_T * TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(PERMUTATION_##type *p ){\ + if (p == NULL) return NULL;\ + PERMUTATION_TYPE_SIZE_T *t_p = malloc(sizeof(PERMUTATION_TYPE_SIZE_T));\ + size_t size = p->size;\ + t_p->perm = malloc(size * sizeof(TYPE_SIZE_T));\ + type *sorted_perm = malloc(size * sizeof(type));\ + COPY_ARRAY_##type(sorted_perm, p->perm, size);\ + qsort(sorted_perm, size, sizeof(type), COMPARE_N_##type);\ + size_t *rec_index_visited = malloc(size * sizeof(size_t));\ + size_t cur_rec = 0; bool found_rec;\ + for(size_t i = 0; i < size; ++i){\ + for(size_t j = 0; j < size; ++j){\ + if(COMPARE_N_##type(&(p->perm[j]), &(sorted_perm[i])) == 0){\ + found_rec = false;\ + for(size_t k = 0; k < cur_rec; ++k){\ + if(rec_index_visited[k] == j){\ + found_rec == true; break; } } \ + if(found_rec == false){\ + t_p->perm[i] = j;\ + rec_index_visited[cur_rec++] = j; \ + break; } } } } \ + free(rec_index_visited);\ + free(sorted_perm);\ + return t_p; }\ +\ + bool IS_PERMUTATION_##type(const PERMUTATION_##type *p){\ + if(p == NULL) return false;\ + PERMUTATION_TYPE_SIZE_T *t_p = TRANSLATE_TO_SET_THEORIC_SIZE_T_##type(p);\ + bool ret = IS_PERMUTATION_SET_THEORIC_TYPE_SIZE_T(t_p);\ + free(t_p);\ + return ret; }\ -permutation* -create_permutation(size_t sz) -{ - if(sz == 0) return NULL; - permutation *p=malloc(sizeof(permutation)); - p->size = sz; - p->perm = malloc(sz*sizeof(unsigned int)); - return p; -} -/*void -copy_array_unsigned(unsigned int *dst, const unsigned int *src, size_t size) -{ - for(size_t i = 0; i < size ; ++i) - dst[i]=src[i]; -}*/ -void -assign_permutation(permutation *p, unsigned int *arr) -{ - copy_array_unsigned(p->perm, arr, p->size); -} +GENERATE_PERMUTATION_FUNCTIONS(TYPE_CHAR) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_U_CHAR) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_INT) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_U_INT) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_L_INT) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_U_L_INT) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_SIZE_T) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_FLOAT) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_DOUBLE) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_L_DOUBLE) +GENERATE_PERMUTATION_FUNCTIONS(TYPE_STRING) -bool -is_permutation_set_theoric(const permutation *p) -{ - if(p==NULL) return false; - size_t size = p->size, j; - unsigned int *count_array_i = calloc(size, sizeof(unsigned int)); - if(count_array_i == NULL) - { - printf("can't allocate count_array_i\n"); - return false; - } - for(size_t i = 0; i < size; ++i) - { - j = p->perm[i]; - if((j >= size) || count_array_i[j]) - { - free(count_array_i); - return false; - } - count_array_i[j]++; - } - return true; -} -/* 2,7,4,1 is a permutation of 1,2,4,7 + + + + + +/* why TRANSLATE ? + * 2,7,4,1 is a permutation of 1,2,4,7 *it is equivalent of 1,3,2,0 in set_theoric(4)=0,1,2,3 this function calculate the permutation equivalent in set_theoric + 2,4,2,5 is translate to 0,1,0,2 * */ -permutation * -translate_set_theoric(const permutation *p, permutation *translate_p) -{ - if(p==NULL) return NULL; - size_t size = p->size; - permutation *translate_p = create_permutation(size); - unsigned int *temperm = malloc(size*sizeof(unsigned int)); - unsigned int *tmperm = malloc(size*sizeof(unsigned int)); - copy_array_unsigned_int(tmperm, p->perm, p->size); // copy - qsort(tmperm, size, sizeof(unsigned int), compare_unsigned_int); - // tmperm contain p->perm ordered - size_t cur=0; - for(size_t i=0; i< size; ++i) - { - for(size_t j=0; jperm[j] == tmperm[i]) - { - bool found = false; - for(size_t c=0; cperm[i]=j; - temperm[cur++]=j; - break; - } - } - } - } - free(tmperm); - free(temperm); - return translate_p; -} - -bool -is_permutation(const permutation *p) -{ - bool ret = is_permutation_set_theoric(p); - if(ret == false) - { - permutation *t_p = translate_set_theoric(p); - ret = is_permutation_set_theoric(t_p); - free(t_p); - } - return ret; -} + +/* if need optimization in translate +#define GENERATE_UNSIGNED_SIZE_WITH_TYPED(type_unsigned, type)\ + PERMUTATION_##type_unsigned * TRANSLATE_TO_SET_THEORIC_##type_unsigned_##type(PERMUTATION_##type *p ){\ + if (p == NULL) return NULL;\ + PERMUTATION_##type_unsigned *t_p = malloc(sizeof(PERMUTATION_##type_unsigned));\ + type_unsigned size = p->size;\ + t_p->perm = malloc(size * sizeof(type_unsigned));\ + type *sorted_perm = malloc(size * sizeof(type));\ + COPY_ARRAY_##type(sorted_perm, p->perm, size);\ + qsort(sorted_perm, size, sizeof(type), COMPARE_N_##type);\ + type_unsigned *rec_index_visited = malloc(size * sizeof(type_unsigned));\ + type_unsigned cur_rec = 0; bool found_rec;\ + for(type_unsigned i = 0; i < size; ++i){\ + for(type_unsigned j = 0; j < size; ++j){\ + if(COMPARE_N_##type(&(p->perm[j]), &(sorted_perm[i])) == 0){\ + found_rec = false;\ + for(type_unsigned k = 0; k < cur_rec; ++k){\ + if(rec_index_visited[k] == j){\ + found_rec == true; break; } } \ + if(found_rec == false){\ + t_p->perm[i] = j;\ + rec_index_visited[cur++] = j; \ + break; } } } } \ + free(rec_index_visited);\ + free(sorted_perm);\ + return t_p; }\ + +*/ diff --git a/src/permutation_t/permutation_t.h b/src/permutation_t/permutation_t.h index 862b2e8..db4c7dd 100644 --- a/src/permutation_t/permutation_t.h +++ b/src/permutation_t/permutation_t.h @@ -4,49 +4,42 @@ #include "src/tools_t/tools_t.h" #include "src/set_theoric_t/set_theoric_t.h" -#define STRUCT_PERMUTATION(type)\ - struct PERMUTATION_##type{\ - size_t size;\ - type * perm; }; -STRUCT_PERMUTATION(TYPE_CHAR) -STRUCT_PERMUTATION(TYPE_U_CHAR) -STRUCT_PERMUTATION(TYPE_INT) -STRUCT_PERMUTATION(TYPE_U_INT) -STRUCT_PERMUTATION(TYPE_L_INT) -STRUCT_PERMUTATION(TYPE_U_L_INT) -STRUCT_PERMUTATION(TYPE_FLOAT) -STRUCT_PERMUTATION(TYPE_DOUBLE) -STRUCT_PERMUTATION(TYPE_L_DOUBLE) -STRUCT_PERMUTATION(TYPE_STRING) - -typedef struct PERMUTATION_TYPE_CHAR PERMUTATION_TYPE_CHAR; -typedef struct PERMUTATION_TYPE_U_CHAR PERMUTATION_TYPE_U_CHAR; -typedef struct PERMUTATION_TYPE_INT PERMUTATION_TYPE_INT; -typedef struct PERMUTATION_TYPE_U_INT PERMUTATION_TYPE_U_INT; -typedef struct PERMUTATION_TYPE_L_INT PERMUTATION_TYPE_L_INT; -typedef struct PERMUTATION_TYPE_U_L_INT PERMUTATION_TYPE_U_L_INT; -typedef struct PERMUTATION_TYPE_FLOAT PERMUTATION_TYPE_FLOAT; -typedef struct PERMUTATION_TYPE_DOUBLE PERMUTATION_TYPE_DOUBLE; -typedef struct PERMUTATION_TYPE_L_DOUBLE PERMUTATION_TYPE_L_DOUBLE; -typedef struct PERMUTATION_TYPE_STRING PERMUTATION_TYPE_STRING; - -/* struct of permutation of unsigned int array, not necessarly set_theoric +/* struct of permutation, not necessarly set_theoric * * */ -struct permutation -{ - size_t size; - unsigned int *perm; -}; -typedef struct permutation permutation; -permutation * create_permutation(size_t sz); -void assign_permutation(permutation *p, unsigned int *arr); -bool is_permutation_set_theoric(const permutation *p); +#define GENERATE_PERMUTATION(type)\ + struct PERMUTATION_##type{\ + size_t size;\ + type * perm; };\ +\ + typedef struct PERMUTATION_##type PERMUTATION_##type;\ + PERMUTATION_##type * CREATE_PERMUTATION_##type(size_t size);\ + + + +GENERATE_PERMUTATION(TYPE_CHAR) +GENERATE_PERMUTATION(TYPE_U_CHAR) +GENERATE_PERMUTATION(TYPE_INT) +GENERATE_PERMUTATION(TYPE_U_INT) +GENERATE_PERMUTATION(TYPE_L_INT) +GENERATE_PERMUTATION(TYPE_U_L_INT) +GENERATE_PERMUTATION(TYPE_SIZE_T) +GENERATE_PERMUTATION(TYPE_FLOAT) +GENERATE_PERMUTATION(TYPE_DOUBLE) +GENERATE_PERMUTATION(TYPE_L_DOUBLE) +GENERATE_PERMUTATION(TYPE_STRING) + +#define GENERATE_FUNCTIONS_UNSIGNED(type)\ + bool IS_PERMUTATION_SET_THEORIC_##type(const PERMUTATION_##type *p);\ + +GENERATE_FUNCTIONS_UNSIGNED(TYPE_U_CHAR) +GENERATE_FUNCTIONS_UNSIGNED(TYPE_U_INT) +GENERATE_FUNCTIONS_UNSIGNED(TYPE_U_L_INT) +GENERATE_FUNCTIONS_UNSIGNED(TYPE_SIZE_T) + -// more general! need translation and use is_permutation_set_theoric -bool is_permutation(const permutation *p); #endif /*__PERMUTATION_T_C_H__*/ diff --git a/src/set_theoric_t/set_theoric_t.c b/src/set_theoric_t/set_theoric_t.c index 6bab797..fd12aa4 100644 --- a/src/set_theoric_t/set_theoric_t.c +++ b/src/set_theoric_t/set_theoric_t.c @@ -1,24 +1,22 @@ #include "src/set_theoric_t/set_theoric_t.h" -#define CREATE_SET_THEORIC(type, id)\ - type * CREATE_SET_THEORIC_##type(type id){\ +#define GENERATE_UNSIGNED_SET_THEORIC(type)\ + SET_THEORIC_##type * CREATE_SET_THEORIC_##type(size_t id){\ if(id == 0) return NULL;\ SET_THEORIC_##type *ret_set = malloc(sizeof(SET_THEORIC_##type));\ ret_set->id = id;\ ret_set->set = malloc(id*sizeof(type));\ for(type i = 0; i < id; ++i) ret_set->set[i]=i;\ - return ret_set; } -CREATE_SET_THEORIC(TYPE_U_CHAR) -CREATE_SET_THEORIC(TYPE_U_INT) -CREATE_SET_THEORIC(TYPE_U_LONG_INT) + return ret_set; }\ +\ + bool IS_SET_THEORIC_##type(SET_THEORIC_##type *st){\ + for(type i = 0; i < st->id; ++i){\ + if(st->set[i] != i) return false;\ + return true; } }\ -#define IS_SET_THEORIC(type, st)\ - bool IS_SET_THEORIC_##type(type *st){\ - for(type i = 0; i < st->id; ++i){\ - if(st->set[i] != i) return false;\ - return true; } -IS_SET_THEORIC(TYPE_U_CHAR,st) -IS_SET_THEORIC(TYPE_U_INT,st) -IS_SET_THEORIC(TYPE_U_LONG_INT,st) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_CHAR) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_INT) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_L_INT) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_SIZE_T) diff --git a/src/set_theoric_t/set_theoric_t.h b/src/set_theoric_t/set_theoric_t.h index bcfbd29..47780e7 100644 --- a/src/set_theoric_t/set_theoric_t.h +++ b/src/set_theoric_t/set_theoric_t.h @@ -5,26 +5,18 @@ #include "src/tools_t/tools_t.h" -#define STRUCT_SET_THEORIC(type)\ +#define GENERATE_UNSIGNED_SET_THEORIC(type)\ struct SET_THEORIC_##type{\ type id;\ - type *set;}; + type *set;};\ + typedef struct SET_THEORIC_##type SET_THEORIC_##type; \ + SET_THEORIC_##type * CREATE_SET_THEORIC_##type(TYPE_##type);\ + bool IS_SET_THEORIC_##type(SET_THEORIC_##type *st);\ -STRUCT_SET_THEORIC(TYPE_U_CHAR) -STRUCT_SET_THEORIC(TYPE_U_INT) -STRUCT_SET_THEORIC(TYPE_U_LONG_INT) - -typedef struct SET_THEORIC_TYPE_U_CHAR SET_THEORIC_TYPE_U_CHAR; -typedef struct SET_THEORIC_TYPE_U_INT SET_THEORIC_TYPE_U_INT; -typedef struct SET_THEORIC_TYPE_U_LONG_INT SET_THEORIC_TYPE_U_LONG_INT; - -SET_THEORIC_TYPE_U_CHAR * CREATE_SET_THEORIC_TYPE_U_CHAR(TYPE_U_CHAR); -SET_THEORIC_TYPE_U_INT * CREATE_SET_THEORIC_TYPE_U_INT(TYPE_U_INT); -SET_THEORIC_TYPE_U_LONG_INT * CREATE_SET_THEORIC_TYPE_U_LONG_INT(TYPE_U_LONG_INT); - -bool IS_SET_THEORIC_TYPE_U_CHAR(SET_THEORIC_TYPE_U_CHAR *st); -bool IS_SET_THEORIC_TYPE_U_INT(SET_THEORIC_TYPE_U_INT *st); -bool IS_SET_THEORIC_TYPE_U_LONG_INT(SET_THEORIC_TYPE_U_LONG_INT *st); +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_CHAR) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_INT) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_U_L_INT) +GENERATE_UNSIGNED_SET_THEORIC(TYPE_SIZE_T) diff --git a/src/test_t/is_good.c b/src/test_t/is_good.c new file mode 100644 index 0000000..0f8527a --- /dev/null +++ b/src/test_t/is_good.c @@ -0,0 +1,13 @@ +#include +#include + +#include "src/permutation_t/permutation_t.h" + + +int main(){ + PERMUTATION_TYPE_CHAR *p = CREATE_PERMUTATION_TYPE_CHAR(3); + + printf(" size = %u \n",p->size); + + return 0; +} diff --git a/src/tools_t/tools_t.c b/src/tools_t/tools_t.c index f0732cc..0f980ff 100644 --- a/src/tools_t/tools_t.c +++ b/src/tools_t/tools_t.c @@ -1,117 +1,86 @@ #include "src/tools_t/tools_t.h" -#define COMPARE_N(type,a,b)\ + +#define GENERATE_FUNCTION_NUMERIC(type)\ int COMPARE_N_##type(const void *a, const void *b){ \ if (*(type*)a == *(type*)b) return 0; \ if (*(type*)a > *(type*)b) return 1; \ - return -1; } + return -1; }\ + \ + void COPY_ARRAY_##type(type *dst, const type *src, size_t size){\ + for(size_t i = 0; i < size; ++i) dst[i]=src[i]; }\ +\ -COMPARE_N(TYPE_CHAR,a,b) -COMPARE_N(TYPE_U_CHAR,a,b) -COMPARE_N(TYPE_INT,a,b) -COMPARE_N(TYPE_U_INT,a,b) -COMPARE_N(TYPE_L_INT,a,b) -COMPARE_N(TYPE_U_L_INT,a,b) -COMPARE_N(TYPE_FLOAT,a,b) -COMPARE_N(TYPE_DOUBLE,a,b) -COMPARE_N(TYPE_L_DOUBLE,a,b) int COMPARE_N_TYPE_STRING(const void *a,const void* b) { return strcmp(( char*)a,( char*)b); } -#define COPY_ARRAY(type, dst, src, size)\ - void COPY_ARRAY_##type(type *dst, const type *src, size_t size){\ - for(size_t i = 0; i < size; ++i) dst[i]=src[i]; } - -COPY_ARRAY(TYPE_CHAR,dst,src,size); -COPY_ARRAY(TYPE_U_CHAR,dst,src,size); -COPY_ARRAY(TYPE_INT,dst,src,size); -COPY_ARRAY(TYPE_U_INT,dst,src,size); -COPY_ARRAY(TYPE_L_INT,dst,src,size); -COPY_ARRAY(TYPE_U_L_INT,dst,src,size); -COPY_ARRAY(TYPE_FLOAT,dst,src,size); -COPY_ARRAY(TYPE_DOUBLE,dst,src,size); -COPY_ARRAY(TYPE_L_DOUBLE,dst,src,size); void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size) { for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]); } -#define MAX_ARRAY(type, array, size, compare)\ + +GENERATE_FUNCTION_NUMERIC(TYPE_CHAR) +GENERATE_FUNCTION_NUMERIC(TYPE_U_CHAR) +GENERATE_FUNCTION_NUMERIC(TYPE_INT) +GENERATE_FUNCTION_NUMERIC(TYPE_U_INT) +GENERATE_FUNCTION_NUMERIC(TYPE_L_INT) +GENERATE_FUNCTION_NUMERIC(TYPE_U_L_INT) +GENERATE_FUNCTION_NUMERIC(TYPE_SIZE_T) +GENERATE_FUNCTION_NUMERIC(TYPE_FLOAT) +GENERATE_FUNCTION_NUMERIC(TYPE_DOUBLE) +GENERATE_FUNCTION_NUMERIC(TYPE_L_DOUBLE) + +#define GENERATE_FUNCTION_ALL(type)\ type MAX_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ type mx =(type)array[0];\ for(size_t i = 0; i < size; ++i)\ - if(compare(&mx,&array[i]) < 0) mx =(type)array[i];\ - return mx;} -MAX_ARRAY(TYPE_CHAR,array,size,COMPARE_N_TYPE_CHAR); -MAX_ARRAY(TYPE_U_CHAR,array,size,COMPARE_N_TYPE_U_CHAR); -MAX_ARRAY(TYPE_INT,array,size,COMPARE_N_TYPE_INT); -MAX_ARRAY(TYPE_U_INT,array,size,COMPARE_N_TYPE_U_INT); -MAX_ARRAY(TYPE_L_INT,array,size,COMPARE_N_TYPE_L_INT); -MAX_ARRAY(TYPE_U_L_INT,array,size,COMPARE_N_TYPE_U_L_INT); -MAX_ARRAY(TYPE_FLOAT,array,size,COMPARE_N_TYPE_FLOAT); -MAX_ARRAY(TYPE_DOUBLE,array,size,COMPARE_N_TYPE_DOUBLE); -MAX_ARRAY(TYPE_L_DOUBLE,array,size,COMPARE_N_TYPE_L_DOUBLE); -MAX_ARRAY(TYPE_STRING,array,size,COMPARE_N_TYPE_STRING); - -#define ARG_MAX_ARRAY(type, array, size, compare)\ + if(COMPARE_N_##type(&mx,&array[i]) < 0) mx =(type)array[i];\ + return mx;}\ +\ size_t ARG_MAX_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ size_t i_mx = 0;\ for(size_t i = 0; i < size; ++i)\ - if(compare(&array[i_mx],&array[i]) < 0) i_mx = i;\ - return i_mx;} -ARG_MAX_ARRAY(TYPE_CHAR,array,size,COMPARE_N_TYPE_CHAR); -ARG_MAX_ARRAY(TYPE_U_CHAR,array,size,COMPARE_N_TYPE_U_CHAR); -ARG_MAX_ARRAY(TYPE_INT,array,size,COMPARE_N_TYPE_INT); -ARG_MAX_ARRAY(TYPE_U_INT,array,size,COMPARE_N_TYPE_U_INT); -ARG_MAX_ARRAY(TYPE_L_INT,array,size,COMPARE_N_TYPE_L_INT); -ARG_MAX_ARRAY(TYPE_U_L_INT,array,size,COMPARE_N_TYPE_U_L_INT); -ARG_MAX_ARRAY(TYPE_FLOAT,array,size,COMPARE_N_TYPE_FLOAT); -ARG_MAX_ARRAY(TYPE_DOUBLE,array,size,COMPARE_N_TYPE_DOUBLE); -ARG_MAX_ARRAY(TYPE_L_DOUBLE,array,size,COMPARE_N_TYPE_L_DOUBLE); -ARG_MAX_ARRAY(TYPE_STRING,array,size,COMPARE_N_TYPE_STRING); - -#define MIN_ARRAY(type, array, size, compare)\ + if(COMPARE_N_##type(&array[i_mx],&array[i]) < 0) i_mx = i;\ + return i_mx;}\ +\ type MIN_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ type mn =(type)array[0];\ for(size_t i = 0; i < size; ++i)\ - if(compare(&mn,&array[i]) > 0) mn =(type)array[i];\ - return mn;} -MIN_ARRAY(TYPE_CHAR,array,size,COMPARE_N_TYPE_CHAR); -MIN_ARRAY(TYPE_U_CHAR,array,size,COMPARE_N_TYPE_U_CHAR); -MIN_ARRAY(TYPE_INT,array,size,COMPARE_N_TYPE_INT); -MIN_ARRAY(TYPE_U_INT,array,size,COMPARE_N_TYPE_U_INT); -MIN_ARRAY(TYPE_L_INT,array,size,COMPARE_N_TYPE_L_INT); -MIN_ARRAY(TYPE_U_L_INT,array,size,COMPARE_N_TYPE_U_L_INT); -MIN_ARRAY(TYPE_FLOAT,array,size,COMPARE_N_TYPE_FLOAT); -MIN_ARRAY(TYPE_DOUBLE,array,size,COMPARE_N_TYPE_DOUBLE); -MIN_ARRAY(TYPE_L_DOUBLE,array,size,COMPARE_N_TYPE_L_DOUBLE); -MIN_ARRAY(TYPE_STRING,array,size,COMPARE_N_TYPE_STRING); - -#define ARG_MIN_ARRAY(type, array, size, compare)\ + if(COMPARE_N_##type(&mn,&array[i]) > 0) mn =(type)array[i];\ + return mn;}\ +\ size_t ARG_MIN_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ size_t i_mn = 0;\ for(size_t i = 0; i < size; ++i)\ - if(compare(&array[i_mn],&array[i]) > 0) i_mn = i;\ - return i_mn;} -ARG_MIN_ARRAY(TYPE_CHAR,array,size,COMPARE_N_TYPE_CHAR); -ARG_MIN_ARRAY(TYPE_U_CHAR,array,size,COMPARE_N_TYPE_U_CHAR); -ARG_MIN_ARRAY(TYPE_INT,array,size,COMPARE_N_TYPE_INT); -ARG_MIN_ARRAY(TYPE_U_INT,array,size,COMPARE_N_TYPE_U_INT); -ARG_MIN_ARRAY(TYPE_L_INT,array,size,COMPARE_N_TYPE_L_INT); -ARG_MIN_ARRAY(TYPE_U_L_INT,array,size,COMPARE_N_TYPE_U_L_INT); -ARG_MIN_ARRAY(TYPE_FLOAT,array,size,COMPARE_N_TYPE_FLOAT); -ARG_MIN_ARRAY(TYPE_DOUBLE,array,size,COMPARE_N_TYPE_DOUBLE); -ARG_MIN_ARRAY(TYPE_L_DOUBLE,array,size,COMPARE_N_TYPE_L_DOUBLE); -ARG_MIN_ARRAY(TYPE_STRING,array,size,COMPARE_N_TYPE_STRING); + if(COMPARE_N_##type(&array[i_mn],&array[i]) > 0) i_mn = i;\ + return i_mn;}\ +\ +GENERATE_FUNCTION_ALL(TYPE_CHAR) +GENERATE_FUNCTION_ALL(TYPE_U_CHAR) +GENERATE_FUNCTION_ALL(TYPE_INT) +GENERATE_FUNCTION_ALL(TYPE_U_INT) +GENERATE_FUNCTION_ALL(TYPE_L_INT) +GENERATE_FUNCTION_ALL(TYPE_U_L_INT) +GENERATE_FUNCTION_ALL(TYPE_SIZE_T) +GENERATE_FUNCTION_ALL(TYPE_FLOAT) +GENERATE_FUNCTION_ALL(TYPE_DOUBLE) +GENERATE_FUNCTION_ALL(TYPE_L_DOUBLE) +GENERATE_FUNCTION_ALL(TYPE_STRING) + + + + +/* int main() { unsigned int ui1 = 2545466; @@ -134,4 +103,5 @@ int main() printf("MIN = %d \n",MIN_ARRAY_TYPE_INT(tabr,6)); return 0; -} +}*/ + diff --git a/src/tools_t/tools_t.h b/src/tools_t/tools_t.h index ac0959b..5736307 100644 --- a/src/tools_t/tools_t.h +++ b/src/tools_t/tools_t.h @@ -4,6 +4,7 @@ #include #include #include +#include #define TYPE_CHAR char #define TYPE_U_CHAR unsigned char @@ -11,6 +12,7 @@ #define TYPE_U_INT unsigned int #define TYPE_L_INT long int #define TYPE_U_L_INT unsigned long int +#define TYPE_SIZE_T size_t #define TYPE_FLOAT float #define TYPE_DOUBLE double #define TYPE_L_DOUBLE long double @@ -22,71 +24,26 @@ for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]); -int COMPARE_N_TYPE_CHAR(const void *,const void*); -int COMPARE_N_TYPE_U_CHAR(const void *,const void*); -int COMPARE_N_TYPE_INT(const void *,const void*); -int COMPARE_N_TYPE_U_INT(const void *,const void*); -int COMPARE_N_TYPE_L_INT(const void *,const void*); -int COMPARE_N_TYPE_U_L_INT(const void *,const void*); -int COMPARE_N_TYPE_FLOAT(const void *,const void*); -int COMPARE_N_TYPE_DOUBLE(const void *,const void*); -int COMPARE_N_TYPE_L_DOUBLE(const void *,const void*); -int COMPARE_N_TYPE_STRING(const void *,const void*); - -void COPY_ARRAY_TYPE_CHAR(TYPE_CHAR* dst, const TYPE_CHAR* src, size_t size); -void COPY_ARRAY_TYPE_U_CHAR(TYPE_U_CHAR* dst, const TYPE_U_CHAR* src, size_t size); -void COPY_ARRAY_TYPE_INT(TYPE_INT* dst, const TYPE_INT* src, size_t size); -void COPY_ARRAY_TYPE_U_INT(TYPE_U_INT* dst, const TYPE_U_INT* src, size_t size); -void COPY_ARRAY_TYPE_L_INT(TYPE_L_INT* dst, const TYPE_L_INT* src, size_t size); -void COPY_ARRAY_TYPE_U_L_INT(TYPE_U_L_INT* dst, const TYPE_U_L_INT* src, size_t size); -void COPY_ARRAY_TYPE_FLOAT(TYPE_FLOAT* dst, const TYPE_FLOAT* src, size_t size); -void COPY_ARRAY_TYPE_DOUBLE(TYPE_DOUBLE* dst, const TYPE_DOUBLE* src, size_t size); -void COPY_ARRAY_TYPE_L_DOUBLE(TYPE_L_DOUBLE* dst, const TYPE_L_DOUBLE* src, size_t size); -void COPY_ARRAY_TYPE_STRING(TYPE_STRING* dst, const TYPE_STRING* src, size_t size); - -TYPE_CHAR MAX_ARRAY_TYPE_CHAR(const TYPE_CHAR *array, size_t size); -TYPE_U_CHAR MAX_ARRAY_TYPE_U_CHAR(const TYPE_U_CHAR *array, size_t size); -TYPE_INT MAX_ARRAY_TYPE_INT(const TYPE_INT *array, size_t size); -TYPE_U_INT MAX_ARRAY_TYPE_U_INT(const TYPE_U_INT *array, size_t size); -TYPE_L_INT MAX_ARRAY_TYPE_L_INT(const TYPE_L_INT *array, size_t size); -TYPE_U_L_INT MAX_ARRAY_TYPE_U_L_INT(const TYPE_U_L_INT *array, size_t size); -TYPE_FLOAT MAX_ARRAY_TYPE_FLOAT(const TYPE_FLOAT *array, size_t size); -TYPE_DOUBLE MAX_ARRAY_TYPE_DOUBLE(const TYPE_DOUBLE *array, size_t size); -TYPE_L_DOUBLE MAX_ARRAY_TYPE_L_DOUBLE(const TYPE_L_DOUBLE *array, size_t size); -TYPE_STRING MAX_ARRAY_TYPE_STRING(const TYPE_STRING *array, size_t size); - -size_t ARG_MAX_ARRAY_TYPE_CHAR(const TYPE_CHAR *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_U_CHAR(const TYPE_U_CHAR *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_INT(const TYPE_INT *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_U_INT(const TYPE_U_INT *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_L_INT(const TYPE_L_INT *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_U_L_INT(const TYPE_U_L_INT *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_FLOAT(const TYPE_FLOAT *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_DOUBLE(const TYPE_DOUBLE *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_L_DOUBLE(const TYPE_L_DOUBLE *array, size_t size); -size_t ARG_MAX_ARRAY_TYPE_STRING(const TYPE_STRING *array, size_t size); - -TYPE_CHAR MIN_ARRAY_TYPE_CHAR(const TYPE_CHAR *array, size_t size); -TYPE_U_CHAR MIN_ARRAY_TYPE_U_CHAR(const TYPE_U_CHAR *array, size_t size); -TYPE_INT MIN_ARRAY_TYPE_INT(const TYPE_INT *array, size_t size); -TYPE_U_INT MIN_ARRAY_TYPE_U_INT(const TYPE_U_INT *array, size_t size); -TYPE_L_INT MIN_ARRAY_TYPE_L_INT(const TYPE_L_INT *array, size_t size); -TYPE_U_L_INT MIN_ARRAY_TYPE_U_L_INT(const TYPE_U_L_INT *array, size_t size); -TYPE_FLOAT MIN_ARRAY_TYPE_FLOAT(const TYPE_FLOAT *array, size_t size); -TYPE_DOUBLE MIN_ARRAY_TYPE_DOUBLE(const TYPE_DOUBLE *array, size_t size); -TYPE_L_DOUBLE MIN_ARRAY_TYPE_L_DOUBLE(const TYPE_L_DOUBLE *array, size_t size); -TYPE_STRING MIN_ARRAY_TYPE_STRING(const TYPE_STRING *array, size_t size); - -size_t ARG_MIN_ARRAY_TYPE_CHAR(const TYPE_CHAR *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_U_CHAR(const TYPE_U_CHAR *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_INT(const TYPE_INT *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_U_INT(const TYPE_U_INT *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_L_INT(const TYPE_L_INT *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_U_L_INT(const TYPE_U_L_INT *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_FLOAT(const TYPE_FLOAT *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_DOUBLE(const TYPE_DOUBLE *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_L_DOUBLE(const TYPE_L_DOUBLE *array, size_t size); -size_t ARG_MIN_ARRAY_TYPE_STRING(const TYPE_STRING *array, size_t size); +#define GENERATE_ALL(type)\ + int COMPARE_N_##type(const void *,const void*);\ + void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\ + type MAX_ARRAY_##type(const type *array, size_t size);\ + size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\ + type MIN_ARRAY_##type(const type *array, size_t size);\ + size_t ARG_MIN_ARRAY_##type(const type *array, size_t size);\ + +GENERATE_ALL(TYPE_CHAR) +GENERATE_ALL(TYPE_U_CHAR) +GENERATE_ALL(TYPE_INT) +GENERATE_ALL(TYPE_U_INT) +GENERATE_ALL(TYPE_L_INT) +GENERATE_ALL(TYPE_U_L_INT) +GENERATE_ALL(TYPE_SIZE_T) +GENERATE_ALL(TYPE_FLOAT) +GENERATE_ALL(TYPE_DOUBLE) +GENERATE_ALL(TYPE_L_DOUBLE) +GENERATE_ALL(TYPE_STRING) #endif /*__TOOLS_T_C_H__*/ + diff --git a/testool_t b/testool_t new file mode 100644 index 0000000000000000000000000000000000000000..4d1adc14e1916cdd6df8f6bc93c55b7542386d03 GIT binary patch literal 26680 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 literal 0 HcmV?d00001