fanasina/y_project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first test isgood

Browse Source
This commit is contained in:
fanasina
2023-07-17 00:35:57 +02:00
parent b9bef119dc
commit 0a9337e675
9 changed files with 242 additions and 314 deletions
Download Patch File Download Diff File Expand all files Collapse all files
isgood
BIN
View File
Binary file not shown.
src/permutation_t/permutation_t.c
+105 -100
View File
@@ -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; j<size; ++j)
{
if(p->perm[j] == tmperm[i])
{
bool found = false;
for(size_t c=0; c<cur; ++c)
{
if(j==temperm[c])
{
found = true;
break;
}
}
if(found == false)
{
translate_p->perm[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; }\
*/
src/permutation_t/permutation_t.h
+31 -38
View File
@@ -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__*/
src/set_theoric_t/set_theoric_t.c
+12 -14
View File
@@ -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)
src/set_theoric_t/set_theoric_t.h
+9 -17
View File
@@ -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)
src/test_t/is_good.c
+13
View File
@@ -0,0 +1,13 @@
#include <stdio.h>
#include <stdlib.h>
#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;
}
src/tools_t/tools_t.c
+50 -80
View File
@@ -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;
}
}*/
src/tools_t/tools_t.h
+22 -65
View File
@@ -4,6 +4,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#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__*/
testool_t
BIN
View File
Binary file not shown.