790 lines
21 KiB
C
790 lines
21 KiB
C
#ifndef __TOOLS_T_C_H__
|
|
#define __TOOLS_T_C_H__
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <time.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
|
|
/* to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!*/
|
|
#ifndef DEBUG
|
|
#define DEBUG 0
|
|
#endif
|
|
|
|
|
|
/* F_OUT file (stream) to log*/
|
|
#ifndef F_OUT
|
|
#define F_OUT stdout
|
|
#endif
|
|
/* F_ERR file (stream) to log*/
|
|
#ifndef F_ERR
|
|
#define F_ERR stderr
|
|
#endif
|
|
|
|
/*
|
|
#ifndef SECOND
|
|
#define SECOND 0
|
|
#endif
|
|
#ifndef NANOSECOND
|
|
#define NANOSECOND 0
|
|
#endif
|
|
|
|
double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
|
|
double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
|
|
long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
|
|
*/
|
|
|
|
#if 1
|
|
|
|
extern long int PRECISION_TYPE_FLOAT ;
|
|
extern long int PRECISION_TYPE_DOUBLE ;
|
|
extern long int PRECISION_TYPE_L_DOUBLE ;
|
|
|
|
#endif
|
|
|
|
|
|
/*void get_cursor_position(int *col, int *rows);*/
|
|
|
|
#if DEBUG
|
|
|
|
#define debug_print(fmt, ...) \
|
|
do { /*if (DEBUG)*/ fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
|
|
__LINE__, __func__, __VA_ARGS__); } while (0)
|
|
|
|
#define PRINT_DEBUG_(fmt, ...) \
|
|
do { /*if (DEBUG)*/ fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
|
|
__LINE__, __func__, __VA_ARGS__); } while (0)
|
|
|
|
#else
|
|
#define debug_print(fmt, ...) {}
|
|
|
|
#define PRINT_DEBUG_(fmt, ...) {}
|
|
|
|
#endif
|
|
|
|
#define error_print(fmt, ...) \
|
|
fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
|
|
__LINE__, __func__, __VA_ARGS__);
|
|
|
|
#define PRINT_ERROR(fmt, ...) \
|
|
fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
|
|
__LINE__, __func__, __VA_ARGS__);
|
|
|
|
#define PRINT_LOC_T(fmt, ...) \
|
|
fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \
|
|
__LINE__, __func__, __VA_ARGS__);
|
|
|
|
|
|
|
|
#define TYPE_CHAR char
|
|
#define TYPE_U_CHAR unsigned char
|
|
#define TYPE_INT int
|
|
#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
|
|
#define TYPE_STRING char*
|
|
|
|
#define FREE(x) { free((x)); (x) = NULL;}
|
|
|
|
#define FOREACH(array, size, function)\
|
|
for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);
|
|
|
|
#define MIN(X, Y) (((Y) < (X)) ? (Y) : (X))
|
|
#define MAX(X, Y) (((Y) > (X)) ? (Y) : (X))
|
|
|
|
#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);\
|
|
TYPE_STRING type##_TO_STR(type var);\
|
|
|
|
|
|
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)
|
|
|
|
/* strto_type */
|
|
|
|
int strto_TYPE_INT(char *str, char **endptr);
|
|
unsigned int strto_TYPE_U_INT(char *str, char **endptr);
|
|
long int strto_TYPE_L_INT(char *str, char **endptr);
|
|
unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr);
|
|
size_t strto_TYPE_SIZE_T(char *str, char **endptr);
|
|
float strto_TYPE_FLOAT(char *str, char **endptr);
|
|
double strto_TYPE_DOUBLE(char *str, char **endptr);
|
|
long double strto_TYPE_L_DOUBLE(char *str, char **endptr);
|
|
|
|
/*
|
|
* time calucl
|
|
*/
|
|
double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
|
|
|
|
double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
|
|
|
|
long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
|
|
|
|
|
|
#endif /*__TOOLS_T_C_H__*/
|
|
|
|
|
|
|
|
#define IMPLEMENTATION_TOOLS()\
|
|
\
|
|
GEN_TO_STR_N(TYPE_CHAR,2,"%c")\
|
|
GEN_TO_STR_N(TYPE_U_CHAR,2,"%c")\
|
|
GEN_TO_STR_N(TYPE_INT,22,"%d")\
|
|
GEN_TO_STR_N(TYPE_U_INT,22,"%u")\
|
|
GEN_TO_STR_N(TYPE_L_INT,22,"%ld")\
|
|
GEN_TO_STR_N(TYPE_U_L_INT,22,"%lu")\
|
|
GEN_TO_STR_N(TYPE_SIZE_T,22,"%lu")\
|
|
GEN_TO_STR_N(TYPE_FLOAT,128,"%.10f")\
|
|
GEN_TO_STR_N(TYPE_DOUBLE,256,"%.30lf")\
|
|
GEN_TO_STR_N(TYPE_L_DOUBLE,256,"%.30Lf")\
|
|
\
|
|
TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){\
|
|
return var;\
|
|
}\
|
|
\
|
|
\
|
|
long int PRECISION_TYPE_CHAR = 1;\
|
|
long int PRECISION_TYPE_U_CHAR = 1;\
|
|
long int PRECISION_TYPE_INT = 1;\
|
|
long int PRECISION_TYPE_U_INT = 1;\
|
|
long int PRECISION_TYPE_L_INT = 1;\
|
|
long int PRECISION_TYPE_U_L_INT = 1;\
|
|
long int PRECISION_TYPE_SIZE_T = 1;\
|
|
\
|
|
long int PRECISION_TYPE_FLOAT = 100000000;\
|
|
long int PRECISION_TYPE_DOUBLE = 100000000000;\
|
|
long int PRECISION_TYPE_L_DOUBLE = 100000000000000;\
|
|
\
|
|
\
|
|
\
|
|
\
|
|
int \
|
|
COMPARE_N_TYPE_STRING(const void *a,const void* b)\
|
|
{\
|
|
char **aa=(char**)a;\
|
|
char **bb=(char**)b;\
|
|
PRINT_DEBUG_("a=%s, b=%s\n",*aa, *bb);\
|
|
return strcmp(*aa,*bb);\
|
|
}\
|
|
\
|
|
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]);\
|
|
}\
|
|
\
|
|
\
|
|
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)\
|
|
\
|
|
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)\
|
|
\
|
|
/* strto_type */\
|
|
\
|
|
int strto_TYPE_INT(char *str, char **endptr){ \
|
|
return (int)strtol(str,endptr,10);\
|
|
}\
|
|
unsigned int strto_TYPE_U_INT(char *str, char **endptr){ \
|
|
return (unsigned int)strtoul(str,endptr,10);\
|
|
}\
|
|
long int strto_TYPE_L_INT(char *str, char **endptr){\
|
|
return strtol(str,endptr,10);\
|
|
}\
|
|
unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr){\
|
|
return strtoul(str,endptr,10);\
|
|
}\
|
|
size_t strto_TYPE_SIZE_T(char *str, char **endptr){\
|
|
return strtoul(str,endptr,10);\
|
|
}\
|
|
float strto_TYPE_FLOAT(char *str, char **endptr){\
|
|
return strtof(str,endptr);\
|
|
}\
|
|
double strto_TYPE_DOUBLE(char *str, char **endptr){\
|
|
return strtod(str,endptr);\
|
|
}\
|
|
long double strto_TYPE_L_DOUBLE(char *str, char **endptr){\
|
|
return strtold(str,endptr);\
|
|
}\
|
|
\
|
|
\
|
|
/*\
|
|
* time section\
|
|
*/\
|
|
\
|
|
double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){\
|
|
/*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
|
|
return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);\
|
|
}\
|
|
\
|
|
double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){\
|
|
/*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
|
|
return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-6 * (time_stop.tv_nsec - time_start.tv_nsec);\
|
|
}\
|
|
\
|
|
long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){\
|
|
/*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\
|
|
return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);\
|
|
}\
|
|
\
|
|
|
|
|
|
|
|
#ifndef __DIMENSION_T_H__
|
|
#define __DIMENSION_T_H__
|
|
|
|
#include "../list_t/list_t.h"
|
|
|
|
struct dimension{
|
|
size_t rank;
|
|
size_t *shape;
|
|
size_t size;
|
|
};
|
|
|
|
|
|
|
|
extern bool littleEndian;
|
|
|
|
bool isLessEqThan(long int a, long int b) ;
|
|
bool isLessThan(long int a, long int b) ;
|
|
bool isGreatEqThan(long int a, long int b) ;
|
|
bool isGreatThan(long int a, long int b) ;
|
|
long int incr(long int i) ;
|
|
long int decr(long int i) ;
|
|
|
|
|
|
typedef struct dimension dimension ;
|
|
|
|
dimension * create_dim(size_t size);
|
|
dimension * create_reverse_dim(size_t size);
|
|
dimension* init_dim(size_t *t, size_t sz);
|
|
dimension* init_copy_dim(size_t *t, size_t sz);
|
|
dimension* clone_dim(dimension *dim);
|
|
void free_dimension(dimension *d);
|
|
|
|
bool is_equal_dim(dimension *d0, dimension *d1);
|
|
|
|
dimension* sub_minus_dim_head(dimension *t, size_t minusSubdim);
|
|
dimension* sub_minus_dim_tail(dimension *t, size_t minusSubdim);
|
|
dimension* sub_dim_head(dimension *t, size_t subdim);
|
|
dimension* sub_dim_tail(dimension *t, size_t subdim);
|
|
|
|
dimension* sub_copy_minus_dim_head(dimension *t, size_t minusSubdim);
|
|
dimension* sub_copy_minus_dim_tail(dimension *t, size_t minusSubdim);
|
|
dimension* sub_copy_dim_head(dimension *t, size_t sub_copydim);
|
|
dimension* sub_copy_dim_tail(dimension *t, size_t sub_copydim);
|
|
|
|
void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t pivotSplit, size_t rangeInPivot );
|
|
|
|
void add_copy_dimension(dimension **d, dimension *d0, dimension *d1);
|
|
void min_copy_dimension(dimension **d, dimension *d0, dimension *d1);
|
|
|
|
void add_dimension(dimension **d, dimension *d0, dimension *d1);
|
|
void min_dimension(dimension **d, dimension *d0, dimension *d1);
|
|
|
|
void printDebug_dimension(dimension *d, char *msg);
|
|
size_t sprint_dimension(char **dimContent, dimension *d);
|
|
|
|
void updateRankDim(dimension *dim);
|
|
|
|
size_t LineFromCoord(size_t *coo, dimension *dim);
|
|
size_t* CoordFromLin(size_t line, dimension *dim);
|
|
void vCoordFromLin(size_t *ret, size_t line, dimension *dim );
|
|
|
|
long int signedLineFromCoord(long *coo, dimension *dim);
|
|
long int* signedCoordFromLin(long line, dimension *dim);
|
|
void signedvCoordFromLin(long *ret, long int line, dimension *dim );
|
|
|
|
|
|
void increment_dim_var(dimension *d);
|
|
void decrement_dim_var(dimension *d);
|
|
|
|
struct list_shape_in_dim{
|
|
size_t index;
|
|
size_t shape;
|
|
struct list_shape_in_dim *next;
|
|
};
|
|
|
|
typedef struct list_shape_in_dim list_shape_in_dim;
|
|
|
|
void append_in_list_shape(list_shape_in_dim **list_p, size_t shape);
|
|
dimension * create_dim_from_list_shape( list_shape_in_dim *l_p);
|
|
|
|
dimension * create_binary_dim(size_t dimension_size);
|
|
|
|
void free_list_shape_in_dim(list_shape_in_dim *l_p);
|
|
|
|
CREATE_HEADER_LIST(dimension)
|
|
|
|
typedef dimension * ptr_DIMENSION;
|
|
|
|
CREATE_HEADER_LIST(ptr_DIMENSION)
|
|
GEN_HEAD_PTR_LIST(ptr_DIMENSION)
|
|
|
|
/*int compare_dimension(dimension *d1, dimension *d2);*/
|
|
|
|
#endif /* __DIMENSION_T_H__*/
|
|
|
|
#ifndef min
|
|
#define min(x,y) (((x)<(y))?(x):(y))
|
|
#endif
|
|
|
|
#define IMPLEMENTATION_DIMENSION()\
|
|
\
|
|
bool littleEndian=true;\
|
|
\
|
|
bool isLessEqThan(long int a, long int b) { return a <= b; }\
|
|
bool isLessThan(long int a, long int b) { return a < b; }\
|
|
bool isGreatEqThan(long int a, long int b) { return a >= b; }\
|
|
bool isGreatThan(long int a, long int b) { return a > b; }\
|
|
long int incr(long int i) { return i + 1; }\
|
|
long int decr(long int i) { return i - 1; }\
|
|
\
|
|
dimension* init_dim(size_t *t, size_t sz){\
|
|
dimension *d = malloc(sizeof(dimension));\
|
|
d->size=sz;\
|
|
d->shape=t;\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
\
|
|
dimension* init_copy_dim(size_t *t, size_t sz){\
|
|
if (sz==0) return NULL;\
|
|
dimension *d = malloc(sizeof(dimension));\
|
|
d->shape=malloc(sz * sizeof(size_t));\
|
|
d->size = sz;\
|
|
for(size_t i=0; i<sz; ++i) d->shape[i]=t[i];\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
dimension *\
|
|
create_dim(size_t sz){\
|
|
if (sz==0) return NULL;\
|
|
dimension *d = malloc(sizeof(dimension));\
|
|
d->shape=malloc(sz * sizeof(size_t));\
|
|
d->size = sz;\
|
|
return d;\
|
|
}\
|
|
\
|
|
dimension* clone_dim(dimension *dim){\
|
|
return init_copy_dim(dim->shape,dim->size);\
|
|
}\
|
|
\
|
|
dimension *\
|
|
create_reverse_dim(size_t sz){\
|
|
dimension *dim = create_dim(sz);\
|
|
for(size_t i=0;i<sz;++i) dim->shape[i]=sz-1-i;\
|
|
updateRankDim(dim);\
|
|
return dim;\
|
|
}\
|
|
\
|
|
void free_dimension(dimension *d){\
|
|
if(d){\
|
|
free(d->shape);\
|
|
free(d);\
|
|
}\
|
|
}\
|
|
\
|
|
bool is_equal_dim(dimension *d0, dimension *d1){\
|
|
if(d0->size != d1->size) return false;\
|
|
if(d0->rank != d1->rank) return false;\
|
|
for(size_t i=0;i<d0->size; ++i)\
|
|
if(d0->shape[i] != d1->shape[i]) return false;\
|
|
\
|
|
return true;\
|
|
}\
|
|
\
|
|
dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){\
|
|
if(minusSubdim < (root->size)){\
|
|
dimension *d = init_copy_dim(root->shape, (root->size)-minusSubdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){\
|
|
if(minusSubdim < (root->size)){\
|
|
dimension *d = init_copy_dim((root->shape)+minusSubdim, (root->size)-minusSubdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
|
|
if(subdim < (root->size)){\
|
|
dimension *d = init_copy_dim(root->shape, subdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
dimension* sub_copy_dim_tail(dimension *root, size_t subdim){\
|
|
if(subdim < (root->size)){\
|
|
dimension *d = init_copy_dim((root->shape)+(root->size - subdim), subdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
void add_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
|
|
(*d) = create_dim(d0->size + d1->size);\
|
|
for (size_t i = 0; i < d0->size; i++) (*d)->shape[i] = d0->shape[i];\
|
|
for (size_t i = 0; i < d1->size; i++) (*d)->shape[d0->size + i] = d1->shape[i];\
|
|
updateRankDim(*d);\
|
|
}\
|
|
\
|
|
void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
|
|
size_t mindim = min(d0->size,d1->size) ;\
|
|
(*d)=create_dim(mindim);\
|
|
\
|
|
for (size_t i = 0; i < mindim; i++) {\
|
|
if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
|
|
else (*d)->shape[i] = d0->shape[i];\
|
|
}\
|
|
updateRankDim(*d);\
|
|
}\
|
|
\
|
|
\
|
|
\
|
|
\
|
|
dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){\
|
|
if(minusSubdim < (root->size)){\
|
|
dimension *d = init_dim(root->shape, (root->size)-minusSubdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
dimension* sub_minus_dim_tail(dimension *root, size_t minusSubdim){\
|
|
if(minusSubdim < (root->size)){\
|
|
dimension *d = init_dim((root->shape)+minusSubdim, (root->size)-minusSubdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
dimension* sub_dim_head(dimension *root, size_t subdim){\
|
|
if(subdim < (root->size)){\
|
|
dimension *d = init_dim(root->shape, subdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
dimension* sub_dim_tail(dimension *root, size_t subdim){\
|
|
if(subdim < (root->size)){\
|
|
dimension *d = init_dim((root->shape)+(root->size - subdim), subdim);\
|
|
updateRankDim(d);\
|
|
return d;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
/*\
|
|
void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t sz_nb_minus_part ) */\
|
|
void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t pivotSplit, size_t rangeInPivot ) {\
|
|
if(pivotSplit < root->size){\
|
|
if(rangeInPivot < root->shape[pivotSplit]){\
|
|
/*size_t sz_part1= (root->rank * sz_nb_minus_part)/(root->shape[(root->size)-1]);*/\
|
|
/*printf("sz_part1 :%ld \n",sz_part1);*/\
|
|
*part_1 = init_copy_dim(root->shape, root->size);\
|
|
((*part_1)->shape[pivotSplit]) -= rangeInPivot;\
|
|
updateRankDim(*part_1);\
|
|
/*if(sz_nb_minus_part <2)\
|
|
*part_2 = init_copy_dim((root->shape), root->size-1 );\
|
|
else{*/\
|
|
*part_2 = init_copy_dim((root->shape), root->size );\
|
|
(*part_2)->shape[pivotSplit] = rangeInPivot ;\
|
|
/*}*/\
|
|
updateRankDim(*part_2);\
|
|
}\
|
|
}\
|
|
}\
|
|
\
|
|
void increment_dim_var(dimension *d){\
|
|
if(littleEndian){\
|
|
(d->shape[0])++;\
|
|
}\
|
|
else{\
|
|
(d->shape[d->size - 1])++;\
|
|
}\
|
|
}\
|
|
\
|
|
\
|
|
void decrement_dim_var(dimension *d){\
|
|
if(littleEndian){\
|
|
(d->shape[0])--;\
|
|
}\
|
|
else{\
|
|
(d->shape[d->size - 1])--;\
|
|
}\
|
|
}\
|
|
\
|
|
void add_dimension(dimension **d, dimension *d0, dimension *d1) {\
|
|
(*d) = create_dim(d0->size + d1->size);\
|
|
for (size_t i = 0; i < d0->size; i++) (*d)->shape[i] = d0->shape[i];\
|
|
for (size_t i = 0; i < d1->size; i++) (*d)->shape[d0->size + i] = d1->shape[i];\
|
|
updateRankDim(*d);\
|
|
}\
|
|
\
|
|
void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
|
|
if (d0->size > d1->size) {\
|
|
*d = d1;\
|
|
}\
|
|
else if (d0->size < d1->size) {\
|
|
*d = d0;\
|
|
}\
|
|
else { /* d0->size = d1->size*/\
|
|
*d = d0;\
|
|
for (size_t i = 0; i < d0->size; i++) {\
|
|
if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
|
|
}\
|
|
}\
|
|
updateRankDim(*d);\
|
|
}\
|
|
\
|
|
void printDebug_dimension(dimension *d,char *msg){\
|
|
\
|
|
printf("<%p>(%s)->size = %ld | (%s)->rank = %ld \n[",d,msg,d->size,msg,d->rank);\
|
|
for(size_t i=0; i<d->size; ++i)\
|
|
printf(" %ld,", d->shape[i]);\
|
|
printf("] \n");\
|
|
/*printf("[%ld: %ld] |", i,d->shape[i]);*/\
|
|
/* if(littleEndian)\
|
|
printf("\nlittleEndian (true): the bigest index varies first, e.g: [x0,x1,x2,...,xn] xn is the bigest index\n");\
|
|
else\
|
|
printf("\nlittleEndian (false): the lowest index varies first, e.g: [x0,x1,x2,...,xn] x0 is the lowest index\n");\
|
|
*/\
|
|
}\
|
|
\
|
|
size_t sprint_dimension(char **dimContent, dimension *d){\
|
|
if(*dimContent != NULL){\
|
|
free(*dimContent);\
|
|
*dimContent=NULL;\
|
|
}\
|
|
size_t nbch=6*d->size+40;\
|
|
*dimContent = malloc(nbch);\
|
|
/*printf("nbCh=%ld\n",nbch);*/\
|
|
char *val=NULL;\
|
|
size_t cur=0;\
|
|
char *dimSzCh="dim->size";\
|
|
for(size_t i=0; i<strlen(dimSzCh);++i)\
|
|
(*dimContent)[cur++]=dimSzCh[i];\
|
|
(*dimContent)[cur++]='=';\
|
|
val=TYPE_SIZE_T_TO_STR(d->size);\
|
|
for(size_t c=0;c<strlen(val);++c)\
|
|
(*dimContent)[cur++]=val[c];\
|
|
free(val); val = NULL;\
|
|
(*dimContent)[cur++]=' ';\
|
|
(*dimContent)[cur++]='/';\
|
|
(*dimContent)[cur++]=' ';\
|
|
char *dimRkCh="dim->rank";\
|
|
for(size_t i=0; i<strlen(dimRkCh);++i)\
|
|
(*dimContent)[cur++]=dimRkCh[i];\
|
|
(*dimContent)[cur++]='=';\
|
|
val=TYPE_SIZE_T_TO_STR(d->rank);\
|
|
for(size_t c=0;c<strlen(val);++c)\
|
|
(*dimContent)[cur++]=val[c];\
|
|
free(val); val = NULL;\
|
|
(*dimContent)[cur++]=' ';\
|
|
(*dimContent)[cur++]='\n';\
|
|
(*dimContent)[cur++]='[';\
|
|
for(size_t i=0; i<d->size;++i){\
|
|
(*dimContent)[cur++]=' ';\
|
|
val=TYPE_SIZE_T_TO_STR(d->shape[i]);\
|
|
for(size_t c=0;c<strlen(val);++c)\
|
|
(*dimContent)[cur++]=val[c];\
|
|
free(val); val = NULL;\
|
|
(*dimContent)[cur++]=',';\
|
|
\
|
|
}\
|
|
(*dimContent)[cur++]=']';\
|
|
\
|
|
(*dimContent)[cur++]='\n';\
|
|
(*dimContent)[cur++]='\0';\
|
|
\
|
|
return cur;\
|
|
}\
|
|
\
|
|
void updateRankDim(dimension *dim){\
|
|
dim->rank=1;\
|
|
for(size_t i=0; i<dim->size; ++i)\
|
|
dim->rank *=dim->shape[i];\
|
|
}\
|
|
\
|
|
/* signed */\
|
|
long int signedLineFromCoord(long int *coo, dimension *dim){\
|
|
long int begin = 0;\
|
|
long int end = dim->size - 1;\
|
|
long int (*iter)(long int); iter = &incr;\
|
|
bool (*cond)(long int, long int); cond = &isLessEqThan;\
|
|
\
|
|
if (littleEndian) {\
|
|
begin = dim->size - 1; end = 0;\
|
|
iter = &decr; cond = &isGreatEqThan;\
|
|
}\
|
|
\
|
|
long int pp = 1;\
|
|
long int sm = 0;\
|
|
for (long int i = begin; cond(i, end); i = iter(i)) {\
|
|
sm += (coo[i] * pp);\
|
|
pp *= dim->shape[i];\
|
|
}\
|
|
return sm;\
|
|
\
|
|
}\
|
|
\
|
|
void signedvCoordFromLin(long int *ret, long int line, dimension *dim ){\
|
|
\
|
|
long int begin = 0, end = dim->size - 1;\
|
|
long int (*iter)(long int) = incr;\
|
|
bool (*cond)(long int, long int) = isLessThan;\
|
|
if (littleEndian == false) {\
|
|
/*if (littleEndian) {*/\
|
|
begin = dim->size - 1; end = 0;\
|
|
iter = decr; cond = isGreatThan;\
|
|
}\
|
|
/*prlong intf("to coor begin = %d end = %d \n", begin, end);*/\
|
|
\
|
|
long int sm = line;\
|
|
long int pp = dim->rank;\
|
|
for (long int i = begin; cond(i, end); i = iter(i)) {\
|
|
/*prlong intf(" i: %d ", i);*/\
|
|
pp /= dim->shape[i];\
|
|
ret[i] = sm / pp;\
|
|
sm %= pp;\
|
|
/*prlong intf("sm[%d] = %d , pp=%d ; ", i, sm, pp);*/\
|
|
}\
|
|
ret[end] = sm;\
|
|
}\
|
|
\
|
|
long int* signedCoordFromLin(long int line, dimension *dim){\
|
|
long int *ret;\
|
|
ret=malloc(dim->size*sizeof(long int));\
|
|
signedvCoordFromLin(ret,line,dim);\
|
|
return ret;\
|
|
}\
|
|
\
|
|
/* */\
|
|
/* unsigned */\
|
|
size_t LineFromCoord(size_t *coo, dimension *dim) {\
|
|
return (long)signedLineFromCoord((long*)coo,dim);\
|
|
}\
|
|
\
|
|
void vCoordFromLin(size_t *ret, size_t line, dimension *dim ){\
|
|
signedvCoordFromLin((long*)ret, (long)line, dim);\
|
|
}\
|
|
\
|
|
size_t* CoordFromLin(size_t line, dimension *dim){\
|
|
return (size_t*)signedCoordFromLin((long)line, dim);\
|
|
}\
|
|
\
|
|
\
|
|
/* */\
|
|
\
|
|
void append_in_list_shape(list_shape_in_dim **list_p, size_t shape){\
|
|
list_shape_in_dim *lis=malloc(sizeof(list_shape_in_dim));\
|
|
lis->shape=shape;\
|
|
lis->next=NULL;\
|
|
if(*list_p == NULL){\
|
|
lis->index=0;\
|
|
*list_p = lis;\
|
|
}\
|
|
else{\
|
|
list_shape_in_dim *tmp =*list_p;\
|
|
while(tmp->next) tmp=tmp->next;\
|
|
lis->index = tmp->index +1;\
|
|
tmp->next=lis;\
|
|
}\
|
|
}\
|
|
\
|
|
dimension * create_dim_from_list_shape( list_shape_in_dim *l_p){\
|
|
\
|
|
if(l_p){\
|
|
list_shape_in_dim *tmp =l_p;\
|
|
while(tmp->next) tmp=tmp->next;\
|
|
dimension *dim=create_dim(tmp->index + 1);\
|
|
(dim)->size = tmp->index + 1;\
|
|
tmp=l_p;\
|
|
while(tmp){\
|
|
(dim)->shape[tmp->index]=tmp->shape;\
|
|
tmp=tmp->next;\
|
|
}\
|
|
updateRankDim(dim);\
|
|
return dim;\
|
|
}\
|
|
return NULL;\
|
|
}\
|
|
\
|
|
dimension * create_binary_dim(size_t dimension_size){\
|
|
dimension * dim = create_dim(dimension_size);\
|
|
for(size_t i=0; i<dimension_size; ++i)\
|
|
dim->shape[i]=2;\
|
|
updateRankDim(dim);\
|
|
return dim;\
|
|
}\
|
|
\
|
|
\
|
|
void free_list_shape_in_dim(list_shape_in_dim *l_p){\
|
|
list_shape_in_dim *tmp=l_p, *ttmp;\
|
|
while(tmp){\
|
|
ttmp = tmp;\
|
|
tmp = ttmp->next;\
|
|
free(ttmp);\
|
|
}\
|
|
}\
|
|
\
|
|
IMPLEMENTATION_LIST(dimension)\
|
|
\
|
|
IMPLEMENTATION_LIST(ptr_DIMENSION)\
|
|
GEN_FUNC_PTR_LIST_FREE(ptr_DIMENSION){\
|
|
dimension *pdim=(dimension*)arg;\
|
|
free_dimension(pdim);\
|
|
/*free(pdim);*/\
|
|
}\
|
|
\
|
|
|
|
|