#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__*/



#ifndef IMPLEMENTATION_TOOLS
#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);\
}\
\

#endif /* IMPLEMENTATION_TOOLS */

#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 

#ifndef IMPLEMENTATION_DIMENSION
#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);*/\
}\
\

#endif /* IMPLEMENTATION_DIMENSION */