diff --git a/onetensor/testDimension.c b/onetensor/testDimension.c
index b3e06ac..b14b47e 100644
--- a/onetensor/testDimension.c
+++ b/onetensor/testDimension.c
@@ -27,11 +27,11 @@ TEST(dimension0){
 
   dimension *D = create_dim(5);
 
-  EXPECT_EQ(D->size,5);
+  EXPECT_EQ(D->rank,5);
 
   free_dimension(D);
 }
-TEST(rank){
+TEST(size){
   dimension *D=create_dim(4);
   D->shape[0]=2;
   D->shape[1]=3;
@@ -39,7 +39,7 @@ TEST(rank){
   D->shape[3]=6;
 
   updateRankDim(D);
-  EXPECT_EQ(D->rank, 180);
+  EXPECT_EQ(D->size, 180);
 
   free_dimension(D);
 }
@@ -116,10 +116,10 @@ TEST(SubDimB){
   dimension *d_head2 = sub_minus_dim_head(D,2);
   
   
-  EXPECT_EQ(d_head2->rank, 12*23);
+  EXPECT_EQ(d_head2->size, 12*23);
 
   dimension *d_tail2 = sub_minus_dim_tail(D,2);
-  EXPECT_EQ(d_tail2->rank, 15*26);
+  EXPECT_EQ(d_tail2->size, 15*26);
 
   free_dimension(D);
   free(d_tail2);
@@ -137,10 +137,10 @@ TEST(SubDim){
   dimension *d_head2 = sub_minus_dim_head(D,2);
   
   
-  EXPECT_EQ(d_head2->rank, 2*3);
+  EXPECT_EQ(d_head2->size, 2*3);
 
   dimension *d_tail2 = sub_minus_dim_tail(D,2);
-  EXPECT_EQ(d_tail2->rank, 5*6);
+  EXPECT_EQ(d_tail2->size, 5*6);
 
   free_dimension(D);
   free(d_tail2);
@@ -159,7 +159,7 @@ TEST(Coord_linear){
   size_t line=255;
   size_t *coord = CoordFromLin(line,D);
 
-  for(size_t i=0; i<D->size; ++i){
+  for(size_t i=0; i<D->rank; ++i){
     LOG("coo[%ld]=%ld\n",i,coord[i]);
   }
   
@@ -180,7 +180,7 @@ TEST(signedCoord_linear){
   long line=-255;
   long *coord = signedCoordFromLin(line,D);
 
-  for(size_t i=0; i<D->size; ++i){
+  for(size_t i=0; i<D->rank; ++i){
     LOG("coo[%ld]=%ld\n",i,coord[i]);
   }
   
@@ -200,7 +200,7 @@ TEST(signedCoord_linearSuccessif){
   for(long line=-4; line < 4; ++line){
     long *coord = signedCoordFromLin(line,D);
 
-    for(size_t i=0; i<D->size; ++i){
+    for(size_t i=0; i<D->rank; ++i){
       LOG("coo[%ld]=%ld\n",i,coord[i]);
     }
   
diff --git a/onetensor/y_tensor_h.h b/onetensor/y_tensor_h.h
index 172bbdf..23d4157 100644
--- a/onetensor/y_tensor_h.h
+++ b/onetensor/y_tensor_h.h
@@ -94,19 +94,19 @@ extern long int PRECISION_TYPE_L_DOUBLE ;
 
 #define FREE(x)  { free((x)); (x) = NULL;} 
 
-#define FOREACH(array, size, function)\
-  for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);
+#define FOREACH(array, array_size, function)\
+  for(size_t _ind = 0; _ind < array_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);\
+  void COPY_ARRAY_##type(type* dst, const type* src, size_t array_size);\
+  type MAX_ARRAY_##type(const  type *array, size_t array_size);\
+  size_t ARG_MAX_ARRAY_##type(const type *array, size_t array_size);\
+  type MIN_ARRAY_##type(const  type *array, size_t array_size);\
+  size_t ARG_MIN_ARRAY_##type(const  type *array, size_t array_size);\
   TYPE_STRING type##_TO_STR(type var);\
   
 
@@ -190,9 +190,9 @@ COMPARE_N_TYPE_STRING(const void *a,const  void* b)\
   return strcmp(*aa,*bb);\
 }\
 \
-void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size)\
+void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t array_size)\
 {\
-  for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]);\
+  for(size_t i = 0; i < array_size; ++i) strcpy(dst[i],src[i]);\
 }\
 \
 \
@@ -275,9 +275,9 @@ long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_s
 #include "../list_t/list_t.h"
 
 struct dimension{
-  size_t rank;
-  size_t *shape;
   size_t size;
+  size_t *shape;
+  size_t rank;
 };
 
 
@@ -294,10 +294,10 @@ 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 * create_dim(size_t rank);
+dimension * create_reverse_dim(size_t rank);
+dimension* init_dim(size_t *t, size_t rnk);
+dimension* init_copy_dim(size_t *t, size_t rnk);
 dimension* clone_dim(dimension *dim);
 void free_dimension(dimension *d);
 
@@ -349,7 +349,7 @@ 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);
+dimension * create_binary_dim(size_t dimension_rank);
 
 void free_list_shape_in_dim(list_shape_in_dim *l_p);
 
@@ -380,40 +380,40 @@ 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* init_dim(size_t *t, size_t rnk){\
   dimension *d = malloc(sizeof(dimension));\
-  d->size=sz;\
+  d->rank=rnk;\
   d->shape=t;\
   updateRankDim(d);\
   return d;\
 }\
 \
-dimension* init_copy_dim(size_t *t, size_t sz){\
-  if (sz==0) return NULL;\
+dimension* init_copy_dim(size_t *t, size_t rnk){\
+  if (rnk==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];\
+  d->shape=malloc(rnk * sizeof(size_t));\
+  d->rank = rnk;\
+  for(size_t i=0; i<rnk; ++i) d->shape[i]=t[i];\
   updateRankDim(d);\
   return d;\
 }\
 dimension *\
-create_dim(size_t sz){\
-  if (sz==0) return NULL;\
+create_dim(size_t rnk){\
+  if (rnk==0) return NULL;\
   dimension *d = malloc(sizeof(dimension));\
-  d->shape=malloc(sz * sizeof(size_t));\
-  d->size = sz;\
+  d->shape=malloc(rnk * sizeof(size_t));\
+  d->rank = rnk;\
   return d;\
 }\
 \
 dimension* clone_dim(dimension *dim){\
-return init_copy_dim(dim->shape,dim->size);\
+return init_copy_dim(dim->shape,dim->rank);\
 }\
 \
 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;\
+create_reverse_dim(size_t rnk){\
+  dimension *dim = create_dim(rnk);\
+  for(size_t i=0;i<rnk;++i) dim->shape[i]=rnk-1-i;\
   updateRankDim(dim);\
   return dim;\
 }\
@@ -426,17 +426,17 @@ void free_dimension(dimension *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->size != d1->size) return false;\
+  for(size_t i=0;i<d0->rank; ++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);\
+  if(minusSubdim < (root->rank)){\
+    dimension *d = init_copy_dim(root->shape, (root->rank)-minusSubdim);\
     updateRankDim(d);\
     return d;\
   }\
@@ -444,8 +444,8 @@ dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){\
 }\
 \
 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);\
+  if(minusSubdim < (root->rank)){\
+    dimension *d = init_copy_dim((root->shape)+minusSubdim, (root->rank)-minusSubdim);\
     updateRankDim(d);\
     return d;\
   }\
@@ -453,7 +453,7 @@ dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){\
 }\
 \
 dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
-  if(subdim < (root->size)){\
+  if(subdim < (root->rank)){\
     dimension *d = init_copy_dim(root->shape, subdim);\
     updateRankDim(d);\
     return d;\
@@ -462,8 +462,8 @@ dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
 }\
 \
 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);\
+  if(subdim < (root->rank)){\
+    dimension *d = init_copy_dim((root->shape)+(root->rank - subdim), subdim);\
     updateRankDim(d);\
     return d;\
   }\
@@ -471,14 +471,14 @@ dimension* sub_copy_dim_tail(dimension *root, size_t subdim){\
 }\
 \
 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];\
+    (*d) = create_dim(d0->rank + d1->rank);\
+    for (size_t i = 0; i < d0->rank; i++) (*d)->shape[i] = d0->shape[i];\
+    for (size_t i = 0; i < d1->rank; i++) (*d)->shape[d0->rank + i] = d1->shape[i];\
     updateRankDim(*d);\
 }\
 \
 void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
-    size_t mindim = min(d0->size,d1->size) ;\
+    size_t mindim = min(d0->rank,d1->rank) ;\
     (*d)=create_dim(mindim);\
 \
        for (size_t i = 0; i < mindim; i++) {\
@@ -492,23 +492,23 @@ void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
 \
 \
 dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){\
-  if(minusSubdim < (root->size)){\
-    dimension *d = init_dim(root->shape, (root->size)-minusSubdim);\
+  if(minusSubdim < (root->rank)){\
+    dimension *d = init_dim(root->shape, (root->rank)-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);\
+  if(minusSubdim < (root->rank)){\
+    dimension *d = init_dim((root->shape)+minusSubdim, (root->rank)-minusSubdim);\
     updateRankDim(d);\
     return d;\
   }\
   return NULL;\
 }\
 dimension* sub_dim_head(dimension *root, size_t subdim){\
-  if(subdim < (root->size)){\
+  if(subdim < (root->rank)){\
     dimension *d = init_dim(root->shape, subdim);\
     updateRankDim(d);\
     return d;\
@@ -516,8 +516,8 @@ dimension* sub_dim_head(dimension *root, size_t subdim){\
   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);\
+  if(subdim < (root->rank)){\
+    dimension *d = init_dim((root->shape)+(root->rank - subdim), subdim);\
     updateRankDim(d);\
     return d;\
   }\
@@ -525,19 +525,19 @@ dimension* sub_dim_tail(dimension *root, size_t subdim){\
 }\
 \
 /*\
-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 rnk_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(pivotSplit < root->rank){\
   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);\
+    /*size_t rnk_part1= (root->size * rnk_nb_minus_part)/(root->shape[(root->rank)-1]);*/\
+    /*printf("rnk_part1 :%ld \n",rnk_part1);*/\
+    *part_1 = init_copy_dim(root->shape, root->rank);\
     ((*part_1)->shape[pivotSplit]) -= rangeInPivot;\
     updateRankDim(*part_1);\
-    /*if(sz_nb_minus_part <2)\
-      *part_2 = init_copy_dim((root->shape), root->size-1 );\
+    /*if(rnk_nb_minus_part <2)\
+      *part_2 = init_copy_dim((root->shape), root->rank-1 );\
     else{*/\
-      *part_2 = init_copy_dim((root->shape), root->size );\
+      *part_2 = init_copy_dim((root->shape), root->rank );\
       (*part_2)->shape[pivotSplit] = rangeInPivot ;\
     /*}*/\
     updateRankDim(*part_2);\
@@ -550,7 +550,7 @@ void increment_dim_var(dimension *d){\
     (d->shape[0])++;\
   }\
   else{\
-    (d->shape[d->size - 1])++;\
+    (d->shape[d->rank - 1])++;\
   }\
 }\
 \
@@ -560,27 +560,27 @@ void decrement_dim_var(dimension *d){\
     (d->shape[0])--;\
   }\
   else{\
-    (d->shape[d->size - 1])--;\
+    (d->shape[d->rank - 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];\
+    (*d) = create_dim(d0->rank + d1->rank);\
+    for (size_t i = 0; i < d0->rank; i++) (*d)->shape[i] = d0->shape[i];\
+    for (size_t i = 0; i < d1->rank; i++) (*d)->shape[d0->rank + i] = d1->shape[i];\
     updateRankDim(*d);\
 }\
 \
 void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
-    if (d0->size > d1->size) {\
+    if (d0->rank > d1->rank) {\
         *d = d1;\
     }\
-    else if (d0->size < d1->size) {\
+    else if (d0->rank < d1->rank) {\
         *d = d0;\
     }\
-    else { /* d0->size = d1->size*/\
+    else { /* d0->rank = d1->rank*/\
         *d = d0;\
-        for (size_t i = 0; i < d0->size; i++) {\
+        for (size_t i = 0; i < d0->rank; i++) {\
             if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
         }\
     }\
@@ -589,8 +589,8 @@ void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
 \
 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("<%p>(%s)->rank = %ld | (%s)->size = %ld \n[",d,msg,d->rank,msg,d->size);\
+  for(size_t i=0; i<d->rank; ++i)\
     printf(" %ld,", d->shape[i]);\
   printf("] \n");\
     /*printf("[%ld: %ld] |", i,d->shape[i]);*/\
@@ -606,34 +606,34 @@ size_t sprint_dimension(char **dimContent, dimension *d){\
     free(*dimContent);\
     *dimContent=NULL;\
   }\
-  size_t nbch=6*d->size+40;\
+  size_t nbch=6*d->rank+40;\
   *dimContent = malloc(nbch);\
   /*printf("nbCh=%ld\n",nbch);*/\
   char *val=NULL;\
   size_t cur=0;\
-  char *dimSzCh="dim->size";\
+  char *dimSzCh="dim->rank";\
   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++]='/';\
+  (*dimContent)[cur++]=' ';\
+  char *dimRkCh="dim->size";\
+  for(size_t i=0; i<strlen(dimRkCh);++i)\
+    (*dimContent)[cur++]=dimRkCh[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++]='\n';\
   (*dimContent)[cur++]='[';\
-  for(size_t i=0; i<d->size;++i){\
+  for(size_t i=0; i<d->rank;++i){\
     (*dimContent)[cur++]=' ';\
     val=TYPE_SIZE_T_TO_STR(d->shape[i]);\
     for(size_t c=0;c<strlen(val);++c)\
@@ -651,20 +651,20 @@ size_t sprint_dimension(char **dimContent, dimension *d){\
 }\
 \
 void updateRankDim(dimension *dim){\
-  dim->rank=1;\
-  for(size_t i=0; i<dim->size; ++i)\
-    dim->rank *=dim->shape[i];\
+  dim->size=1;\
+  for(size_t i=0; i<dim->rank; ++i)\
+    dim->size *=dim->shape[i];\
 }\
 \
 /* signed  */\
 long int signedLineFromCoord(long int *coo, dimension *dim){\
     long int begin = 0;\
-    long int end = dim->size - 1;\
+    long int end = dim->rank - 1;\
     long int (*iter)(long int); iter = &incr;\
     bool (*cond)(long int, long int); cond = &isLessEqThan;\
 \
     if (littleEndian) {\
-        begin = dim->size - 1; end = 0;\
+        begin = dim->rank - 1; end = 0;\
         iter = &decr; cond = &isGreatEqThan;\
     }\
 \
@@ -680,18 +680,18 @@ long int signedLineFromCoord(long int *coo, dimension *dim){\
 \
 void signedvCoordFromLin(long int *ret, long int line, dimension *dim ){\
     \
-    long int begin = 0, end = dim->size - 1;\
+    long int begin = 0, end = dim->rank - 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;\
+        begin = dim->rank - 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;\
+    long int pp = dim->size;\
     for (long int i = begin; cond(i, end); i = iter(i)) {\
         /*prlong intf(" i: %d ", i);*/\
         pp /= dim->shape[i];\
@@ -704,7 +704,7 @@ void signedvCoordFromLin(long int *ret, long int line, dimension *dim ){\
 \
 long int* signedCoordFromLin(long int line, dimension *dim){\
     long int *ret;\
-    ret=malloc(dim->size*sizeof(long int));\
+    ret=malloc(dim->rank*sizeof(long int));\
     signedvCoordFromLin(ret,line,dim);\
     return ret;\
 }\
@@ -748,7 +748,7 @@ dimension * create_dim_from_list_shape( list_shape_in_dim *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;\
+    (dim)->rank = tmp->index + 1;\
     tmp=l_p;\
     while(tmp){\
       (dim)->shape[tmp->index]=tmp->shape;\
@@ -760,9 +760,9 @@ dimension * create_dim_from_list_shape( list_shape_in_dim *l_p){\
   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)\
+dimension * create_binary_dim(size_t dimension_rank){\
+  dimension * dim = create_dim(dimension_rank);\
+  for(size_t i=0; i<dimension_rank; ++i)\
     dim->shape[i]=2;\
   updateRankDim(dim);\
   return dim;\
@@ -815,14 +815,14 @@ void _recreate_tensor_if_not_the_same_dim_or_null_##type(tensor_##type **M, dime
 tensor_##type* clone_tensor_##type(tensor_##type *tens);\
 void free_tensor_##type(tensor_##type *  tens); \
 int copy_tensor_##type(tensor_##type * dst, tensor_##type * src);\
-tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
-tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
-tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
-tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim); \
-tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
-tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim); \
-tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \
-tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim); \
+tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim); \
+tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim); \
+tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t sizeInDim); \
+tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t sizeInDim); \
+tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim); \
+tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim); \
+tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t sizeInDim); \
+tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t sizeInDim); \
 void print_tensor_msg_##type(tensor_##type *T, char *msg);\
 void fprint_tensor_##type(char *file_name, tensor_##type *T);\
 size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex);\
@@ -901,22 +901,22 @@ void concatArray(size_t* dst, size_t* src0, size_t* src1, size_t debDst, size_t
     }
 }
 
-void printArraySzt(size_t *a, size_t sz,char *msg){
-  printf("======== %s ======= size: %ld\n",msg,sz);
-  for(size_t i=0; i< sz; ++i)
+void printArraySzt(size_t *a, size_t rnk,char *msg){
+  printf("======== %s ======= rank: %ld\n",msg,rnk);
+  for(size_t i=0; i< rnk; ++i)
     printf("[%ld : %ld ] ",i,a[i]);
   printf("\n");
 }
 
 int checkContractProdTensorDim(dimension *d0, dimension *d1, ssize_t contractionNumber){
-  if((d0->size-contractionNumber <0)||(d1->size-contractionNumber <0)) return 0;
+  if((d0->rank-contractionNumber <0)||(d1->rank-contractionNumber <0)) return 0;
   if(littleEndian){
-    ssize_t beginCommonM0=d0->size-contractionNumber;
+    ssize_t beginCommonM0=d0->rank-contractionNumber;
     for(ssize_t i=0; i<contractionNumber; ++i){
       if(d0->shape[beginCommonM0+i] != d1->shape[i]) return 0;
     }
   }else{
-    ssize_t beginCommonM1=d1->size-contractionNumber;
+    ssize_t beginCommonM1=d1->rank-contractionNumber;
     for(ssize_t i=0; i<contractionNumber; ++i){
       if(d0->shape[i] != d1->shape[beginCommonM1+i]) return 0;
     }
@@ -957,7 +957,7 @@ long int decr(long int i) { return i - 1; }
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     updateRankDim(dim);\
     r_tens->dim = dim;\
-    r_tens->x = malloc(sizeof(type)*dim->rank);\
+    r_tens->x = malloc(sizeof(type)*dim->size);\
     return r_tens;\
   }\
 \
@@ -983,7 +983,7 @@ tensor_##type* init_tensor_head_##type(tensor_##type *troot ,dimension *dim){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     updateRankDim(dim);\
     r_tens->dim = dim;\
-    r_tens->x = troot->x + ((troot->dim)->rank - dim->rank);\
+    r_tens->x = troot->x + ((troot->dim)->size - dim->size);\
     return r_tens;\
   }\
 \
@@ -993,7 +993,7 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
     updateRankDim(dim);\
     r_tens->dim = dim;\
     /*r_tens->x = troot->x;*/\
-    for(size_t i=0; i<dim->rank;++i)\
+    for(size_t i=0; i<dim->size;++i)\
       r_tens->x[i]=troot->x[i];\
     return r_tens;\
   }\
@@ -1002,10 +1002,10 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     updateRankDim(dim);\
     r_tens->dim = dim;\
-    /*r_tens->x = troot->x + ((troot->dim)->rank - dim->rank);*/\
-    r_tens->x = malloc(sizeof(type)*dim->rank);\
-    size_t dRank=(troot->dim)->rank - dim->rank;\
-    for(size_t i=0; i<dim->rank;++i)\
+    /*r_tens->x = troot->x + ((troot->dim)->size - dim->size);*/\
+    r_tens->x = malloc(sizeof(type)*dim->size);\
+    size_t dRank=(troot->dim)->size - dim->size;\
+    for(size_t i=0; i<dim->size;++i)\
       r_tens->x[i]=troot->x[i+dRank];\
     return r_tens;\
   }\
@@ -1013,8 +1013,8 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
 \
  tensor_##type* create_tensor_from_cpy_dim_##type(dimension *dim){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
-    r_tens->dim = init_copy_dim(dim->shape,dim->size);\
-    r_tens->x = malloc(sizeof(type)*dim->rank);\
+    r_tens->dim = init_copy_dim(dim->shape,dim->rank);\
+    r_tens->x = malloc(sizeof(type)*dim->size);\
     return r_tens;\
   }\
 \
@@ -1022,8 +1022,8 @@ tensor_##type* clone_tensor_##type(tensor_##type *tens){\
   if(tens){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     r_tens->dim = clone_dim(tens->dim);\
-    r_tens->x = malloc(sizeof(type) * (tens->dim)->rank);\
-    for(size_t i=0; i<(tens->dim)->rank;++i)\
+    r_tens->x = malloc(sizeof(type) * (tens->dim)->size);\
+    for(size_t i=0; i<(tens->dim)->size;++i)\
       r_tens->x[i]=tens->x[i];\
     return r_tens;\
   }\
@@ -1032,9 +1032,9 @@ tensor_##type* clone_tensor_##type(tensor_##type *tens){\
 \
 int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
   if(dst!=NULL && src!=NULL){ \
-    int diff = dst->dim->rank - src->dim->rank;\
+    int diff = dst->dim->size - src->dim->size;\
     if(diff == 0) \
-      for(size_t i=0; i<(src->dim)->rank;++i)\
+      for(size_t i=0; i<(src->dim)->size;++i)\
         dst->x[i]=src->x[i];\
     return diff;\
     \
@@ -1053,28 +1053,28 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     /*static bool initRandomFirst = true;\
     if(initRandomFirst){ srand(time(NULL)); initRandomFirst = false;}*/\
     int randVal;\
-    for(size_t i =0; i<(M->dim)->rank;++i){\
+    for(size_t i =0; i<(M->dim)->size;++i){\
       randVal = xrand() % randomRange;\
       M->x[i]=minR + (maxR-minR)*randVal  / randomRange ;\
     \
     }\
   }\
-  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_t = sub_minus_dim_tail(rdim,rdim->size - minuSubdim);\
-    if(rankInDim < dS_t->rank){\
+    dimension *dS_t = sub_minus_dim_tail(rdim,rdim->rank - minuSubdim);\
+    if(sizeInDim < dS_t->size){\
       dimension *dS_h = sub_minus_dim_head(rdim,minuSubdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-      ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+      ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       if(littleEndian){\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-            ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+        for(size_t i=0; i<dS_h->size; ++i){\
+            ret_ens->x[i]=rootens->x[i*dS_t->size + sizeInDim];\
           \
         }\
       }else{\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       }\
       return ret_ens;\
@@ -1082,21 +1082,21 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     return NULL;\
   }\
   \
-  tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_h = sub_minus_dim_head(rdim,rdim->size - minuSubdim);\
-    if(rankInDim < dS_h->rank){\
+    dimension *dS_h = sub_minus_dim_head(rdim,rdim->rank - minuSubdim);\
+    if(sizeInDim < dS_h->size){\
       dimension *dS_t = sub_minus_dim_tail(rdim,minuSubdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-        ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+        ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->size + sizeInDim];\
         }\
       }else{\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
       }\
@@ -1105,21 +1105,21 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     return NULL;\
   }\
   \
-  tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){\
+  tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, size_t subdim, size_t sizeInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_t = sub_dim_tail(rdim,rdim->size - subdim);\
-    if(rankInDim < dS_t->rank){\
+    dimension *dS_t = sub_dim_tail(rdim,rdim->rank - subdim);\
+    if(sizeInDim < dS_t->size){\
       dimension *dS_h = sub_dim_head(rdim,subdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-        ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+        ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       if(littleEndian){\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_t->size + sizeInDim];\
         }\
       }else{\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       \
       }\
@@ -1127,21 +1127,21 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     }\
     return NULL;\
   }\
-  tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t rankInDim){ \
+  tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, size_t subdim, size_t sizeInDim){ \
     dimension *rdim= rootens->dim;\
-    dimension *dS_h = sub_dim_head(rdim,rdim->size - subdim);\
-    if(rankInDim < dS_h->rank){\
+    dimension *dS_h = sub_dim_head(rdim,rdim->rank - subdim);\
+    if(sizeInDim < dS_h->size){\
       dimension *dS_t = sub_dim_tail(rdim,subdim);\
       tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-        ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+        ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->size + sizeInDim];\
         }\
       }else{\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
       }\
@@ -1150,26 +1150,26 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     return NULL;\
   }\
   \
-  tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_t = sub_copy_minus_dim_tail(rdim,rdim->size - minuSubdim);\
-    if(rankInDim < dS_t->rank){\
+    dimension *dS_t = sub_copy_minus_dim_tail(rdim,rdim->rank - minuSubdim);\
+    if(sizeInDim < dS_t->size){\
       dimension *dS_h = sub_copy_minus_dim_head(rdim,minuSubdim);\
       tensor_##type *ret_ens = create_tensor_##type(dS_h);\
       /*malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-      ret_ens->x = malloc(sizeof(type)*dS_h->rank);*/\
+      ret_ens->x = malloc(sizeof(type)*dS_h->size);*/\
       if(littleEndian){\
-        /*ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
-        */for(size_t i=0; i<dS_h->rank; ++i){\
-            ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        /*ret_ens->x = malloc(sizeof(type)*dS_h->size);\
+        */for(size_t i=0; i<dS_h->size; ++i){\
+            ret_ens->x[i]=rootens->x[i*dS_t->size + sizeInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->size, i,dS_h->size,i*dS_h->size + sizeInDim);*/\
           \
         }\
       }else{\
-        /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
+        /*ret_ens->x = (rootens->x)+sizeInDim*dS_h->size;*/\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       }\
       free_dimension(dS_t);\
@@ -1179,23 +1179,23 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     return NULL;\
   }\
   \
-  tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t rankInDim){\
+  tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, size_t minuSubdim, size_t sizeInDim){\
     dimension *rdim= rootens->dim;\
-    dimension *dS_h = sub_copy_minus_dim_head(rdim,rdim->size - minuSubdim);\
-    if(rankInDim < dS_h->rank){\
+    dimension *dS_h = sub_copy_minus_dim_head(rdim,rdim->rank - minuSubdim);\
+    if(sizeInDim < dS_h->size){\
       dimension *dS_t = sub_copy_minus_dim_tail(rdim,minuSubdim);\
       tensor_##type *ret_ens = create_tensor_##type(dS_t);\
       /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-      ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       */if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->size + sizeInDim];\
         }\
       }else{\
-        /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
+        /*ret_ens->x = (rootens->x)+sizeInDim*dS_t->size;*/\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
       }\
@@ -1206,26 +1206,26 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     return NULL;\
   }\
   \
-  tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){\
-    /*return sub_copy_minus_tensor_head_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\
+  tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, size_t sub_copydim, size_t sizeInDim){\
+    /*return sub_copy_minus_tensor_head_##type(rootens,rootens->dim->rank - sub_copydim, sizeInDim);*/\
     dimension *rdim= rootens->dim;\
-    dimension *dS_t = sub_copy_dim_tail(rdim,rdim->size - sub_copydim);\
-    if(rankInDim < dS_t->rank){\
+    dimension *dS_t = sub_copy_dim_tail(rdim,rdim->rank - sub_copydim);\
+    if(sizeInDim < dS_t->size){\
       dimension *dS_h = sub_copy_dim_head(rdim,sub_copydim);\
       tensor_##type *ret_ens = create_tensor_##type(dS_h);\
       /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_h;\
-      ret_ens->x = malloc(sizeof(type)*dS_h->rank);\
+      ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       */if(littleEndian){\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_t->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_t->size + sizeInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->size, i,dS_h->size,i*dS_h->size + sizeInDim);*/\
         }\
       }else{\
-        /*ret_ens->x = (rootens->x)+rankInDim*dS_h->rank;*/\
-        for(size_t i=0; i<dS_h->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_h->rank * rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        /*ret_ens->x = (rootens->x)+sizeInDim*dS_h->size;*/\
+        for(size_t i=0; i<dS_h->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->size, i,dS_h->size,i*dS_h->size + sizeInDim);*/\
         }\
       \
       }\
@@ -1235,26 +1235,26 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
     free_dimension(dS_t);\
     return NULL;\
   }\
-  tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t rankInDim){ \
-    /*return sub_copy_minus_tensor_tail_##type(rootens,rootens->dim->size - sub_copydim, rankInDim);*/\
+  tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, size_t sub_copydim, size_t sizeInDim){ \
+    /*return sub_copy_minus_tensor_tail_##type(rootens,rootens->dim->rank - sub_copydim, sizeInDim);*/\
     dimension *rdim= rootens->dim;\
-    dimension *dS_h = sub_copy_dim_head(rdim,rdim->size - sub_copydim);\
-    if(rankInDim < dS_h->rank){\
+    dimension *dS_h = sub_copy_dim_head(rdim,rdim->rank - sub_copydim);\
+    if(sizeInDim < dS_h->size){\
       dimension *dS_t = sub_copy_dim_tail(rdim,sub_copydim);\
       tensor_##type *ret_ens = create_tensor_##type(dS_t);\
       /*tensor_##type *ret_ens = malloc(sizeof(tensor_##type));\
       ret_ens->dim = dS_t;\
-      ret_ens->x = malloc(sizeof(type)*dS_t->rank);\
+      ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       */if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i*dS_h->rank + rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i*dS_h->size + sizeInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->size, i,dS_h->size,i*dS_h->size + sizeInDim);*/\
         }\
       }else{\
-        /*ret_ens->x = (rootens->x)+rankInDim*dS_t->rank;*/\
-        for(size_t i=0; i<dS_t->rank; ++i){\
-          ret_ens->x[i]=rootens->x[i + dS_t->rank * rankInDim];\
-          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->rank, i,dS_h->rank,i*dS_h->rank + rankInDim);*/\
+        /*ret_ens->x = (rootens->x)+sizeInDim*dS_t->size;*/\
+        for(size_t i=0; i<dS_t->size; ++i){\
+          ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
+          /*printf("%ld: [i:%ld] | %ld : [%ld ]\n",dS_t->size, i,dS_h->size,i*dS_h->size + sizeInDim);*/\
         }\
       \
       }\
@@ -1267,7 +1267,7 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
   \
 void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
   /*size_t j=0 ,k=0*/;\
-  size_t *coord = malloc(sizeof(long int)*(T->dim)->size); \
+  size_t *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   /*char *dimsg=malloc(512);\
   sprintf(dimsg,"(%s)->dim",msg);\
@@ -1277,15 +1277,15 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
   long int (*iter)(long int) ;\
   bool (*cond)(long int, long int) ; \
   if (littleEndian ) {\
-        begin = (T->dim->size) - 1; end = 0;\
+        begin = (T->dim->rank) - 1; end = 0;\
         iter = decr; cond = isGreatEqThan; \
         /*printf("littleEndian(=true): the bigest index varies first, e.g:  [x0,x1,x2,...,xn] xn is the bigest index \n");*/\
   }else{\
-        begin = 0 ; end = (T->dim->size) - 1; \
+        begin = 0 ; end = (T->dim->rank) - 1; \
         iter = incr; cond = isLessEqThan; \
         /*printf("littleEndian(=false): the lowest index varies first, e.g:  [x0,x1,x2,...,xn] x0 is the lowest index \n");*/\
   }\
-  for(long int i=0;i<(T->dim)->rank;++i){\
+  for(long int i=0;i<(T->dim)->size;++i){\
     vCoordFromLin(coord,i,T->dim);\
     if(coord[begin]==0){\
       for(long int j=begin; cond(j,end); j= iter(j) ){\
@@ -1294,7 +1294,7 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
       }\
     }\
     /*printf(" [");\
-    for(size_t k=0; k<(T->dim)->size;++k) printf(" %ld",coord[k]);\
+    for(size_t k=0; k<(T->dim)->rank;++k) printf(" %ld",coord[k]);\
     */val=type##_TO_STR(T->x[i]);\
     printf(" |#%ld]: %s, ",i,val);\
     /*printf(" %s, ",val);*/\
@@ -1312,7 +1312,7 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
         }\
         else break;\
       }\
-      if(count == (T->dim)->size-1) printf("\n ");\
+      if(count == (T->dim)->rank-1) printf("\n ");\
     }\
   }\
   \
@@ -1324,7 +1324,7 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
 \
 void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
   /*size_t j=0,k=0;*/\
-  size_t *coord = malloc(sizeof(long int)*(T->dim)->size); \
+  size_t *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   FILE *fileWrite = fopen(file_name, "w");\
   if(fileWrite == NULL) {\
@@ -1335,20 +1335,20 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
   long int (*iter)(long int) ;\
   bool (*cond)(long int, long int) ; \
   if (littleEndian ) {\
-        begin = (T->dim->size) - 1; end = 0;\
+        begin = (T->dim->rank) - 1; end = 0;\
         iter = decr; cond = isGreatEqThan; \
         /*fprintf(fileWrite,"littleEndian(=true): the bigest index varies first, e.g:  [x0,x1,x2,...,xn] xn is the bigest index \n");*/\
   }else{\
-        begin = 0 ; end = (T->dim->size) - 1; \
+        begin = 0 ; end = (T->dim->rank) - 1; \
         iter = incr; cond = isLessEqThan; \
         /*fprintf(fileWrite,"littleEndian(=false): the lowest index varies first, e.g:  [x0,x1,x2,...,xn] x0 is the lowest index \n");*/\
   }\
     fprintf(fileWrite,"[");\
-  for(size_t i=0; i<(T->dim)->size; ++i)\
+  for(size_t i=0; i<(T->dim)->rank; ++i)\
     fprintf(fileWrite," %ld,", (T->dim)->shape[i]);\
   fprintf(fileWrite,"] \n");\
 \
-  for(long int i=0;i<(T->dim)->rank;++i){\
+  for(long int i=0;i<(T->dim)->size;++i){\
     vCoordFromLin(coord,i,T->dim);\
     if(coord[begin]==0){\
       for(long int j=begin; cond(j,end); j= iter(j) ){\
@@ -1362,7 +1362,7 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
       return;\
     }\
 /*fprintf(fileWrite," [");\
-    for(size_t k=0; k<(T->dim)->size;++k) fprintf(fileWrite," %ld,",coord[k]);\
+    for(size_t k=0; k<(T->dim)->rank;++k) fprintf(fileWrite," %ld,",coord[k]);\
     */val=type##_TO_STR(T->x[i]);\
     fprintf(fileWrite," %s, ",val);\
     free(val); val=NULL;\
@@ -1374,7 +1374,7 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
         }\
         else break;\
       }\
-      if(count == (T->dim)->size-1) fprintf(fileWrite,"\n ");\
+      if(count == (T->dim)->rank-1) fprintf(fileWrite,"\n ");\
     }\
   }\
   \
@@ -1388,17 +1388,17 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
     free(*tensorContent);\
     *tensorContent = NULL;  \
   }\
-  size_t sz = ((T->dim)->rank)*(32+ withIndex * 5*(T->dim)->size + 129 );\
-  /*printf("malloc %ld char\n",sz);*/\
-  *tensorContent = malloc(sz )  ;\
+  size_t rnk = ((T->dim)->size)*(32+ withIndex * 5*(T->dim)->rank + 129 );\
+  /*printf("malloc %ld char\n",rnk);*/\
+  *tensorContent = malloc(rnk )  ;\
   size_t cur=0;\
-  size_t *coord = malloc(sizeof(long int)*(T->dim)->size); \
+  size_t *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   long int begin , end /*, beginIter, endIter*/ ;\
   long int (*iter)(long int) ;\
   bool (*cond)(long int, long int) ; \
   if (littleEndian ) {\
-        begin = (T->dim->size) - 1; end = 0;\
+        begin = (T->dim->rank) - 1; end = 0;\
         iter = decr; cond = isGreatEqThan; \
         val=malloc(128);\
         sprintf(val,"littleEndian(=true): the bigest index varies first, e.g:  [x0,x1,x2,...,xn] xn is the bigest index \n");\
@@ -1406,7 +1406,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
           (*tensorContent)[cur++]=val[c];\
         free(val); val = NULL;\
   }else{\
-        begin = 0 ; end = (T->dim->size) - 1; \
+        begin = 0 ; end = (T->dim->rank) - 1; \
         iter = incr; cond = isLessEqThan; \
         val=malloc(128);\
         sprintf(val,"littleEndian(=false): the lowest index varies first, e.g:  [x0,x1,x2,...,xn] x0 is the lowest index \n");\
@@ -1414,7 +1414,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
           (*tensorContent)[cur++]=val[c];\
         free(val); val = NULL;\
   }\
-  for(long int i=0;i<(T->dim)->rank;++i){\
+  for(long int i=0;i<(T->dim)->size;++i){\
     vCoordFromLin(coord,i,T->dim);\
     if(coord[begin]==0){\
       for(long int j=begin; cond(j,end); j= iter(j) ){\
@@ -1426,7 +1426,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
     (*tensorContent)[cur++]=' ';\
    (*tensorContent)[cur++]='[';\
     (*tensorContent)[cur++]='{';\
-    for(size_t k=0; k<(T->dim)->size;++k) {\
+    for(size_t k=0; k<(T->dim)->rank;++k) {\
       /*printf(" %ld,",coord[k]);*/\
       val=TYPE_SIZE_T_TO_STR(coord[k]);\
       for(size_t c=0;c<strlen(val);++c){\
@@ -1466,7 +1466,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
         if(coord[j]==(T->dim)->shape[j]-1) {/*printf(")"); */ (*tensorContent)[cur++]=')'; ++count;}\
         else break;\
       }\
-      if(count == (T->dim)->size-1) {(*tensorContent)[cur++]='\n'; (*tensorContent)[cur++]=' ';}\
+      if(count == (T->dim)->rank-1) {(*tensorContent)[cur++]='\n'; (*tensorContent)[cur++]=' ';}\
     }\
   }\
   \
@@ -1478,8 +1478,8 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
   \
   \
 void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot){\
-  size_t sz = (Troot->dim)->size;\
-  if(pivotSplit < sz){\
+  size_t rnk = (Troot->dim)->rank;\
+  if(pivotSplit < rnk){\
     if( rangeInPivot < (Troot->dim)->shape[pivotSplit]){\
       dimension *dpart1, *dpart2;\
       split_dim_part(Troot->dim, &dpart1, &dpart2, pivotSplit, rangeInPivot);\
@@ -1489,8 +1489,8 @@ void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##
   }\
 }  \
 void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot){\
-  size_t sz = (Troot->dim)->size;\
-  if(pivotSplit < sz){\
+  size_t rnk = (Troot->dim)->rank;\
+  if(pivotSplit < rnk){\
     if( rangeInPivot < (Troot->dim)->shape[pivotSplit]){\
       dimension *dpart1, *dpart2;\
       split_dim_part(Troot->dim, &dpart1, &dpart2, pivotSplit, rangeInPivot);\
@@ -1506,15 +1506,15 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
     _recreate_tensor_if_not_the_same_dim_or_null_##type(MM,dd);  \
   tensor_##type *M = *MM; \
     size_t* coord;  \
-    coord = malloc(sizeof(size_t)*(dd->size));  \
+    coord = malloc(sizeof(size_t)*(dd->rank));  \
     size_t* coord0 , lin0;  \
-    coord0 = malloc(sizeof(size_t)* M0->dim->size);  \
+    coord0 = malloc(sizeof(size_t)* M0->dim->rank);  \
     size_t* coord1 , lin1;  \
-    coord1 = malloc(sizeof(size_t)* M1->dim->size);  \
-    for (size_t i = 0; i < dd->rank; i++) {  \
+    coord1 = malloc(sizeof(size_t)* M1->dim->rank);  \
+    for (size_t i = 0; i < dd->size; i++) {  \
         vCoordFromLin(coord, i, M->dim);  \
-        subArray(coord0, coord, 0, M0->dim->size, 0);  \
-        subArray(coord1, coord, 0, M1->dim->size, M0->dim->size);  \
+        subArray(coord0, coord, 0, M0->dim->rank, 0);  \
+        subArray(coord1, coord, 0, M1->dim->rank, M0->dim->rank);  \
           \
         lin0=LineFromCoord(coord0, M0->dim);  \
         lin1=LineFromCoord(coord1, M1->dim);  \
@@ -1532,12 +1532,12 @@ void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1)
     _recreate_tensor_if_not_the_same_dim_or_null_##type(MM,dd);  \
     tensor_##type *M = *MM; \
     size_t m_idx;\
-    for(size_t i=0; i<M0->dim->rank; ++i){\
-      for(size_t j=0; j<M1->dim->rank; ++j){\
+    for(size_t i=0; i<M0->dim->size; ++i){\
+      for(size_t j=0; j<M1->dim->size; ++j){\
           if(littleEndian)\
-            m_idx= i*M1->dim->rank + j ;\
+            m_idx= i*M1->dim->size + j ;\
           else\
-            m_idx= i+M0->dim->rank * j ;\
+            m_idx= i+M0->dim->size * j ;\
           M->x[m_idx]=M0->x[i]*M1->x[j];\
           /*printf("[%ld|%ld:(%ld,%ld)]",x_idx++,m_idx,i,j);*/\
       }\
@@ -1559,8 +1559,8 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
         getchar();\
     }\
 \
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1596,24 +1596,24 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
    \
 \
     size_t a0_id, a1_id, n0_id, n1_id;\
-    for (size_t i = 0; i < M->dim->rank; i++) {\
+    for (size_t i = 0; i < M->dim->size; i++) {\
         if(littleEndian){\
-          a0_id=i/dSub1->rank;\
-          a1_id=i%dSub1->rank;\
+          a0_id=i/dSub1->size;\
+          a1_id=i%dSub1->size;\
         }\
         else{\
-          a0_id=i%dSub0->rank;\
-          a1_id=i/dSub0->rank;\
+          a0_id=i%dSub0->size;\
+          a1_id=i/dSub0->size;\
         }\
         M->x[i] = 0;\
-        for (size_t k = 0; k < dM->rank; k++) {\
+        for (size_t k = 0; k < dM->size; k++) {\
           if(littleEndian){\
-            n0_id= a0_id*dM->rank + k;\
-            n1_id= a1_id + dSub1->rank * k;\
+            n0_id= a0_id*dM->size + k;\
+            n1_id= a1_id + dSub1->size * k;\
           }\
           else{\
-            n0_id= a0_id + dSub0->rank * k;\
-            n1_id= a1_id*dM->rank + k;\
+            n0_id= a0_id + dSub0->size * k;\
+            n1_id= a1_id*dM->size + k;\
           }\
             M->x[i] += M0->x[n0_id] * M1->x[n1_id];\
             \
@@ -1637,8 +1637,8 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
         getchar();\
     }\
 \
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1674,34 +1674,34 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
    \
 \
     size_t a0_id, a1_id, n0_id, n1_id;\
-    for (size_t i = 0; i < M->dim->rank; i++) {\
+    for (size_t i = 0; i < M->dim->size; i++) {\
         if(littleEndian){\
-          a0_id=i/dSub1->rank;\
-          a1_id=i%dSub1->rank;\
-          n0_id=a0_id*dM->rank ;\
+          a0_id=i/dSub1->size;\
+          a1_id=i%dSub1->size;\
+          n0_id=a0_id*dM->size ;\
           n1_id= a1_id ;\
         }\
         else{\
-          a0_id=i%dSub0->rank;\
-          a1_id=i/dSub0->rank;\
-          n1_id= a1_id*dM->rank ;\
+          a0_id=i%dSub0->size;\
+          a1_id=i/dSub0->size;\
+          n1_id= a1_id*dM->size ;\
           n0_id= a0_id ;\
         }\
         M->x[i] = 0;\
-        for (size_t k = 0; k < dM->rank; k++) {\
+        for (size_t k = 0; k < dM->size; k++) {\
           if(littleEndian){\
-            /*n0_id= a0_id*dM->rank + k;*/\
-            /*n1_id= a1_id + dSub1->rank * k;*/\
+            /*n0_id= a0_id*dM->size + k;*/\
+            /*n1_id= a1_id + dSub1->size * k;*/\
             /*M->x[i] += M0->x[begin0++] * M1->x[n1_id];*/\
             M->x[i] += M0->x[n0_id++] * M1->x[n1_id];\
-            n1_id +=dSub1->rank ;\
+            n1_id +=dSub1->size ;\
           }\
           else{\
-            /*n0_id= a0_id + dSub0->rank * k;*/\
-            /*n1_id= a1_id*dM->rank + k;*/\
+            /*n0_id= a0_id + dSub0->size * k;*/\
+            /*n1_id= a1_id*dM->size + k;*/\
             /*M->x[i] += M0->x[n0_id] * M1->x[begin1++];*/\
             M->x[i] += M0->x[n0_id] * M1->x[n1_id++];\
-            n0_id += dSub0->rank ;\
+            n0_id += dSub0->size ;\
           }\
             \
         }\
@@ -1750,15 +1750,15 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
-    arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
-    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
-    else arg_th[i]->endRange = M->dim->rank ;\
+    arg_th[i]->beginRange = i*(M->dim->size)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M->dim->size)/nbthread ;\
+    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->size)/nbthread ;\
+    else arg_th[i]->endRange = M->dim->size ;\
     */if(littleEndian){\
-      arg_th[i]->MRank = M1->dim->rank;\
+      arg_th[i]->MRank = M1->dim->size;\
     }\
     else{\
-      arg_th[i]->MRank = M0->dim->rank;\
+      arg_th[i]->MRank = M0->dim->size;\
     }\
     pthread_create(&thrd[i], NULL, runProd_thread_##type, (void*)arg_th[i]);\
   }\
@@ -1813,12 +1813,12 @@ void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##ty
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-    arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
-    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
-    else arg_th[i]->endRange = M0->dim->rank ;\
-    */arg_th[i]->M1Rank = M1->dim->rank;\
-      arg_th[i]->M0Rank = M0->dim->rank;\
+    arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
+    /*if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
+    else arg_th[i]->endRange = M0->dim->size ;\
+    */arg_th[i]->M1Rank = M1->dim->size;\
+      arg_th[i]->M0Rank = M0->dim->size;\
     pthread_create(&thrd[i], NULL, runProd_thread2d_##type, (void*)arg_th[i]);\
   }\
 \
@@ -1879,8 +1879,8 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
         printDebug_dimension(M1->dim, "M1 dim");\
         getchar();\
     }\
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1913,16 +1913,16 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
-    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
-    else arg_th[i]->endRange = M->dim->rank ;\
+    arg_th[i]->beginRange = i*(M->dim->size)/nbthread ;\
+    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->size)/nbthread ;\
+    else arg_th[i]->endRange = M->dim->size ;\
     if(littleEndian){\
-      arg_th[i]->dSubRank = dSub1->rank;\
+      arg_th[i]->dSubRank = dSub1->size;\
     }\
     else{\
-      arg_th[i]->dSubRank = dSub0->rank;\
+      arg_th[i]->dSubRank = dSub0->size;\
     }\
-    arg_th[i]->dMRank = dM->rank;\
+    arg_th[i]->dMRank = dM->size;\
     pthread_create(&thrd[i], NULL, runProdContract_thread_##type, (void*)arg_th[i]);\
   }\
 \
@@ -1976,8 +1976,8 @@ void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0,
         printDebug_dimension(M1->dim, "M1 dim");\
         getchar();\
     }\
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -2010,16 +2010,16 @@ void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0,
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(M->dim->rank)/nbthread ;\
-    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->rank)/nbthread ;\
-    else arg_th[i]->endRange = M->dim->rank ;\
+    arg_th[i]->beginRange = i*(M->dim->size)/nbthread ;\
+    if(i < nbthread - 1 ) arg_th[i]->endRange = (i+1)*(M->dim->size)/nbthread ;\
+    else arg_th[i]->endRange = M->dim->size ;\
     if(littleEndian){\
-      arg_th[i]->dSubRank = dSub1->rank;\
+      arg_th[i]->dSubRank = dSub1->size;\
     }\
     else{\
-      arg_th[i]->dSubRank = dSub0->rank;\
+      arg_th[i]->dSubRank = dSub0->size;\
     }\
-    arg_th[i]->dMRank = dM->rank;\
+    arg_th[i]->dMRank = dM->size;\
     pthread_create(&thrd[i], NULL, runProdContractOpt0_thread_##type, (void*)arg_th[i]);\
   }\
 \
@@ -2084,8 +2084,8 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
         getchar();\
     }\
 \
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -2118,11 +2118,11 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(dSub0->rank)/nbthread ;\
-    arg_th[i]->endRange = (i+1)*(dSub0->rank)/nbthread ;\
-    arg_th[i]->dSub1Rank = dSub1->rank;\
-    arg_th[i]->dSub0Rank = dSub0->rank;\
-    arg_th[i]->dMRank = dM->rank;\
+    arg_th[i]->beginRange = i*(dSub0->size)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(dSub0->size)/nbthread ;\
+    arg_th[i]->dSub1Rank = dSub1->size;\
+    arg_th[i]->dSub0Rank = dSub0->size;\
+    arg_th[i]->dMRank = dM->size;\
     pthread_create(&thrd[i], NULL, runPro2dContract_thread_##type, (void*)arg_th[i]);\
   }\
 \
@@ -2184,8 +2184,8 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
         getchar();\
     }\
 \
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -2218,11 +2218,11 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
     arg_th[i]->Mx=M->x;\
-    arg_th[i]->beginRange = i*(dSub0->rank)/nbthread ;\
-    arg_th[i]->endRange = (i+1)*(dSub0->rank)/nbthread ;\
-    arg_th[i]->dSub1Rank = dSub1->rank;\
-    arg_th[i]->dSub0Rank = dSub0->rank;\
-    arg_th[i]->dMRank = dM->rank;\
+    arg_th[i]->beginRange = i*(dSub0->size)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(dSub0->size)/nbthread ;\
+    arg_th[i]->dSub1Rank = dSub1->size;\
+    arg_th[i]->dSub0Rank = dSub0->size;\
+    arg_th[i]->dMRank = dM->size;\
     pthread_create(&thrd[i], NULL, runPro2dContractOpt0_thread_##type, (void*)arg_th[i]);\
   }\
 \
@@ -2242,8 +2242,8 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
         printDebug_dimension(M1->dim, "M1 dim");\
         getchar();\
     }\
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
+    size_t len0 = M0->dim->rank - contractionNumber;\
+    size_t len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -2277,7 +2277,7 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
     tensor_##type *M= *MM;\
 \
     size_t* coord;\
-    coord = malloc(sizeof(size_t)* M->dim->size);\
+    coord = malloc(sizeof(size_t)* M->dim->rank);\
 \
     size_t* coord0 , lin0;\
     coord0 = malloc(sizeof(size_t)* len0);\
@@ -2285,19 +2285,19 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
     coord1 = malloc(sizeof(size_t)* len1);\
 \
     size_t* coordM0 ;\
-    coordM0 = malloc(sizeof(size_t)* M0->dim->size);\
+    coordM0 = malloc(sizeof(size_t)* M0->dim->rank);\
     size_t* coordM1 ;\
-    coordM1 = malloc(sizeof(size_t)* M1->dim->size);\
+    coordM1 = malloc(sizeof(size_t)* M1->dim->rank);\
 \
     size_t* Koord ;\
     Koord = malloc(sizeof(size_t)* contractionNumber);\
 \
-    for (size_t i = 0; i < M->dim->rank; i++) {\
+    for (size_t i = 0; i < M->dim->size; i++) {\
         vCoordFromLin(coord, i, M->dim);\
         subArray(coord0, coord, 0, len0, 0);\
         subArray(coord1, coord, 0, len1, len0);\
         M->x[i] = 0;\
-        for (size_t k = 0; k < dM->rank; k++) {\
+        for (size_t k = 0; k < dM->size; k++) {\
             vCoordFromLin(Koord, k, dM);\
             concatArray(coordM0, coord0, Koord, 0, 0, len0, 0, contractionNumber);\
             concatArray(coordM1, Koord, coord1, 0, 0, contractionNumber, 0, len1);\
@@ -2316,23 +2316,23 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
     FREE_dM_S_ ; \
 }\
 \
-/* dot product = of 2 tensors same dimensions M0, M1, dim0, dim1 == contract (dim0 size) product of M0' M1' of dim0' and dim1' / dim0->shape = [1, dim0-> shape] and  dim1'->shape = [dim1->shape, 1] */ \
+/* dot product = of 2 tensors same dimensions M0, M1, dim0, dim1 == contract (dim0 rank) product of M0' M1' of dim0' and dim1' / dim0->shape = [1, dim0-> shape] and  dim1'->shape = [dim1->shape, 1] */ \
 type scalarProduct_dep_contractProd_##type(tensor_##type *M0, tensor_##type *M1, size_t nbthreads ,void (*tensorContractVar)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread )){\
   type ret = 0;\
   if(is_equal_dim(M0->dim, M1->dim)){/* */\
-    dimension * d0 = create_dim(M0->dim->size + 1);\
-    dimension * d1 = create_dim(M1->dim->size + 1);\
+    dimension * d0 = create_dim(M0->dim->rank + 1);\
+    dimension * d1 = create_dim(M1->dim->rank + 1);\
     size_t i;\
     d0->shape[0] = 1;\
-    for(i=0; i<M0->dim->size; ++i) d0->shape[i+1] = M0->dim->shape[i];\
-    for(i=0; i<M1->dim->size; ++i) d1->shape[i] = M1->dim->shape[i];\
+    for(i=0; i<M0->dim->rank; ++i) d0->shape[i+1] = M0->dim->shape[i];\
+    for(i=0; i<M1->dim->rank; ++i) d1->shape[i] = M1->dim->shape[i];\
     d1->shape[i] = 1;\
     tensor_##type *M_0=create_tensor_##type(d0);\
     tensor_##type *M_1=create_tensor_##type(d1);\
     copy_tensor_##type(M_0,M0);\
     copy_tensor_##type(M_1,M1);\
     tensor_##type *M_=NULL;\
-    tensorContractVar(&M_,M_0,M_1,M0->dim->size,nbthreads);\
+    tensorContractVar(&M_,M_0,M_1,M0->dim->rank,nbthreads);\
     ret = M_->x[0];\
     free_tensor_##type(M_0);\
     free_tensor_##type(M_1);\
@@ -2354,10 +2354,10 @@ tensor_##type * parseInput_withDim_to_tensor_##type(char *input){\
   size_t ss;\
   char *ttmp=input;\
   char *ppEnd="[";\
-  bool size_unknown=false; \
+  bool unknown_shape=false; \
   for(size_t i=0; i<len ; ++i){\
     if(input[i]==']') break;\
-    if((input[i]=='*') ||(input[i]=='_')){ size_unknown =true; break;}\
+    if((input[i]=='*') ||(input[i]=='_')){ unknown_shape =true; break;}\
   }\
   while(ppEnd && (ppEnd[0] !=']') ){\
     ss = strtoul(ttmp, &ppEnd, 10);\
@@ -2375,12 +2375,12 @@ tensor_##type * parseInput_withDim_to_tensor_##type(char *input){\
 \
   ttmp++; ppEnd++;\
 \
-  if(size_unknown == false){\
+  if(unknown_shape == false){\
     tens = create_tensor_##type(dim);\
   \
     size_t i=0;\
     type x;\
-    while(ppEnd && (ppEnd[0] !='\0') && i<dim->rank){\
+    while(ppEnd && (ppEnd[0] !='\0') && i<dim->size){\
       x = strto_##type(ttmp, &ppEnd);\
       while(ttmp == ppEnd && ppEnd[0] !='\0'){\
         ttmp++;\
@@ -2426,10 +2426,10 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
   size_t ss;\
   char *ttmp=input;\
   char *ppEnd="[";\
-  bool size_unknown=false; \
+  bool unknown_shape=false; \
   for(size_t i=0; i<len ; ++i){\
     if(input[i]==']') break;\
-    if((input[i]=='*') ||(input[i]=='_')){ size_unknown =true; break;}\
+    if((input[i]=='*') ||(input[i]=='_')){ unknown_shape =true; break;}\
   }\
   while(ppEnd && (ppEnd[0] !=']') ){\
     ss = strtoul(ttmp, &ppEnd, 10);\
@@ -2447,21 +2447,21 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
 \
   ttmp++; ppEnd++;\
 \
-  if(size_unknown == false){\
-    /*dimension *dim1 = create_dim(dim->size-1);\
-    dimension *ddim1 = create_dim(dim->size-2);\
-    dimension *ddim2 = create_dim(dim->size-2);\
+  if(unknown_shape == false){\
+    /*dimension *dim1 = create_dim(dim->rank-1);\
+    dimension *ddim1 = create_dim(dim->rank-2);\
+    dimension *ddim2 = create_dim(dim->rank-2);\
     dimension *dim2 = create_dim(2);\
-    */dimension *dim1 = create_dim(dim->size-pivotSplit);\
-    dimension *ddim1 = create_dim(dim->size-pivotSplit-1);\
+    */dimension *dim1 = create_dim(dim->rank-pivotSplit);\
+    dimension *ddim1 = create_dim(dim->rank-pivotSplit-1);\
     dimension *ddim2 = create_dim(pivotSplit);\
     dimension *dim2 = create_dim(pivotSplit+1);\
-    for(size_t i=0;i<dim1->size;++i) dim1->shape[i] = dim->shape[i];\
-    for(size_t i=0;i<ddim1->size;++i) ddim1->shape[i] = dim->shape[i+1];\
-    for(size_t i=0;i<ddim2->size;++i) ddim2->shape[i] = dim->shape[ dim->size - pivotSplit + i];\
+    for(size_t i=0;i<dim1->rank;++i) dim1->shape[i] = dim->shape[i];\
+    for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i+1];\
+    for(size_t i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[ dim->rank - pivotSplit + i];\
     dim2->shape[0] = dim->shape[0];\
-    for(size_t i=1;i<dim2->size;++i) dim2->shape[i] = ddim2->shape[i-1];\
-    /*dim2->shape[1] = dim->shape[dim->size - 1];*/\
+    for(size_t i=1;i<dim2->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
+    /*dim2->shape[1] = dim->shape[dim->rank - 1];*/\
     updateRankDim(dim1);\
     updateRankDim(ddim1);\
     updateRankDim(ddim2);\
@@ -2472,7 +2472,7 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
     size_t i1=0,i=0,j=0,i2=0;\
     bool filled1=false,filled2=false;\
     type x;\
-    while(ppEnd && (ppEnd[0] !='\0') && j<dim2->rank){\
+    while(ppEnd && (ppEnd[0] !='\0') && j<dim2->size){\
       x = strto_##type(ttmp, &ppEnd);\
       while(ttmp == ppEnd && ppEnd[0] !='\0'){\
         ttmp++;\
@@ -2482,8 +2482,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
         if(!filled1){\
           ++i1;\
           (*Tpart1)->x[i++] = x;\
-          /*printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->rank);\
-          */if(i1 == ddim1->rank){\
+          /*printf("++ x: %f, i1:%ld , rkn1: %ld\n",x,i1,ddim1->size);\
+          */if(i1 == ddim1->size){\
             filled1=true;\
             i1=0;\
             filled2=false;\
@@ -2492,8 +2492,8 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
           if(!filled2){\
             ++i2;\
             (*Tpart2)->x[j++] = x;\
-            /*printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->rank);\
-            */if(i2 == ddim2->rank){\
+            /*printf("-----++ x: %f, i2:%ld , rknr: %ld\n",x,i2,ddim2->size);\
+            */if(i2 == ddim2->size){\
               filled2=true;\
               i2=0;\
               filled1=false;\
@@ -2509,14 +2509,14 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
     free_dimension(ddim2);\
   }\
   else{\
-    /*dimension *ddim1 = create_dim(dim->size-1);\
+    /*dimension *ddim1 = create_dim(dim->rank-1);\
     dimension *ddim2 = create_dim(1);\
-    for(size_t i=0;i<ddim1->size;++i) ddim1->shape[i] = dim->shape[i];\
-    ddim2->shape[0] = dim->shape[dim->size - 1];\
-    */dimension *ddim1 = create_dim(dim->size-pivotSplit);\
+    for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+    ddim2->shape[0] = dim->shape[dim->rank - 1];\
+    */dimension *ddim1 = create_dim(dim->rank-pivotSplit);\
     dimension *ddim2 = create_dim(pivotSplit);\
-    for(size_t i=0;i<ddim1->size;++i) ddim1->shape[i] = dim->shape[i];\
-    for(size_t i=0;i<ddim2->size;++i) ddim2->shape[i] = dim->shape[dim->size - pivotSplit + i];\
+    for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+    for(size_t i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[dim->rank - pivotSplit + i];\
     updateRankDim(ddim1);\
     updateRankDim(ddim2);\
     array_chainlist_##type *l_a1=NULL;\
@@ -2537,7 +2537,7 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
           append_array_chainlist_##type(&l_a1, x);\
           /*printf("++ x: %f, i1:%ld\n",x,i1);*/\
           /*(*Tpart1)->x[i++] = x;*/\
-          if(i1 == ddim1->rank){\
+          if(i1 == ddim1->size){\
             filled1=true;\
             i1=0;\
             filled2=false;\
@@ -2548,7 +2548,7 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
             /*(*Tpart2)->x[j++] = x;*/\
             append_array_chainlist_##type(&l_a2, x);\
             /*printf("++ x: %f, i2:%ld\n",x,i2);*/\
-            if(i2 == ddim2->rank){\
+            if(i2 == ddim2->size){\
               filled2 = true;\
               i2=0;\
               filled1 = false;\
@@ -2586,7 +2586,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     fprintf( stderr, "Cannot open file: %s for reading\n",file_name_input );\
     exit( -1 );\
   }\
-  bool size_unknown=false, broken=false; \
+  bool unknown_shape=false, broken=false; \
   bool Done=false;\
   int retfread = 0, curIn=0;\
   while(!Done){\
@@ -2604,7 +2604,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     for(size_t i=0; i<len ; ++i){\
       if(iinput[i]==']') {broken = true; break;}\
       if((iinput[i]=='*') ||(iinput[i]=='_')){ \
-        broken=true;  size_unknown =true;\
+        broken=true;  unknown_shape =true;\
         break;\
       }\
     }\
@@ -2659,18 +2659,18 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
     }\
     if(bracketsDown){\
   \
-      if(size_unknown == false){\
+      if(unknown_shape == false){\
         \
         if(!initDim){\
-          dim1 = create_dim(dim->size-pivotSplit);\
-          ddim1 = create_dim(dim->size-pivotSplit-1);\
+          dim1 = create_dim(dim->rank-pivotSplit);\
+          ddim1 = create_dim(dim->rank-pivotSplit-1);\
           ddim2 = create_dim(pivotSplit);\
           dim2 = create_dim(pivotSplit+1);\
-          for(size_t i=0;i<dim1->size;++i) dim1->shape[i] = dim->shape[i];\
-          for(size_t i=0;i<ddim1->size;++i) ddim1->shape[i] = dim->shape[i+1];\
-          for(size_t i=0;i<ddim2->size;++i) ddim2->shape[i] = dim->shape[ dim->size - pivotSplit + i];\
+          for(size_t i=0;i<dim1->rank;++i) dim1->shape[i] = dim->shape[i];\
+          for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i+1];\
+          for(size_t i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[ dim->rank - pivotSplit + i];\
           dim2->shape[0] = dim->shape[0];\
-          for(size_t i=1;i<dim2->size;++i) dim2->shape[i] = ddim2->shape[i-1];\
+          for(size_t i=1;i<dim2->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
           updateRankDim(dim1);\
           updateRankDim(ddim1);\
           updateRankDim(ddim2);\
@@ -2681,7 +2681,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
         }\
       \
         type x;\
-        while(strlen(ttmp) && j<dim2->rank){ \
+        while(strlen(ttmp) && j<dim2->size){ \
           x = strto_##type(ttmp, &ppEnd);\
           while(ttmp == ppEnd && strlen(ttmp)){\
             ttmp++;\
@@ -2691,7 +2691,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
             if(!filled1){\
               ++i1;\
               (*Tpart1)->x[i++] = x;\
-              if(i1 == ddim1->rank){\
+              if(i1 == ddim1->size){\
                 filled1=true;\
                 i1=0;\
                 filled2=false;\
@@ -2700,7 +2700,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
               if(!filled2){\
                 ++i2;\
                 (*Tpart2)->x[j++] = x;\
-                if(i2 == ddim2->rank){\
+                if(i2 == ddim2->size){\
                   filled2=true;\
                   i2=0;\
                   filled1=false;\
@@ -2719,10 +2719,10 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
       else{\
         \
         if(!initDim){\
-          ddim1 = create_dim(dim->size-pivotSplit);\
+          ddim1 = create_dim(dim->rank-pivotSplit);\
           ddim2 = create_dim(pivotSplit);\
-          for(size_t i=0;i<ddim1->size;++i) ddim1->shape[i] = dim->shape[i];\
-          for(size_t i=0;i<ddim2->size;++i) ddim2->shape[i] = dim->shape[dim->size - pivotSplit + i];\
+          for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+          for(size_t i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[dim->rank - pivotSplit + i];\
           updateRankDim(ddim1);\
           updateRankDim(ddim2);\
           initDim=true;\
@@ -2738,7 +2738,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
             if(!filled1){\
               ++i1;\
               append_array_chainlist_##type(&l_a1, x);\
-              if(i1 == ddim1->rank){\
+              if(i1 == ddim1->size){\
                 filled1=true;\
                 i1=0;\
                 filled2=false;\
@@ -2747,7 +2747,7 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
               if(!filled2){\
                 ++i2;\
                 append_array_chainlist_##type(&l_a2, x);\
-                if(i2 == ddim2->rank){\
+                if(i2 == ddim2->size){\
                   filled2 = true;\
                   i2=0;\
                   filled1 = false;\
@@ -2780,12 +2780,12 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
 \
 tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens){\
   tensor_##type **re_tens=malloc((tens->dim)->shape[0]*sizeof(tensor_##type *));\
-  dimension *dim=create_dim((tens->dim)->size - 1);\
-  for(size_t i=0; i<dim->size; ++i) dim->shape[i]=(tens->dim)->shape[i+1];\
+  dimension *dim=create_dim((tens->dim)->rank - 1);\
+  for(size_t i=0; i<dim->rank; ++i) dim->shape[i]=(tens->dim)->shape[i+1];\
   updateRankDim(dim);\
   for(size_t i=0; i < (tens->dim)->shape[0];++i){\
     re_tens[i]=create_tensor_from_cpy_dim_##type(dim);\
-    for(size_t j=0; j<dim->rank; ++j) (re_tens[i])->x[j] = tens->x[i*(dim->rank) + j ] ;\
+    for(size_t j=0; j<dim->size; ++j) (re_tens[i])->x[j] = tens->x[i*(dim->size) + j ] ;\
   }\
   free_dimension(dim);\
   return re_tens;\
@@ -2811,14 +2811,14 @@ tensor_##type * create_tensor_from_list_array_##type( array_chainlist_##type *l_
   if(l_a){\
     array_chainlist_##type *tmp =l_a;\
     while(tmp->next) tmp=tmp->next;\
-    size_t miss_part_d=(tmp->index + 1)/part_dim->rank;\
-    dimension *dim=create_dim(part_dim->size + 1);\
+    size_t miss_part_d=(tmp->index + 1)/part_dim->size;\
+    dimension *dim=create_dim(part_dim->rank + 1);\
     if(littleEndian){\
       dim->shape[0]=miss_part_d;\
-      for(size_t i=0; i<part_dim->size;++i) dim->shape[i+1]=part_dim->shape[i];\
+      for(size_t i=0; i<part_dim->rank;++i) dim->shape[i+1]=part_dim->shape[i];\
     }else{\
       size_t i=0;\
-      for(i=0; i<part_dim->size;++i) dim->shape[i]=part_dim->shape[i];\
+      for(i=0; i<part_dim->rank;++i) dim->shape[i]=part_dim->shape[i];\
       dim->shape[i]=miss_part_d;\
       \
     }\
@@ -2844,17 +2844,17 @@ void free_array_chainlist_##type(array_chainlist_##type *l_a){\
 }\
 \
 tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
-  size_t dimsz = (org->dim)->size; \
-  dimension *dim_tr=create_dim(dimsz);\
-  for(size_t i=0; i<dimsz; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimsz-1)-i];\
+  size_t dimrnk = (org->dim)->rank; \
+  dimension *dim_tr=create_dim(dimrnk);\
+  for(size_t i=0; i<dimrnk; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimrnk-1)-i];\
   updateRankDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_tr");\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
-  size_t *coord = malloc((dimsz)*sizeof(size_t));\
-  size_t *coord_tr = malloc((dimsz)*sizeof(size_t));\
-  for(size_t i=0; i<dim_tr->rank; ++i){\
+  size_t *coord = malloc((dimrnk)*sizeof(size_t));\
+  size_t *coord_tr = malloc((dimrnk)*sizeof(size_t));\
+  for(size_t i=0; i<dim_tr->size; ++i){\
     vCoordFromLin(coord,i,org->dim);\
-    for(size_t j=0; j<dimsz;++j)  coord_tr[j]=coord[dimsz-1-j]; \
+    for(size_t j=0; j<dimrnk;++j)  coord_tr[j]=coord[dimrnk-1-j]; \
     tens_tr->x[LineFromCoord(coord_tr, dim_tr)] = org->x[i];\
   }\
   free(coord);\
@@ -2863,17 +2863,17 @@ tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
 }\
 \
 tensor_##type * shapeute_notOpt_tensor_##type(tensor_##type *org, dimension *dshape){\
-  size_t dimsz = (org->dim)->size; \
-  dimension *dim_tr=create_dim(dimsz);\
-  for(size_t i=0; i<dimsz; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimsz-1)-i];\
+  size_t dimrnk = (org->dim)->rank; \
+  dimension *dim_tr=create_dim(dimrnk);\
+  for(size_t i=0; i<dimrnk; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimrnk-1)-i];\
   updateRankDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_tr");\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
-  size_t *coord = malloc((dimsz)*sizeof(size_t));\
-  size_t *coord_tr = malloc((dimsz)*sizeof(size_t));\
-  for(size_t i=0; i<dim_tr->rank; ++i){\
+  size_t *coord = malloc((dimrnk)*sizeof(size_t));\
+  size_t *coord_tr = malloc((dimrnk)*sizeof(size_t));\
+  for(size_t i=0; i<dim_tr->size; ++i){\
     vCoordFromLin(coord,i,org->dim);\
-    for(size_t j=0; j<dimsz;++j)  coord_tr[j]=coord[dshape->shape[j]]; \
+    for(size_t j=0; j<dimrnk;++j)  coord_tr[j]=coord[dshape->shape[j]]; \
     tens_tr->x[LineFromCoord(coord_tr, dim_tr)] = org->x[i];\
   }\
   free(coord);\
@@ -2903,8 +2903,8 @@ void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nb
     arg_th[i]=malloc(sizeof(struct arg_1Update_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->func=func;\
-    arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-    arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+    arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+    arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
     \
     pthread_create(&thrd[i], NULL, run1UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
   }\
@@ -2943,8 +2943,8 @@ void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*fun
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
       arg_th[i]->func=func;\
-      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
       \
       pthread_create(&thrd[i], NULL, run2UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
@@ -2986,8 +2986,8 @@ void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       arg_th[i]->M1x=M1->x;\
       arg_th[i]->M2x=M2->x;\
       arg_th[i]->func=func;\
-      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
       \
       pthread_create(&thrd[i], NULL, run3UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
@@ -3024,7 +3024,7 @@ void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
     type (*func)(type, type,  type(*f1)(type)),\
     type(*f1)(type),\
     size_t nbthread){\
-  /*printf(" rankM0=%ld , rank M2:%ld ; iseq :%d \n",(M0->dim)->rank,(M2->dim)->rank,is_equal_dim(M0->dim,M2->dim) );\
+  /*printf(" sizeM0=%ld , size M2:%ld ; iseq :%d \n",(M0->dim)->size,(M2->dim)->size,is_equal_dim(M0->dim,M2->dim) );\
 */\
    /* printDebug_dimension(M0->dim," dim M0 in update4 ");  \
     printDebug_dimension(M2->dim," dim M2 in update4 ");  \
@@ -3040,8 +3040,8 @@ void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       arg_th[i]->M2x=M2->x;\
       arg_th[i]->func=func;\
       arg_th[i]->f1=f1;\
-      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
       \
       pthread_create(&thrd[i], NULL, run4UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
@@ -3093,8 +3093,8 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       arg_th[i]->func=func;\
       arg_th[i]->f1=f1;\
       arg_th[i]->f2=f2;\
-      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
       \
       pthread_create(&thrd[i], NULL, run5UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
@@ -3130,7 +3130,7 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
     type (*func)(type, type, type),\
     type scalar,\
     size_t nbthread){\
-  /*printf(" rankM0=%ld , rank M2:%ld ; iseq :%d \n",(M0->dim)->rank,(M2->dim)->rank,is_equal_dim(M0->dim,M2->dim) );\
+  /*printf(" sizeM0=%ld , size M2:%ld ; iseq :%d \n",(M0->dim)->size,(M2->dim)->size,is_equal_dim(M0->dim,M2->dim) );\
 */\
    /* printDebug_dimension(M0->dim," dim M0 in update6 ");  \
     printDebug_dimension(M2->dim," dim M2 in update6 ");  \
@@ -3145,8 +3145,8 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
       arg_th[i]->M1x=M1->x;\
       arg_th[i]->func=func;\
       arg_th[i]->scalar=scalar;\
-      arg_th[i]->beginRange = i*(M0->dim->rank)/nbthread ;\
-      arg_th[i]->endRange = (i+1)*(M0->dim->rank)/nbthread ;\
+      arg_th[i]->beginRange = i*(M0->dim->size)/nbthread ;\
+      arg_th[i]->endRange = (i+1)*(M0->dim->size)/nbthread ;\
       \
       pthread_create(&thrd[i], NULL, run6UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\