From a2d44bd71d4c0fcde7c7faf3079ded62714f5572 Mon Sep 17 00:00:00 2001
From: fanasina <rafanasin@gmail.com>
Date: Sun, 2 Aug 2026 22:22:12 +0200
Subject: [PATCH] [update] use long instead of size_t if possible

---
 onetensor/y_tensor_h.h | 662 ++++++++++++++++++++---------------------
 1 file changed, 331 insertions(+), 331 deletions(-)

diff --git a/onetensor/y_tensor_h.h b/onetensor/y_tensor_h.h
index f5459d0..f4e3e80 100644
--- a/onetensor/y_tensor_h.h
+++ b/onetensor/y_tensor_h.h
@@ -6,11 +6,11 @@
 #include "../list_t/list_t.h"
 
 struct dimension{
-  size_t rank;
-  size_t *shape;
+  long rank;
+  long *shape;
   long int *basis;
-  size_t basis_rank;
-  size_t size;
+  long basis_rank;
+  long size;
 };
 
 
@@ -27,26 +27,26 @@ long int decr(long int i) ;
 
 typedef struct dimension dimension ;
 
-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 * create_dim(long rank);
+dimension * create_reverse_dim(long rank);
+dimension* init_dim(long *t, long rnk);
+dimension* init_copy_dim(long *t, long rnk);
 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_minus_dim_head(dimension *t, long minusSubdim);
+dimension* sub_minus_dim_tail(dimension *t, long minusSubdim);
+dimension* sub_dim_head(dimension *t, long subdim);
+dimension* sub_dim_tail(dimension *t, long 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);
+dimension* sub_copy_minus_dim_head(dimension *t, long minusSubdim);
+dimension* sub_copy_minus_dim_tail(dimension *t, long minusSubdim);
+dimension* sub_copy_dim_head(dimension *t, long sub_copydim);
+dimension* sub_copy_dim_tail(dimension *t, long sub_copydim);
 
-void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, size_t pivotSplit, size_t rangeInPivot );
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, long pivotSplit, long rangeInPivot );
 
 void add_copy_dimension(dimension **d, dimension *d0, dimension *d1);
 void min_copy_dimension(dimension **d, dimension *d0, dimension *d1);
@@ -55,13 +55,13 @@ 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);
+long sprint_dimension(char **dimContent, dimension *d);
 
 void updateDim(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 LineFromCoord(long *coo, dimension *dim);
+size_t* CoordFromLin(long line, dimension *dim);
+void vCoordFromLin(long *ret, long line, dimension *dim );
 
 long int signedLineFromCoord(long *coo, dimension *dim);
 long int* signedCoordFromLin(long line, dimension *dim);
@@ -72,17 +72,17 @@ void increment_dim_var(dimension *d);
 void decrement_dim_var(dimension *d);
 
 struct list_shape_in_dim{
-  size_t index;
-  size_t shape;
+  long index;
+  long 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);
+void append_in_list_shape(list_shape_in_dim **list_p, long shape);
 dimension * create_dim_from_list_shape( list_shape_in_dim *l_p);
 
-dimension * create_binary_dim(size_t dimension_rank);
+dimension * create_binary_dim(long dimension_rank);
 
 void free_list_shape_in_dim(list_shape_in_dim *l_p);
 
@@ -113,7 +113,7 @@ 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 rnk){\
+dimension* init_dim(long *t, long rnk){\
   dimension *d = malloc(sizeof(dimension));\
   d->rank=rnk;\
   d->shape=t;\
@@ -123,19 +123,19 @@ dimension* init_dim(size_t *t, size_t rnk){\
   return d;\
 }\
 \
-dimension* init_copy_dim(size_t *t, size_t rnk){\
+dimension* init_copy_dim(long *t, long rnk){\
   if (rnk==0) return NULL;\
   dimension *d = malloc(sizeof(dimension));\
   d->shape=malloc(rnk * sizeof(size_t));\
   d->basis=NULL;\
   d->basis_rank=0;\
   d->rank = rnk;\
-  for(size_t i=0; i<rnk; ++i) d->shape[i]=t[i];\
+  for(long i=0; i<rnk; ++i) d->shape[i]=t[i];\
   updateDim(d);\
   return d;\
 }\
 dimension *\
-create_dim(size_t rnk){\
+create_dim(long rnk){\
   if (rnk==0) return NULL;\
   dimension *d = malloc(sizeof(dimension));\
   d->shape=malloc(rnk * sizeof(size_t));\
@@ -150,9 +150,9 @@ return init_copy_dim(dim->shape,dim->rank);\
 }\
 \
 dimension *\
-create_reverse_dim(size_t rnk){\
+create_reverse_dim(long rnk){\
   dimension *dim = create_dim(rnk);\
-  for(size_t i=0;i<rnk;++i) dim->shape[i]=rnk-1-i;\
+  for(long i=0;i<rnk;++i) dim->shape[i]=rnk-1-i;\
   updateDim(dim);\
   return dim;\
 }\
@@ -168,13 +168,13 @@ void free_dimension(dimension *d){\
 bool is_equal_dim(dimension *d0, dimension *d1){\
   if(d0->rank != d1->rank) return false;\
   if(d0->size != d1->size) return false;\
-  for(size_t i=0;i<d0->rank; ++i)\
+  for(long 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){\
+dimension* sub_copy_minus_dim_head(dimension *root, long minusSubdim){\
   if(minusSubdim < (root->rank)){\
     dimension *d = init_copy_dim(root->shape, (root->rank)-minusSubdim);\
     updateDim(d);\
@@ -183,7 +183,7 @@ dimension* sub_copy_minus_dim_head(dimension *root, size_t minusSubdim){\
   return NULL;\
 }\
 \
-dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){\
+dimension* sub_copy_minus_dim_tail(dimension *root, long minusSubdim){\
   if(minusSubdim < (root->rank)){\
     dimension *d = init_copy_dim((root->shape)+minusSubdim, (root->rank)-minusSubdim);\
     updateDim(d);\
@@ -192,7 +192,7 @@ dimension* sub_copy_minus_dim_tail(dimension *root, size_t minusSubdim){\
   return NULL;\
 }\
 \
-dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
+dimension* sub_copy_dim_head(dimension *root, long subdim){\
   if(subdim < (root->rank)){\
     dimension *d = init_copy_dim(root->shape, subdim);\
     updateDim(d);\
@@ -201,7 +201,7 @@ dimension* sub_copy_dim_head(dimension *root, size_t subdim){\
   return NULL;\
 }\
 \
-dimension* sub_copy_dim_tail(dimension *root, size_t subdim){\
+dimension* sub_copy_dim_tail(dimension *root, long subdim){\
   if(subdim < (root->rank)){\
     dimension *d = init_copy_dim((root->shape)+(root->rank - subdim), subdim);\
     updateDim(d);\
@@ -212,16 +212,16 @@ dimension* sub_copy_dim_tail(dimension *root, size_t subdim){\
 \
 void add_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
     (*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];\
+    for (long i = 0; i < d0->rank; i++) (*d)->shape[i] = d0->shape[i];\
+    for (long i = 0; i < d1->rank; i++) (*d)->shape[d0->rank + i] = d1->shape[i];\
     updateDim(*d);\
 }\
 \
 void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
-    size_t mindim = min(d0->rank,d1->rank) ;\
+    long mindim = min(d0->rank,d1->rank) ;\
     (*d)=create_dim(mindim);\
 \
-       for (size_t i = 0; i < mindim; i++) {\
+       for (long 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];\
         }\
@@ -231,7 +231,7 @@ void min_copy_dimension(dimension **d, dimension *d0, dimension *d1) {\
 \
 \
 \
-dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){\
+dimension* sub_minus_dim_head(dimension *root, long minusSubdim){\
   if(minusSubdim < (root->rank)){\
     dimension *d = init_dim(root->shape, (root->rank)-minusSubdim);\
     updateDim(d);\
@@ -239,7 +239,7 @@ dimension* sub_minus_dim_head(dimension *root, size_t minusSubdim){\
   }\
   return NULL;\
 }\
-dimension* sub_minus_dim_tail(dimension *root, size_t minusSubdim){\
+dimension* sub_minus_dim_tail(dimension *root, long minusSubdim){\
   if(minusSubdim < (root->rank)){\
     dimension *d = init_dim((root->shape)+minusSubdim, (root->rank)-minusSubdim);\
     updateDim(d);\
@@ -247,7 +247,7 @@ dimension* sub_minus_dim_tail(dimension *root, size_t minusSubdim){\
   }\
   return NULL;\
 }\
-dimension* sub_dim_head(dimension *root, size_t subdim){\
+dimension* sub_dim_head(dimension *root, long subdim){\
   if(subdim < (root->rank)){\
     dimension *d = init_dim(root->shape, subdim);\
     updateDim(d);\
@@ -255,7 +255,7 @@ dimension* sub_dim_head(dimension *root, size_t subdim){\
   }\
   return NULL;\
 }\
-dimension* sub_dim_tail(dimension *root, size_t subdim){\
+dimension* sub_dim_tail(dimension *root, long subdim){\
   if(subdim < (root->rank)){\
     dimension *d = init_dim((root->shape)+(root->rank - subdim), subdim);\
     updateDim(d);\
@@ -265,11 +265,11 @@ dimension* sub_dim_tail(dimension *root, size_t subdim){\
 }\
 \
 /*\
-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 ) {\
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, long rnk_nb_minus_part ) */\
+void split_dim_part(dimension *root, dimension **part_1, dimension **part_2, long pivotSplit, long rangeInPivot ) {\
   if(pivotSplit < root->rank){\
   if(rangeInPivot <  root->shape[pivotSplit]){\
-    /*size_t rnk_part1= (root->size * rnk_nb_minus_part)/(root->shape[(root->rank)-1]);*/\
+    /*long 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;\
@@ -306,8 +306,8 @@ void decrement_dim_var(dimension *d){\
 \
 void add_dimension(dimension **d, dimension *d0, dimension *d1) {\
     (*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];\
+    for (long i = 0; i < d0->rank; i++) (*d)->shape[i] = d0->shape[i];\
+    for (long i = 0; i < d1->rank; i++) (*d)->shape[d0->rank + i] = d1->shape[i];\
     updateDim(*d);\
 }\
 \
@@ -320,7 +320,7 @@ void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
     }\
     else { /* d0->rank = d1->rank*/\
         *d = d0;\
-        for (size_t i = 0; i < d0->rank; i++) {\
+        for (long i = 0; i < d0->rank; i++) {\
             if (d0->shape[i] > d1->shape[i]) (*d)->shape[i] = d1->shape[i];\
         }\
     }\
@@ -330,7 +330,7 @@ void min_dimension(dimension **d, dimension *d0, dimension *d1) {\
 void printDebug_dimension(dimension *d,char *msg){\
 \
   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)\
+  for(long i=0; i<d->rank; ++i)\
     printf(" %ld,", d->shape[i]);\
   printf("] \n");\
     /*printf("[%ld: %ld] |", i,d->shape[i]);*/\
@@ -341,16 +341,16 @@ void printDebug_dimension(dimension *d,char *msg){\
 */\
 }\
 \
-size_t sprint_dimension(char **dimContent, dimension *d){\
+long sprint_dimension(char **dimContent, dimension *d){\
   if(*dimContent != NULL){\
     free(*dimContent);\
     *dimContent=NULL;\
   }\
-  size_t nbch=6*d->rank+40;\
+  long nbch=6*d->rank+40;\
   *dimContent = malloc(nbch);\
   /*printf("nbCh=%ld\n",nbch);*/\
   char *val=NULL;\
-  size_t cur=0;\
+  long cur=0;\
   char *dimSzCh="dim->rank";\
   for(size_t i=0; i<strlen(dimSzCh);++i)\
     (*dimContent)[cur++]=dimSzCh[i];\
@@ -373,7 +373,7 @@ size_t sprint_dimension(char **dimContent, dimension *d){\
   (*dimContent)[cur++]=' ';\
   (*dimContent)[cur++]='\n';\
   (*dimContent)[cur++]='[';\
-  for(size_t i=0; i<d->rank;++i){\
+  for(long 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)\
@@ -462,22 +462,22 @@ long int* signedCoordFromLin(long int line, dimension *dim){\
 \
 /* */\
 /* unsigned */\
-size_t LineFromCoord(size_t *coo, dimension *dim) {\
+long LineFromCoord(long *coo, dimension *dim) {\
   return (long)signedLineFromCoord((long*)coo,dim);\
 }\
 \
-void vCoordFromLin(size_t *ret, size_t line, dimension *dim ){\
+void vCoordFromLin(long *ret, long line, dimension *dim ){\
   signedvCoordFromLin((long*)ret, (long)line, dim);\
 }\
 \
-size_t* CoordFromLin(size_t line, dimension *dim){\
+size_t* CoordFromLin(long line, dimension *dim){\
   return (size_t*)signedCoordFromLin((long)line, dim);\
 }\
 \
 \
 /* */\
 \
-void append_in_list_shape(list_shape_in_dim **list_p, size_t shape){\
+void append_in_list_shape(list_shape_in_dim **list_p, long shape){\
     list_shape_in_dim *lis=malloc(sizeof(list_shape_in_dim));\
     lis->shape=shape;\
     lis->next=NULL;\
@@ -511,9 +511,9 @@ dimension * create_dim_from_list_shape( list_shape_in_dim *l_p){\
   return NULL;\
 }\
 \
-dimension * create_binary_dim(size_t dimension_rank){\
+dimension * create_binary_dim(long dimension_rank){\
   dimension * dim = create_dim(dimension_rank);\
-  for(size_t i=0; i<dimension_rank; ++i)\
+  for(long i=0; i<dimension_rank; ++i)\
     dim->shape[i]=2;\
   updateDim(dim);\
   return dim;\
@@ -552,7 +552,7 @@ GEN_FUNC_PTR_LIST_FREE(ptr_DIMENSION){\
 
 //#include "dimension_t/dimension_t.h"
 
-void subArray(size_t* dst, size_t* src, size_t debDst, size_t finDst, size_t debSrc);
+void subArray(size_t* dst, size_t* src, long debDst, long finDst, long debSrc);
 
 #define GENERATE_TENSOR_TYPE(type) \
 struct tensor_##type{\
@@ -566,39 +566,39 @@ 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 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); \
+tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim); \
+tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim); \
+tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, long subdim, long sizeInDim); \
+tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, long subdim, long sizeInDim); \
+tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim); \
+tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim); \
+tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, long sub_copydim, long sizeInDim); \
+tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, long sub_copydim, long 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);\
-void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot);\
-void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, size_t pivotSplit, size_t rangeInPivot);\
+long sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex);\
+void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, long pivotSplit, long rangeInPivot);\
+void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, long pivotSplit, long rangeInPivot);\
 void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
 void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1); \
-void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
-void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
-void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,size_t nbthread); \
-void tensorContractnProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
-void tensorContractnProdThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
-void tensorContractnPro2dThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
-void tensorContractnPro2dThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread); \
-void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
-void tensorContractnProdOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber); \
-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 ));\
+void tensorContractnProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber); \
+void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,long nbthread); \
+void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1,long nbthread); \
+void tensorContractnProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread); \
+void tensorContractnProdThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread); \
+void tensorContractnPro2dThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread); \
+void tensorContractnPro2dThreadOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread); \
+void tensorContractnProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber); \
+void tensorContractnProdOpt0_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber); \
+type scalarProduct_dep_contractProd_##type(tensor_##type *M0, tensor_##type *M1, long nbthreads ,void (*tensorContractVar)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread ));\
 type scalarProduct_0_##type(tensor_##type *M0, tensor_##type *M1);\
 void init_random_x_##type(tensor_##type *M, type minR, type maxR,  int randomRange);\
 tensor_##type * parseInput_withDim_to_tensor_##type(char *input);\
-void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, size_t pivotSplit);\
-void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, size_t pivotSplit);\
+void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, long pivotSplit);\
+void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, long pivotSplit);\
 tensor_##type ** fromInput_to_array_tensor_##type(tensor_##type *tens);\
 struct array_chainlist_##type{\
-  size_t index;\
+  long index;\
   type x;\
   struct array_chainlist_##type *next;\
 };\
@@ -611,24 +611,24 @@ tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org);\
 tensor_##type * transpose_Opt1_tensor_##type(tensor_##type *org);\
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dshape);\
 void update_1tensor_func_##type(tensor_##type *M0, \
-    type (*func)(type), size_t nbthread);\
+    type (*func)(type), long nbthread);\
 void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
-    type (*func)(type), size_t nbthread);\
+    type (*func)(type), long nbthread);\
 void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
-    type (*func)(type, type), size_t nbthread);\
+    type (*func)(type, type), long nbthread);\
 void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
     type (*func)(type, type,  type(*f1)(type)),\
     type(*f1)(type),\
-    size_t nbthread);\
+    long nbthread);\
 void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, tensor_##type *M3 , \
     type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
     type(*f1)(type), \
     type (*f2)(type,type), \
-    size_t nbthread);\
+    long nbthread);\
 void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1,  \
     type (*func)(type, type, type),\
     type scalar,\
-    size_t nbthread);\
+    long nbthread);\
 
 
 GENERATE_TENSOR_TYPE(TYPE_FLOAT);
@@ -638,39 +638,39 @@ GENERATE_TENSOR_TYPE(TYPE_L_DOUBLE);
 
 #endif /* __TENSOR_T__H__ */
 
-void subArray(size_t* dst, size_t* src, size_t debDst, size_t finDst, size_t debSrc) {
-    for (size_t i = debDst; i < finDst; i++) {
+void subArray(size_t* dst, size_t* src, long debDst, long finDst, long debSrc) {
+    for (long i = debDst; i < finDst; i++) {
         dst[i] = src[i + debSrc];
     }
 }
 
-void concatArray(size_t* dst, size_t* src0, size_t* src1, size_t debDst, size_t debSrc0, size_t finSrc0, size_t debSrc1, size_t finSrc1) {
-    size_t i = debDst;
-    for (size_t j = debSrc0; j < finSrc0; j++) {
+void concatArray(size_t* dst, size_t* src0, size_t* src1, long debDst, long debSrc0, long finSrc0, long debSrc1, long finSrc1) {
+    long i = debDst;
+    for (long j = debSrc0; j < finSrc0; j++) {
         dst[i++] = src0[j];
     }
-    for (size_t j = debSrc1; j < finSrc1; j++) {
+    for (long j = debSrc1; j < finSrc1; j++) {
         dst[i++] = src1[j];
     }
 }
 
-void printArraySzt(size_t *a, size_t rnk,char *msg){
+void printArraySzt(long *a, long rnk,char *msg){
   printf("======== %s ======= rank: %ld\n",msg,rnk);
-  for(size_t i=0; i< rnk; ++i)
+  for(long i=0; i< rnk; ++i)
     printf("[%ld : %ld ] ",i,a[i]);
   printf("\n");
 }
 
-int checkContractProdTensorDim(dimension *d0, dimension *d1, ssize_t contractionNumber){
+int checkContractProdTensorDim(dimension *d0, dimension *d1, long contractionNumber){
   if((d0->rank-contractionNumber <0)||(d1->rank-contractionNumber <0)) return 0;
   if(littleEndian){
-    ssize_t beginCommonM0=d0->rank-contractionNumber;
-    for(ssize_t i=0; i<contractionNumber; ++i){
+    long beginCommonM0=d0->rank-contractionNumber;
+    for(long i=0; i<contractionNumber; ++i){
       if(d0->shape[beginCommonM0+i] != d1->shape[i]) return 0;
     }
   }else{
-    ssize_t beginCommonM1=d1->rank-contractionNumber;
-    for(ssize_t i=0; i<contractionNumber; ++i){
+    long beginCommonM1=d1->rank-contractionNumber;
+    for(long i=0; i<contractionNumber; ++i){
       if(d0->shape[i] != d1->shape[beginCommonM1+i]) return 0;
     }
    }
@@ -746,7 +746,7 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
     updateDim(dim);\
     r_tens->dim = dim;\
     /*r_tens->x = troot->x;*/\
-    for(size_t i=0; i<dim->size;++i)\
+    for(long i=0; i<dim->size;++i)\
       r_tens->x[i]=troot->x[i];\
     return r_tens;\
   }\
@@ -757,8 +757,8 @@ tensor_##type* init_copy_tensor_head_##type(tensor_##type *troot ,dimension *dim
     r_tens->dim = dim;\
     /*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)\
+    long dRank=(troot->dim)->size - dim->size;\
+    for(long i=0; i<dim->size;++i)\
       r_tens->x[i]=troot->x[i+dRank];\
     return r_tens;\
   }\
@@ -776,7 +776,7 @@ tensor_##type* clone_tensor_##type(tensor_##type *tens){\
     tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
     r_tens->dim = clone_dim(tens->dim);\
     r_tens->x = malloc(sizeof(type) * (tens->dim)->size);\
-    for(size_t i=0; i<(tens->dim)->size;++i)\
+    for(long i=0; i<(tens->dim)->size;++i)\
       r_tens->x[i]=tens->x[i];\
     return r_tens;\
   }\
@@ -787,7 +787,7 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
   if(dst!=NULL && src!=NULL){ \
     int diff = dst->dim->size - src->dim->size;\
     if(diff == 0) \
-      for(size_t i=0; i<(src->dim)->size;++i)\
+      for(long i=0; i<(src->dim)->size;++i)\
         dst->x[i]=src->x[i];\
     return diff;\
     \
@@ -806,13 +806,13 @@ 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)->size;++i){\
+    for(long 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 sizeInDim){\
+  tensor_##type * sub_minus_tensor_head_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_t = sub_minus_dim_tail(rdim,rdim->rank - minuSubdim);\
     if(sizeInDim < dS_t->size){\
@@ -821,12 +821,12 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_h;\
       ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       if(littleEndian){\
-        for(size_t i=0; i<dS_h->size; ++i){\
+        for(long 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->size; ++i){\
+        for(long i=0; i<dS_h->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       }\
@@ -835,7 +835,7 @@ 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 sizeInDim){\
+  tensor_##type * sub_minus_tensor_tail_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_h = sub_minus_dim_head(rdim,rdim->rank - minuSubdim);\
     if(sizeInDim < dS_h->size){\
@@ -844,11 +844,11 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_t;\
         ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long 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->size; ++i){\
+        for(long i=0; i<dS_t->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
@@ -858,7 +858,7 @@ 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 sizeInDim){\
+  tensor_##type * sub_tensor_head_##type(tensor_##type *rootens, long subdim, long sizeInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_t = sub_dim_tail(rdim,rdim->rank - subdim);\
     if(sizeInDim < dS_t->size){\
@@ -867,11 +867,11 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_h;\
         ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       if(littleEndian){\
-        for(size_t i=0; i<dS_h->size; ++i){\
+        for(long 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->size; ++i){\
+        for(long i=0; i<dS_h->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       \
@@ -880,7 +880,7 @@ 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 sizeInDim){ \
+  tensor_##type * sub_tensor_tail_##type(tensor_##type *rootens, long subdim, long sizeInDim){ \
     dimension *rdim= rootens->dim;\
     dimension *dS_h = sub_dim_head(rdim,rdim->rank - subdim);\
     if(sizeInDim < dS_h->size){\
@@ -889,11 +889,11 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_t;\
         ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long 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->size; ++i){\
+        for(long i=0; i<dS_t->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
@@ -903,7 +903,7 @@ 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 sizeInDim){\
+  tensor_##type * sub_copy_minus_tensor_head_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_t = sub_copy_minus_dim_tail(rdim,rdim->rank - minuSubdim);\
     if(sizeInDim < dS_t->size){\
@@ -914,14 +914,14 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->x = malloc(sizeof(type)*dS_h->size);*/\
       if(littleEndian){\
         /*ret_ens->x = malloc(sizeof(type)*dS_h->size);\
-        */for(size_t i=0; i<dS_h->size; ++i){\
+        */for(long 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)+sizeInDim*dS_h->size;*/\
-        for(size_t i=0; i<dS_h->size; ++i){\
+        for(long i=0; i<dS_h->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_h->size * sizeInDim];\
         }\
       }\
@@ -932,7 +932,7 @@ 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 sizeInDim){\
+  tensor_##type * sub_copy_minus_tensor_tail_##type(tensor_##type *rootens, long minuSubdim, long sizeInDim){\
     dimension *rdim= rootens->dim;\
     dimension *dS_h = sub_copy_minus_dim_head(rdim,rdim->rank - minuSubdim);\
     if(sizeInDim < dS_h->size){\
@@ -942,12 +942,12 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_t;\
       ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       */if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long i=0; i<dS_t->size; ++i){\
           ret_ens->x[i]=rootens->x[i*dS_h->size + sizeInDim];\
         }\
       }else{\
         /*ret_ens->x = (rootens->x)+sizeInDim*dS_t->size;*/\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long i=0; i<dS_t->size; ++i){\
           ret_ens->x[i]=rootens->x[i + dS_t->size * sizeInDim];\
         }\
       \
@@ -959,7 +959,7 @@ 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 sizeInDim){\
+  tensor_##type * sub_copy_tensor_head_##type(tensor_##type *rootens, long sub_copydim, long 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->rank - sub_copydim);\
@@ -970,13 +970,13 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_h;\
       ret_ens->x = malloc(sizeof(type)*dS_h->size);\
       */if(littleEndian){\
-        for(size_t i=0; i<dS_h->size; ++i){\
+        for(long 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)+sizeInDim*dS_h->size;*/\
-        for(size_t i=0; i<dS_h->size; ++i){\
+        for(long 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);*/\
         }\
@@ -988,7 +988,7 @@ 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 sizeInDim){ \
+  tensor_##type * sub_copy_tensor_tail_##type(tensor_##type *rootens, long sub_copydim, long 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->rank - sub_copydim);\
@@ -999,13 +999,13 @@ int copy_tensor_##type(tensor_##type * dst, tensor_##type * src){\
       ret_ens->dim = dS_t;\
       ret_ens->x = malloc(sizeof(type)*dS_t->size);\
       */if(littleEndian==false){\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long 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)+sizeInDim*dS_t->size;*/\
-        for(size_t i=0; i<dS_t->size; ++i){\
+        for(long 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);*/\
         }\
@@ -1019,8 +1019,8 @@ 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)->rank); \
+  /*long j=0 ,k=0*/;\
+  long *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   /*char *dimsg=malloc(512);\
   sprintf(dimsg,"(%s)->dim",msg);\
@@ -1047,7 +1047,7 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
       }\
     }\
     /*printf(" [");\
-    for(size_t k=0; k<(T->dim)->rank;++k) printf(" %ld",coord[k]);\
+    for(long 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);*/\
@@ -1058,7 +1058,7 @@ void print_tensor_msg_##type(tensor_##type *T,char *msg) {\
       scanf("%c",&c);\
     }*/\
     if(coord[begin]==(T->dim)->shape[begin]-1){\
-      size_t count=0;\
+      long count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
         if(coord[j]==(T->dim)->shape[j]-1) {\
           printf(")"); ++count;\
@@ -1076,8 +1076,8 @@ 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)->rank); \
+  /*long j=0,k=0;*/\
+  long *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   FILE *fileWrite = fopen(file_name, "w");\
   if(fileWrite == NULL) {\
@@ -1097,7 +1097,7 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
         /*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)->rank; ++i)\
+  for(long i=0; i<(T->dim)->rank; ++i)\
     fprintf(fileWrite," %ld,", (T->dim)->shape[i]);\
   fprintf(fileWrite,"] \n");\
 \
@@ -1115,12 +1115,12 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
       return;\
     }\
 /*fprintf(fileWrite," [");\
-    for(size_t k=0; k<(T->dim)->rank;++k) fprintf(fileWrite," %ld,",coord[k]);\
+    for(long 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;\
     if(coord[begin]==(T->dim)->shape[begin]-1){\
-      size_t count=0;\
+      long count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
         if(coord[j]==(T->dim)->shape[j]-1) {\
           fprintf(fileWrite,")"); ++count;\
@@ -1136,16 +1136,16 @@ void fprint_tensor_##type(char *file_name, tensor_##type *T) {\
   fclose(fileWrite);\
 }\
 \
-size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex) {\
+long sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withIndex) {\
   if(*tensorContent != NULL) {\
     free(*tensorContent);\
     *tensorContent = NULL;  \
   }\
-  size_t rnk = ((T->dim)->size)*(32+ withIndex * 5*(T->dim)->rank + 129 );\
+  long 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)->rank); \
+  long cur=0;\
+  long *coord = malloc(sizeof(long int)*(T->dim)->rank); \
   char *val=NULL;\
   long int begin , end /*, beginIter, endIter*/ ;\
   long int (*iter)(long int) ;\
@@ -1179,7 +1179,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)->rank;++k) {\
+    for(long 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){\
@@ -1200,7 +1200,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
   }\
      if(T->x[i] != T->x[i]){\
       /*char *nanStr="ALERT NAN";\
-      for(size_t c=0;c<strlen(nanStr);++c)\
+      for(long c=0;c<strlen(nanStr);++c)\
         (*tensorContent)[cur++]=nanStr[c];*/\
       printf(" ALERT NAN ");\
       ;\
@@ -1214,7 +1214,7 @@ size_t sprint_tensor_##type(char **tensorContent,tensor_##type *T, bool withInde
     free(val); val = NULL;\
     (*tensorContent)[cur++]=',';\
     if(coord[begin]==(T->dim)->shape[begin]-1){\
-      size_t count=0;\
+      long count=0;\
       for(long int j=begin; cond(j,end); j = iter(j)){\
         if(coord[j]==(T->dim)->shape[j]-1) {/*printf(")"); */ (*tensorContent)[cur++]=')'; ++count;}\
         else break;\
@@ -1230,8 +1230,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 rnk = (Troot->dim)->rank;\
+void split_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, long pivotSplit, long rangeInPivot){\
+  long rnk = (Troot->dim)->rank;\
   if(pivotSplit < rnk){\
     if( rangeInPivot < (Troot->dim)->shape[pivotSplit]){\
       dimension *dpart1, *dpart2;\
@@ -1241,8 +1241,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 rnk = (Troot->dim)->rank;\
+void split_copy_tensor_##type(tensor_##type *Troot, tensor_##type **Tpart1, tensor_##type **Tpart2, long pivotSplit, long rangeInPivot){\
+  long rnk = (Troot->dim)->rank;\
   if(pivotSplit < rnk){\
     if( rangeInPivot < (Troot->dim)->shape[pivotSplit]){\
       dimension *dpart1, *dpart2;\
@@ -1264,7 +1264,7 @@ void tensorProdNotOpt_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
     coord0 = malloc(sizeof(size_t)* M0->dim->rank);  \
     size_t* coord1 , lin1;  \
     coord1 = malloc(sizeof(size_t)* M1->dim->rank);  \
-    for (size_t i = 0; i < dd->size; i++) {  \
+    for (long i = 0; i < dd->size; i++) {  \
         vCoordFromLin(coord, i, M->dim);  \
         subArray(coord0, coord, 0, M0->dim->rank, 0);  \
         subArray(coord1, coord, 0, M1->dim->rank, M0->dim->rank);  \
@@ -1284,9 +1284,9 @@ void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1)
     add_dimension(&dd, M0->dim, M1->dim); \
     _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->size; ++i){\
-      for(size_t j=0; j<M1->dim->size; ++j){\
+    long m_idx;\
+    for(long i=0; i<M0->dim->size; ++i){\
+      for(long j=0; j<M1->dim->size; ++j){\
           if(littleEndian)\
             m_idx= i*M1->dim->size + j ;\
           else\
@@ -1301,7 +1301,7 @@ void tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1)
  M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
-void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
+void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber) {\
    /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
         prsize_tf("Deep = %d\n", contractionNumber);\
     }*/\
@@ -1312,8 +1312,8 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
         /*getchar();*/\
     }\
 \
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1348,8 +1348,8 @@ 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->size; i++) {\
+    long a0_id, a1_id, n0_id, n1_id;\
+    for (long i = 0; i < M->dim->size; i++) {\
         if(littleEndian){\
           a0_id=i/dSub1->size;\
           a1_id=i%dSub1->size;\
@@ -1359,7 +1359,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
           a1_id=i/dSub0->size;\
         }\
         M->x[i] = 0;\
-        for (size_t k = 0; k < dM->size; k++) {\
+        for (long k = 0; k < dM->size; k++) {\
           if(littleEndian){\
             n0_id= a0_id*dM->size + k;\
             n1_id= a1_id + dSub1->size * k;\
@@ -1379,7 +1379,7 @@ void tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##
  M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
-void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
+void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber) {\
    /* if (!checkMatchProdtensor(M0->dim, M1->dim, contractionNumber)) {\
         prsize_tf("Deep = %d\n", contractionNumber);\
     }*/\
@@ -1390,8 +1390,8 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
         /*getchar();*/\
     }\
 \
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1426,8 +1426,8 @@ 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->size; i++) {\
+    long a0_id, a1_id, n0_id, n1_id;\
+    for (long i = 0; i < M->dim->size; i++) {\
         if(littleEndian){\
           a0_id=i/dSub1->size;\
           a1_id=i%dSub1->size;\
@@ -1441,7 +1441,7 @@ void tensorContractnProdOpt0_##type(tensor_##type** MM, tensor_##type *M0, tenso
           n0_id= a0_id ;\
         }\
         M->x[i] = 0;\
-        for (size_t k = 0; k < dM->size; k++) {\
+        for (long k = 0; k < dM->size; k++) {\
           if(littleEndian){\
             /*n0_id= a0_id*dM->size + k;*/\
             /*n1_id= a1_id + dSub1->size * k;*/\
@@ -1466,14 +1466,14 @@ struct arg_Prod_##type{\
   type *M0x;\
   type *M1x;\
   type *Mx;\
-  size_t beginRange;\
-  size_t endRange;\
-  size_t MRank;\
+  long beginRange;\
+  long endRange;\
+  long MRank;\
 };\
 void* runProd_thread_##type(void *arg){\
   struct arg_Prod_##type *arg_t = arg;\
-  size_t a0_id, a1_id;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+  long a0_id, a1_id;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         if(littleEndian){\
           a0_id=i / arg_t->MRank;\
           a1_id=i % arg_t->MRank;\
@@ -1488,7 +1488,7 @@ void* runProd_thread_##type(void *arg){\
 }\
 \
 \
-void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
+void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
     _recreate_tensor_if_not_the_same_dim_or_null_##type(MM,dd);  \
@@ -1498,7 +1498,7 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_Prod_##type **arg_th = malloc( nbthread * sizeof(struct arg_Prod_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i){\
+  for(long i = 0; i < nbthread; ++i){\
     arg_th[i]=malloc(sizeof(struct arg_Prod_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1516,7 +1516,7 @@ void tensorProdThread_##type(tensor_##type **MM, tensor_##type *M0, tensor_##typ
     pthread_create(&thrd[i], NULL, runProd_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1529,16 +1529,16 @@ struct arg_Pro2d_##type{\
   type *M0x;\
   type *M1x;\
   type *Mx;\
-  size_t beginRange;\
-  size_t endRange;\
-  size_t M0Rank;\
-  size_t M1Rank;\
+  long beginRange;\
+  long endRange;\
+  long M0Rank;\
+  long M1Rank;\
 };\
 void* runProd_thread2d_##type(void *arg){\
   struct arg_Pro2d_##type *arg_t = arg;\
-  size_t k;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
-      for (size_t j = 0; j < arg_t->M1Rank; j++) {\
+  long k;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+      for (long j = 0; j < arg_t->M1Rank; j++) {\
         if(littleEndian){\
           k = i * arg_t->M1Rank + j;\
         }\
@@ -1551,7 +1551,7 @@ void* runProd_thread2d_##type(void *arg){\
   return 0;\
 }\
 \
-void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, size_t nbthread) {  \
+void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long nbthread) {  \
     dimension *dd;  \
     add_dimension(&dd, M0->dim, M1->dim); \
     _recreate_tensor_if_not_the_same_dim_or_null_##type(MM,dd);  \
@@ -1561,7 +1561,7 @@ void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##ty
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_Pro2d_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2d_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i){\
+  for(long i = 0; i < nbthread; ++i){\
     arg_th[i]=malloc(sizeof(struct arg_Pro2d_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1575,7 +1575,7 @@ void tensorProdThrea2d_##type(tensor_##type **MM, tensor_##type *M0, tensor_##ty
     pthread_create(&thrd[i], NULL, runProd_thread2d_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1588,15 +1588,15 @@ struct arg_ProdContract_##type{\
   type *M0x;\
   type *M1x;\
   type *Mx;\
-  size_t beginRange;\
-  size_t endRange;\
-  size_t dSubRank;\
-  size_t dMRank;\
+  long beginRange;\
+  long endRange;\
+  long dSubRank;\
+  long dMRank;\
 };\
 void* runProdContract_thread_##type(void *arg){\
   struct arg_ProdContract_##type *arg_t = arg;\
-  size_t a0_id, a1_id, n0_id, n1_id;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+  long a0_id, a1_id, n0_id, n1_id;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         if(littleEndian){\
           a0_id=i/ arg_t->dSubRank;\
           a1_id=i% arg_t->dSubRank;\
@@ -1606,7 +1606,7 @@ void* runProdContract_thread_##type(void *arg){\
           a1_id=i/ arg_t->dSubRank;\
         }\
         arg_t->Mx[i] = 0;\
-        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+        for (long k = 0; k < arg_t->dMRank; k++) {\
           if(littleEndian){\
             n0_id= a0_id * arg_t->dMRank + k;\
             n1_id= a1_id + arg_t->dSubRank * k;\
@@ -1625,15 +1625,15 @@ void* runProdContract_thread_##type(void *arg){\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
 \
-void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread) {\
     if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
         /*getchar();*/\
     }\
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1661,7 +1661,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_ProdContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_ProdContract_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i){\
+  for(long i = 0; i < nbthread; ++i){\
     arg_th[i]=malloc(sizeof(struct arg_ProdContract_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1679,7 +1679,7 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
     pthread_create(&thrd[i], NULL, runProdContract_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1692,8 +1692,8 @@ void tensorContractnProdThread_##type(tensor_##type** MM, tensor_##type *M0, ten
 \
 void* runProdContractOpt0_thread_##type(void *arg){\
   struct arg_ProdContract_##type *arg_t = arg;\
-  size_t a0_id, a1_id, n0_id, n1_id;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+  long a0_id, a1_id, n0_id, n1_id;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         if(littleEndian){\
           a0_id=i/ arg_t->dSubRank;\
           a1_id=i% arg_t->dSubRank;\
@@ -1707,7 +1707,7 @@ void* runProdContractOpt0_thread_##type(void *arg){\
             n1_id= a1_id * arg_t->dMRank ;\
         }\
         arg_t->Mx[i] = 0;\
-        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+        for (long k = 0; k < arg_t->dMRank; k++) {\
           if(littleEndian){\
             arg_t->Mx[i] += arg_t->M0x[n0_id++] * arg_t->M1x[n1_id];\
             n1_id += arg_t->dSubRank ;\
@@ -1722,15 +1722,15 @@ void* runProdContractOpt0_thread_##type(void *arg){\
 }\
 \
 \
-void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread) {\
     if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
         /*getchar();*/\
     }\
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1758,7 +1758,7 @@ void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0,
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_ProdContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_ProdContract_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i){\
+  for(long i = 0; i < nbthread; ++i){\
     arg_th[i]=malloc(sizeof(struct arg_ProdContract_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1776,7 +1776,7 @@ void tensorContractnProdThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0,
     pthread_create(&thrd[i], NULL, runProdContractOpt0_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1790,24 +1790,24 @@ struct arg_Pro2dContract_##type{\
   type *M0x;\
   type *M1x;\
   type *Mx;\
-  size_t beginRange;\
-  size_t endRange;\
-  size_t dMRank;\
-  size_t dSub0Rank;\
-  size_t dSub1Rank;\
+  long beginRange;\
+  long endRange;\
+  long dMRank;\
+  long dSub0Rank;\
+  long dSub1Rank;\
 };\
 \
 void* runPro2dContract_thread_##type(void *arg){\
   struct arg_Pro2dContract_##type *arg_t = arg;\
-  size_t n0_id, n1_id, l;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
-      for (size_t j = 0; j < arg_t->dSub1Rank; j++) {\
+  long n0_id, n1_id, l;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+      for (long j = 0; j < arg_t->dSub1Rank; j++) {\
         if(littleEndian)\
           l = j + arg_t->dSub1Rank * i;\
         else\
           l = j * arg_t->dSub0Rank + i;\
         arg_t->Mx[l] = 0;\
-        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+        for (long k = 0; k < arg_t->dMRank; k++) {\
           if(littleEndian){\
             n0_id= i * arg_t->dMRank + k;\
             n1_id= j + arg_t->dSub1Rank * k;\
@@ -1826,7 +1826,7 @@ void* runPro2dContract_thread_##type(void *arg){\
  M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
-void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread) {\
     /*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
     }*/\
@@ -1837,8 +1837,8 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
         /*getchar();*/\
     }\
 \
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1866,7 +1866,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_Pro2dContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2dContract_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i) {\
+  for(long i = 0; i < nbthread; ++i) {\
     arg_th[i] = malloc(sizeof(struct arg_Pro2dContract_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1879,7 +1879,7 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
     pthread_create(&thrd[i], NULL, runPro2dContract_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1891,9 +1891,9 @@ void tensorContractnPro2dThread_##type(tensor_##type** MM, tensor_##type *M0, te
 \
 void* runPro2dContractOpt0_thread_##type(void *arg){\
   struct arg_Pro2dContract_##type *arg_t = arg;\
-  size_t n0_id, n1_id, l;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
-      for (size_t j = 0; j < arg_t->dSub1Rank; j++) {\
+  long n0_id, n1_id, l;\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+      for (long j = 0; j < arg_t->dSub1Rank; j++) {\
         if(littleEndian){\
           l = j + arg_t->dSub1Rank * i;\
             n0_id= i * arg_t->dMRank ;\
@@ -1904,7 +1904,7 @@ void* runPro2dContractOpt0_thread_##type(void *arg){\
             n1_id= j * arg_t->dMRank ;\
         }\
         arg_t->Mx[l] = 0;\
-        for (size_t k = 0; k < arg_t->dMRank; k++) {\
+        for (long k = 0; k < arg_t->dMRank; k++) {\
           if(littleEndian){\
             /*n0_id= i * arg_t->dMRank + k;\
             n1_id= j + arg_t->dSub1Rank * k;*/\
@@ -1926,7 +1926,7 @@ void* runPro2dContractOpt0_thread_##type(void *arg){\
  M[x0,x1,x3..xl x{l+1}...xn] X M[xn,x{n-1},x{n-2}...xl y{l+1} ..ym] = M[x0,x1..xly{l+1}...y{n+m-2l}] (deep = l > 0)\
 M[[i][j]]=sum_{[k]}M0[[i][k]]*M[[k][j]]*/\
 \
-void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber, size_t nbthread) {\
+void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread) {\
     /*if(checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)==0){\
       printf("checkContractProdTensorDim %ld contractionNumber\n", contractionNumber);\
     }*/\
@@ -1937,8 +1937,8 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
         /*getchar();*/\
     }\
 \
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -1966,7 +1966,7 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_Pro2dContract_##type **arg_th = malloc( nbthread * sizeof(struct arg_Pro2dContract_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i) {\
+  for(long i = 0; i < nbthread; ++i) {\
     arg_th[i] = malloc(sizeof(struct arg_Pro2dContract_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->M1x=M1->x;\
@@ -1979,7 +1979,7 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
     pthread_create(&thrd[i], NULL, runPro2dContractOpt0_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -1988,15 +1988,15 @@ void tensorContractnPro2dThreadOpt0_##type(tensor_##type** MM, tensor_##type *M0
   free(arg_th);\
   FREE_dM_S_ ; \
 }\
-void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
+void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber) {\
     if (!checkContractProdTensorDim(M0->dim, M1->dim, contractionNumber)) {\
         printf("error Deep = %ld\n", contractionNumber);\
         printDebug_dimension(M0->dim, "M0 dim");\
         printDebug_dimension(M1->dim, "M1 dim");\
         /*getchar();*/\
     }\
-    size_t len0 = M0->dim->rank - contractionNumber;\
-    size_t len1 = M1->dim->rank - contractionNumber;\
+    long len0 = M0->dim->rank - contractionNumber;\
+    long len1 = M1->dim->rank - contractionNumber;\
 \
     size_t* tsub0 = malloc(sizeof(size_t) *len0);\
     size_t* tsub1 = malloc(sizeof(size_t) *len1);\
@@ -2045,12 +2045,12 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
     size_t* Koord ;\
     Koord = malloc(sizeof(size_t)* contractionNumber);\
 \
-    for (size_t i = 0; i < M->dim->size; i++) {\
+    for (long 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->size; k++) {\
+        for (long 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);\
@@ -2070,12 +2070,12 @@ void tensorContractnProdNotOpt_##type(tensor_##type** MM, tensor_##type *M0, ten
 }\
 \
 /* 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 scalarProduct_dep_contractProd_##type(tensor_##type *M0, tensor_##type *M1, long nbthreads ,void (*tensorContractVar)(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1, long contractionNumber, long nbthread )){\
   type ret = 0;\
   if(is_equal_dim(M0->dim, M1->dim)){/* */\
     dimension * d0 = create_dim(M0->dim->rank + 1);\
     dimension * d1 = create_dim(M1->dim->rank + 1);\
-    size_t i;\
+    long i;\
     d0->shape[0] = 1;\
     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];\
@@ -2102,13 +2102,13 @@ type scalarProduct_0_##type(tensor_##type *M0, tensor_##type *M1){\
 /*format_file: [dim]((x,x,a)(a,x,a)) | example:[2,3,4](((a0,b0,c0,d0)(a1,b1,c1,d1)(a2,b2,c2,d2))((e0,f0,g0,h0)(e1,f1,g1,h1)(e2,f2,g2,h2)))*/\
 tensor_##type * parseInput_withDim_to_tensor_##type(char *input){\
   tensor_##type *tens ;\
-  size_t len = strlen(input);\
+  long len = strlen(input);\
   list_shape_in_dim *l_p=NULL;\
-  size_t ss;\
+  long ss;\
   char *ttmp=input;\
   char *ppEnd="[";\
   bool unknown_shape=false; \
-  for(size_t i=0; i<len ; ++i){\
+  for(long i=0; i<len ; ++i){\
     if(input[i]==']') break;\
     if((input[i]=='*') ||(input[i]=='_')){ unknown_shape =true; break;}\
   }\
@@ -2131,7 +2131,7 @@ tensor_##type * parseInput_withDim_to_tensor_##type(char *input){\
   if(unknown_shape == false){\
     tens = create_tensor_##type(dim);\
   \
-    size_t i=0;\
+    long i=0;\
     type x;\
     while(ppEnd && (ppEnd[0] !='\0') && i<dim->size){\
       x = strto_##type(ttmp, &ppEnd);\
@@ -2172,15 +2172,15 @@ tensor_##type * parseInput_withDim_to_tensor_##type(char *input){\
 \
 \
 /*format_file: [*,dim1,dim2]((x,x,a)(x,a))... | example:[2,(2,3),4](((a0,b0,c0,)((a1,b1,c1))((a2,b2,c2,d2))((e0,f0,g0)(e1,f1,g1)(e2,f2,g2,h2))) ==[2,2,3][2,4]*/\
-void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, size_t pivotSplit){\
+void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *input, long pivotSplit){\
   /*tensor_##type *tens ;*/\
-  size_t len = strlen(input);\
+  long len = strlen(input);\
   list_shape_in_dim *l_p=NULL;\
-  size_t ss;\
+  long ss;\
   char *ttmp=input;\
   char *ppEnd="[";\
   bool unknown_shape=false; \
-  for(size_t i=0; i<len ; ++i){\
+  for(long i=0; i<len ; ++i){\
     if(input[i]==']') break;\
     if((input[i]=='*') ||(input[i]=='_')){ unknown_shape =true; break;}\
   }\
@@ -2209,11 +2209,11 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
     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->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];\
+    for(long i=0;i<dim1->rank;++i) dim1->shape[i] = dim->shape[i];\
+    for(long i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i+1];\
+    for(long 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->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
+    for(long i=1;i<dim2->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
     /*dim2->shape[1] = dim->shape[dim->rank - 1];*/\
     updateDim(dim1);\
     updateDim(ddim1);\
@@ -2222,7 +2222,7 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
     *Tpart1 = create_tensor_##type(dim1);\
     *Tpart2 = create_tensor_##type(dim2);\
   \
-    size_t i1=0,i=0,j=0,i2=0;\
+    long i1=0,i=0,j=0,i2=0;\
     bool filled1=false,filled2=false;\
     type x;\
     while(ppEnd && (ppEnd[0] !='\0') && j<dim2->size){\
@@ -2264,17 +2264,17 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
   else{\
     /*dimension *ddim1 = create_dim(dim->rank-1);\
     dimension *ddim2 = create_dim(1);\
-    for(size_t i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+    for(long 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->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];\
+    for(long i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+    for(long i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[dim->rank - pivotSplit + i];\
     updateDim(ddim1);\
     updateDim(ddim2);\
     array_chainlist_##type *l_a1=NULL;\
     array_chainlist_##type *l_a2=NULL;\
-    size_t i1=0, /*i=0,j=0, */ i2=0;\
+    long i1=0, /*i=0,j=0, */ i2=0;\
     bool filled1=false,filled2=false;\
     type x;\
     while(ppEnd && (ppEnd[0] !='\0')){\
@@ -2328,9 +2328,9 @@ void parseInputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_#
 \
 \
 /*format_file: [*,dim1,dim2]((x,x,a)(x,a))... | example:[2,(2,3),4](((a0,b0,c0,)((a1,b1,c1))((a2,b2,c2,d2))((e0,f0,g0)(e1,f1,g1)(e2,f2,g2,h2))) == with pivot 1 => [2,2,3][2,4]*/\
-void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, size_t pivotSplit){\
-  size_t block_size=2;\
-  size_t block_count=4;\
+void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, tensor_##type **Tpart2, char *file_name_input, long pivotSplit){\
+  long block_size=2;\
+  long block_count=4;\
   char *input=malloc(block_size*block_count + 1);\
   char *iinput=malloc(block_size*block_count + 256);\
   FILE *f_input;\
@@ -2353,8 +2353,8 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
       iinput[curIn++]=input[0];\
     }\
     iinput[curIn]='\0';\
-    size_t len = strlen(iinput);\
-    for(size_t i=0; i<len ; ++i){\
+    long len = strlen(iinput);\
+    for(long i=0; i<len ; ++i){\
       if(iinput[i]==']') {broken = true; break;}\
       if((iinput[i]=='*') ||(iinput[i]=='_')){ \
         broken=true;  unknown_shape =true;\
@@ -2366,11 +2366,11 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
   rewind(f_input);\
   list_shape_in_dim *l_p=NULL;\
   dimension *dim=NULL;\
-  size_t ss;\
+  long ss;\
   char *ttmp;\
   char *ppEnd="[";\
   bool bracketsDown=false;\
-        size_t i1=0,i=0,j=0,i2=0;\
+        long i1=0,i=0,j=0,i2=0;\
         bool filled1=false,filled2=false;\
         array_chainlist_##type *l_a1=NULL;\
         array_chainlist_##type *l_a2=NULL;\
@@ -2419,11 +2419,11 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
           ddim1 = create_dim(dim->rank-pivotSplit-1);\
           ddim2 = create_dim(pivotSplit);\
           dim2 = create_dim(pivotSplit+1);\
-          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];\
+          for(long i=0;i<dim1->rank;++i) dim1->shape[i] = dim->shape[i];\
+          for(long i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i+1];\
+          for(long 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->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
+          for(long i=1;i<dim2->rank;++i) dim2->shape[i] = ddim2->shape[i-1];\
           updateDim(dim1);\
           updateDim(ddim1);\
           updateDim(ddim2);\
@@ -2474,8 +2474,8 @@ void parse_file_InputOutput_withDim_to_tensors_##type(tensor_##type **Tpart1, te
         if(!initDim){\
           ddim1 = create_dim(dim->rank-pivotSplit);\
           ddim2 = create_dim(pivotSplit);\
-          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];\
+          for(long i=0;i<ddim1->rank;++i) ddim1->shape[i] = dim->shape[i];\
+          for(long i=0;i<ddim2->rank;++i) ddim2->shape[i] = dim->shape[dim->rank - pivotSplit + i];\
           updateDim(ddim1);\
           updateDim(ddim2);\
           initDim=true;\
@@ -2534,11 +2534,11 @@ 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)->rank - 1);\
-  for(size_t i=0; i<dim->rank; ++i) dim->shape[i]=(tens->dim)->shape[i+1];\
+  for(long i=0; i<dim->rank; ++i) dim->shape[i]=(tens->dim)->shape[i+1];\
   updateDim(dim);\
-  for(size_t i=0; i < (tens->dim)->shape[0];++i){\
+  for(long 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->size; ++j) (re_tens[i])->x[j] = tens->x[i*(dim->size) + j ] ;\
+    for(long j=0; j<dim->size; ++j) (re_tens[i])->x[j] = tens->x[i*(dim->size) + j ] ;\
   }\
   free_dimension(dim);\
   return re_tens;\
@@ -2564,13 +2564,13 @@ 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->size;\
+    long 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->rank;++i) dim->shape[i+1]=part_dim->shape[i];\
+      for(long i=0; i<part_dim->rank;++i) dim->shape[i+1]=part_dim->shape[i];\
     }else{\
-      size_t i=0;\
+      long i=0;\
       for(i=0; i<part_dim->rank;++i) dim->shape[i]=part_dim->shape[i];\
       dim->shape[i]=miss_part_d;\
       \
@@ -2597,17 +2597,17 @@ void free_array_chainlist_##type(array_chainlist_##type *l_a){\
 }\
 \
 tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
-  size_t dimrnk = (org->dim)->rank; \
+  long 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];\
+  for(long i=0; i<dimrnk; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimrnk-1)-i];\
   updateDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_tr");\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
-  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){\
+  long *coord = malloc((dimrnk)*sizeof(size_t));\
+  long *coord_tr = malloc((dimrnk)*sizeof(size_t));\
+  for(long i=0; i<dim_tr->size; ++i){\
     vCoordFromLin(coord,i,org->dim);\
-    for(size_t j=0; j<dimrnk;++j)  coord_tr[j]=coord[dimrnk-1-j]; \
+    for(long 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);\
@@ -2618,19 +2618,19 @@ tensor_##type * transpose_notOpt_tensor_##type(tensor_##type *org){\
 \
 tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org){\
   dimension *dim= org->dim;\
-  size_t dimrnk = dim->rank;\
+  long dimrnk = dim->rank;\
   dimension *dim_tr=create_dim(dimrnk);\
-  for(size_t i=0; i<dimrnk; ++i) dim_tr->shape[i]=dim->shape[(dimrnk-1)-i];\
+  for(long i=0; i<dimrnk; ++i) dim_tr->shape[i]=dim->shape[(dimrnk-1)-i];\
   /*updateDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_trOpt");*/\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
   /*tensor_##type *tens_tr = CREATE_TENSOR_##type(dim_tr);*/\
   long int cur_tr=0, add_tr=0, minus_tr=0;\
   tens_tr->x[cur_tr] = org->x[cur_tr];\
-  for(size_t i=1; i<dim_tr->size; ++i){\
+  for(long i=1; i<dim_tr->size; ++i){\
     minus_tr =0;\
     /*printf("DEBUG: cur_tr=%ld\n",cur_tr);*/\
-    for(size_t l=0; l<dimrnk; ++l){      \
+    for(long l=0; l<dimrnk; ++l){      \
       add_tr = minus_tr + dim_tr->basis[l+1];\
       if(cur_tr + add_tr < dim_tr->basis[l]){\
         cur_tr += add_tr;\
@@ -2649,19 +2649,19 @@ tensor_##type * transpose_Opt0_tensor_##type(tensor_##type *org){\
 tensor_##type * transpose_Opt1_tensor_##type(tensor_##type *org){\
   dimension *dim= org->dim;\
   /*updateDim(dim);*/\
-  size_t dimrnk = dim->rank;\
+  long dimrnk = dim->rank;\
   dimension *dim_tr=create_dim(dimrnk);\
-  for(size_t i=0; i<dimrnk; ++i) dim_tr->shape[i]=dim->shape[(dimrnk-1)-i];\
+  for(long i=0; i<dimrnk; ++i) dim_tr->shape[i]=dim->shape[(dimrnk-1)-i];\
   /*updateDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_trOpt");*/\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
   /*tensor_##type *tens_tr = CREATE_TENSOR_##type(dim_tr);*/\
   long int cur_tr=0, add_tr=0, minus_tr=0;\
   tens_tr->x[cur_tr] = org->x[cur_tr];\
-  for(size_t i=1; i<dim->size; ++i){\
+  for(long i=1; i<dim->size; ++i){\
     minus_tr =0;\
     /*printf("DEBUG: cur_tr=%ld\n",cur_tr);*/\
-    for(size_t l=0; l<dimrnk; ++l){      \
+    for(long l=0; l<dimrnk; ++l){      \
       add_tr = minus_tr + dim->basis[l+1];\
       if(cur_tr + add_tr < dim->basis[l]){\
         cur_tr += add_tr;\
@@ -2677,17 +2677,17 @@ tensor_##type * transpose_Opt1_tensor_##type(tensor_##type *org){\
 }\
 \
 tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dshape){\
-  size_t dimrnk = (org->dim)->rank; \
+  long 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];\
+  for(long i=0; i<dimrnk; ++i) dim_tr->shape[i]=(org->dim)->shape[(dimrnk-1)-i];\
   updateDim(dim_tr);\
   printDebug_dimension(dim_tr,"dim_tr");\
   tensor_##type *tens_tr = create_tensor_##type(dim_tr);\
-  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){\
+  long *coord = malloc((dimrnk)*sizeof(size_t));\
+  long *coord_tr = malloc((dimrnk)*sizeof(size_t));\
+  for(long i=0; i<dim_tr->size; ++i){\
     vCoordFromLin(coord,i,org->dim);\
-    for(size_t j=0; j<dimrnk;++j)  coord_tr[j]=coord[dshape->shape[j]]; \
+    for(long 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);\
@@ -2696,24 +2696,24 @@ tensor_##type * permute_notOpt_tensor_##type(tensor_##type *org, dimension *dsha
 }\
 struct arg_1Update_##type{\
   type *M0x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type);\
 };\
 void* run1UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_1Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M0x[i]);\
    }\
   return 0;\
 }\
 \
-void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nbthread){\
+void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), long nbthread){\
     \
   pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
   struct arg_1Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_1Update_##type *));\
 \
-  for(size_t i = 0; i < nbthread; ++i){\
+  for(long i = 0; i < nbthread; ++i){\
     arg_th[i]=malloc(sizeof(struct arg_1Update_##type));\
     arg_th[i]->M0x=M0->x;\
     arg_th[i]->func=func;\
@@ -2723,7 +2723,7 @@ void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nb
     pthread_create(&thrd[i], NULL, run1UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
   }\
 \
-  for(size_t i=0; i< nbthread; ++i){\
+  for(long i=0; i< nbthread; ++i){\
     pthread_join(thrd[i], NULL);\
     free(arg_th[i]);\
   }\
@@ -2735,24 +2735,24 @@ void update_1tensor_func_##type(tensor_##type *M0, type (*func)(type), size_t nb
 struct arg_2Update_##type{\
   type *M0x;\
   type *M1x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type);\
 };\
 void* run2UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_2Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M1x[i]);\
    }\
   return 0;\
 }\
 \
-void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*func)(type), size_t nbthread){\
+void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*func)(type), long nbthread){\
   if ( is_equal_dim(M0->dim,M1->dim)){ \
     pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
     struct arg_2Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_2Update_##type *));\
   \
-    for(size_t i = 0; i < nbthread; ++i){\
+    for(long i = 0; i < nbthread; ++i){\
       arg_th[i]=malloc(sizeof(struct arg_2Update_##type));\
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
@@ -2763,7 +2763,7 @@ void update_2tensor_func_##type(tensor_##type *M0, tensor_##type *M1, type (*fun
       pthread_create(&thrd[i], NULL, run2UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
   \
-    for(size_t i=0; i< nbthread; ++i){\
+    for(long i=0; i< nbthread; ++i){\
       pthread_join(thrd[i], NULL);\
       free(arg_th[i]);\
     }\
@@ -2777,24 +2777,24 @@ struct arg_3Update_##type{\
   type *M0x;\
   type *M1x;\
   type *M2x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type, type);\
 };\
 void* run3UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_3Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i]);\
    }\
   return 0;\
 }\
 \
-void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, type (*func)(type,type), size_t nbthread){\
+void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, type (*func)(type,type), long nbthread){\
   if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))){  \
     pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
     struct arg_3Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_3Update_##type *));\
   \
-    for(size_t i = 0; i < nbthread; ++i){\
+    for(long i = 0; i < nbthread; ++i){\
       arg_th[i]=malloc(sizeof(struct arg_3Update_##type));\
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
@@ -2806,7 +2806,7 @@ void update_3tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       pthread_create(&thrd[i], NULL, run3UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
   \
-    for(size_t i=0; i< nbthread; ++i){\
+    for(long i=0; i< nbthread; ++i){\
       pthread_join(thrd[i], NULL);\
       free(arg_th[i]);\
     }\
@@ -2821,14 +2821,14 @@ struct arg_4Update_##type{\
   type *M0x;\
   type *M1x;\
   type *M2x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type, type,  type(*f1)(type));\
   type(*f1)(type);\
 };\
 void* run4UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_4Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i], arg_t->f1);\
    }\
   return 0;\
@@ -2837,7 +2837,7 @@ void* run4UpdatCalcfunc_thread_##type(void *arg){\
 void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##type *M2, \
     type (*func)(type, type,  type(*f1)(type)),\
     type(*f1)(type),\
-    size_t nbthread){\
+    long nbthread){\
   /*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 ");  \
@@ -2847,7 +2847,7 @@ void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
     */pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
     struct arg_4Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_4Update_##type *));\
   \
-    for(size_t i = 0; i < nbthread; ++i){\
+    for(long i = 0; i < nbthread; ++i){\
       arg_th[i]=malloc(sizeof(struct arg_4Update_##type));\
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
@@ -2860,7 +2860,7 @@ void update_4tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       pthread_create(&thrd[i], NULL, run4UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
   \
-    for(size_t i=0; i< nbthread; ++i){\
+    for(long i=0; i< nbthread; ++i){\
       pthread_join(thrd[i], NULL);\
       free(arg_th[i]);\
     }\
@@ -2875,15 +2875,15 @@ struct arg_5Update_##type{\
   type *M1x;\
   type *M2x;\
   type *M3x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type, type, type, type(*f1)(type), type (*f2)(type,type) );\
   type(*f1)(type);\
   type (*f2)(type,type);\
 };\
 void* run5UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_5Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M1x[i], arg_t->M2x[i], arg_t->M3x[i], arg_t->f1, arg_t->f2);\
    }\
   return 0;\
@@ -2893,12 +2893,12 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
     type (*func) (type, type, type, type(*f1)(type), type (*f2)(type,type)), \
     type(*f1)(type), \
     type (*f2)(type,type), \
-    size_t nbthread){\
+    long nbthread){\
   if ( is_equal_dim(M0->dim,M1->dim) && (is_equal_dim(M0->dim, M2->dim))&& (is_equal_dim(M0->dim, M3->dim))){  \
     pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
     struct arg_5Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_5Update_##type *));\
     /*printDebug_dimension(M0->dim," dim M0 in update5 "); */ \
-    for(size_t i = 0; i < nbthread; ++i){\
+    for(long i = 0; i < nbthread; ++i){\
       arg_th[i]=malloc(sizeof(struct arg_5Update_##type));\
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
@@ -2913,7 +2913,7 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
       pthread_create(&thrd[i], NULL, run5UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
   \
-    for(size_t i=0; i< nbthread; ++i){\
+    for(long i=0; i< nbthread; ++i){\
       pthread_join(thrd[i], NULL);\
       free(arg_th[i]);\
     }\
@@ -2927,14 +2927,14 @@ void update_5tensor_func_##type(tensor_##type *M0, tensor_##type *M1, tensor_##t
 struct arg_6Update_##type{\
   type *M0x;\
   type *M1x;\
-  size_t beginRange;\
-  size_t endRange;\
+  long beginRange;\
+  long endRange;\
   type (*func)(type, type, type);\
   type scalar;\
 };\
 void* run6UpdatCalcfunc_thread_##type(void *arg){\
   struct arg_6Update_##type *arg_t = arg;\
-    for (size_t i = arg_t->beginRange; i < arg_t->endRange; i++) {\
+    for (long i = arg_t->beginRange; i < arg_t->endRange; i++) {\
         arg_t->M0x[i] = arg_t->func(arg_t->M0x[i], arg_t->M1x[i], arg_t->scalar);\
    }\
   return 0;\
@@ -2943,7 +2943,7 @@ void* run6UpdatCalcfunc_thread_##type(void *arg){\
 void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
     type (*func)(type, type, type),\
     type scalar,\
-    size_t nbthread){\
+    long nbthread){\
   /*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 ");  \
@@ -2953,7 +2953,7 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
     */pthread_t *thrd = malloc(nbthread * sizeof(pthread_t));\
     struct arg_6Update_##type **arg_th = malloc( nbthread * sizeof(struct arg_6Update_##type *));\
   \
-    for(size_t i = 0; i < nbthread; ++i){\
+    for(long i = 0; i < nbthread; ++i){\
       arg_th[i]=malloc(sizeof(struct arg_6Update_##type));\
       arg_th[i]->M0x=M0->x;\
       arg_th[i]->M1x=M1->x;\
@@ -2965,7 +2965,7 @@ void update_6tensor_func_##type(tensor_##type *M0, tensor_##type *M1, \
       pthread_create(&thrd[i], NULL, run6UpdatCalcfunc_thread_##type, (void*)arg_th[i]);\
     }\
   \
-    for(size_t i=0; i< nbthread; ++i){\
+    for(long i=0; i< nbthread; ++i){\
       pthread_join(thrd[i], NULL);\
       free(arg_th[i]);\
     }\