diff --git a/isgood b/isgood new file mode 100644 index 0000000..51e3be2 Binary files /dev/null and b/isgood differ diff --git a/src/permutation_t/permutation_t.c b/src/permutation_t/permutation_t.c index 457e68b..4a6795b 100644 --- a/src/permutation_t/permutation_t.c +++ b/src/permutation_t/permutation_t.c @@ -1,114 +1,119 @@ #include "src/permutation_t/permutation_t.h" -#define CREATE_PERMUTATION(type, size)\ - type * CREATE_PERMUTATION_##type(size_t size){\ - if (sz == 0) return NULL;\ +#define GENERATE_PERMUTATION_FUNCTIONS_UNSIGNED(type)\ + bool IS_PERMUTATION_SET_THEORIC_##type(const PERMUTATION_##type *p){\ + if(p == NULL) return false;\ + size_t size = p->size;\ + 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 0000000..4d1adc1 Binary files /dev/null and b/testool_t differ