diff --git a/tensor_t/src/tensor_t/cl_tensor_t.c b/tensor_t/src/tensor_t/cl_tensor_t.c
index 98af652..0234702 100644
--- a/tensor_t/src/tensor_t/cl_tensor_t.c
+++ b/tensor_t/src/tensor_t/cl_tensor_t.c
@@ -3,71 +3,16 @@
 
 #define MAX_SOURCE_SIZE (0x100000)
 
-
-#define CL_GEN_FUNC_TENSOR(type)\
-  tensor_##type* CREATE_CL_TENSOR_##type(dimension *dim){\
-    tensor_##type *r_tens=malloc(sizeof(tensor_##type));\
-    updateRankDim(dim);\
-    r_tens->dim = dim;\
-    r_tens->x = malloc(sizeof(type)*dim->rank);\
-    return r_tens;\
-  }\
-\
-\
-void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
-    dimension *dd;  \
-    add_dimension(&dd, M0->dim, M1->dim); \
-    (*MM)=CREATE_TENSOR_##type(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){\
-          m_idx= i*M1->dim->rank + j ;\
-          M->x[m_idx]=M0->x[i]*M1->x[j];\
-          /*printf("[%ld|%ld:(%ld,%ld)]",x_idx++,m_idx,i,j);*/\
-      }\
-    }\
-}  \
-\
-/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n /  xl = y0,x{l+1}=y1, x{n}=yl  et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
- 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 cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
-\
-    size_t len0 = M0->dim->size - contractionNumber;\
-    size_t len1 = M1->dim->size - contractionNumber;\
-\
-    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
-    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
-    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
-    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
-    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
-    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
-    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
-    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
-    dimension *dSub0 = init_dim(tsub0, len0);\
-    dimension *dSub1 = init_dim(tsub1, len1);\
-    dimension *dM1 = init_dim(tDk1, contractionNumber);\
-    dimension *dM0 = init_dim(tDk0, contractionNumber);\
-    dimension *dM;\
-    min_dimension(&dM, dM0, dM1);\
-    \
-    dimension *dd;\
-    add_dimension(&dd, dSub0, dSub1);\
-    updateRankDim(dd);\
-    *MM = CREATE_TENSOR_##type(dd);\
-    tensor_##type *M= *MM;\
-\
- \
-/* Load the kernel source code into the array source_str*/ \
+#define CL_GEN_SETUP_(type,file_cl_src,func_cl_name)\
+  /* Load the kernel source code into the array source_str*/ \
     FILE *fp; \
     char *source_str; \
     size_t source_size; \
  \
-    fp = fopen("/media/fanasina/corsair480/progr_/ytest/y_PROJECT/tensor_t/src/tensor_t/kernel_ProdContractnTensor.cl", "r"); \
+    /*fp = fopen("../src/kernel_ProdTensor.cl", "r");*/ \
+    fp = fopen(file_cl_src, "r"); \
     if (!fp) { \
-        perror("kernel_ProdContractnTensor.cl");\
+        perror(file_cl_src);\
         fprintf(stderr, "Failed to load kernel. \n"); \
         exit(1); \
     } \
@@ -114,21 +59,23 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
     ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); \
     size_t len; clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, NULL, NULL, &len);\
     char *log = malloc(sizeof(char)*len);\
-  clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, len, log, NULL);\
+    clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, len, log, NULL);\
   printf("log: %s \n",log);\
  \
     /*/ Create the OpenCL kernel */ \
-    char func_cl_name[250]; sprintf(func_cl_name,"prodContractnTensorLin_%s", #type); \
+    /*char func_cl_name[250]; sprintf(func_cl_name,"prodTensorLin_%s", #type);*/ \
     printf("cl_func_type = %s\n",func_cl_name);  \
     cl_kernel kernel = clCreateKernel(program, func_cl_name, &ret); \
- \
+ 
+
     /*/ Set the arguments of the kernel  */ \
-    ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(dSub1->rank)); \
-    ret = clSetKernelArg(kernel, 1, sizeof(size_t), (void *)&(dM->rank)); \
-    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M0_mem_obj); \
-    ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M1_mem_obj); \
-    ret = clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&M_mem_obj); \
- \
+    /*ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(M1->dim->rank)); \
+    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&M0_mem_obj); \
+    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M1_mem_obj); \
+    ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M_mem_obj); \
+ */
+
+#define CL_EXEC_KERNEL(type)\
     /*/ Execute the OpenCL kernel on the list */ \
     size_t global_item_size = M->dim->rank; /*/ Process the entire lists */ \
     size_t local_item_size = 1;  /*64;*/ /*/ Divide work items into groups of 64 */ \
@@ -149,8 +96,72 @@ void cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor
     ret = clReleaseMemObject(M_mem_obj); \
     ret = clReleaseCommandQueue(command_queue); \
     ret = clReleaseContext(context); \
+
+#define CL_GEN_FUNC_TENSOR(type)\
+\
+\
+void cl_tensorProd_##type(tensor_##type **MM, tensor_##type *M0, tensor_##type *M1) {  \
+    dimension *dd;  \
+    add_dimension(&dd, M0->dim, M1->dim); \
+    (*MM)=CREATE_TENSOR_##type(dd);  \
+    tensor_##type *M = *MM; \
+    char *file_cl_src = "../src/kernel_ProdTensor.cl"; \
+    char *func_cl_name = "prodTensorLin_" #type; \
+  CL_GEN_SETUP_(type,file_cl_src,func_cl_name);\
+    /*/ Set the arguments of the kernel  */ \
+    ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(M1->dim->rank)); \
+    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&M0_mem_obj); \
+    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M1_mem_obj); \
+    ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M_mem_obj); \
+  CL_EXEC_KERNEL(type);\
+}  \
+\
+/* M[x0,x1,x3..xn] X M[y0,y1,y3..ym] = M[z0,z1...zp] (deep = l > 0) /exists 1<= l<...<l=n /  xl = y0,x{l+1}=y1, x{n}=yl  et zi=xi i<n-l et zj=y{j-(n-l)} j>=n-l alor p=n+m-2l\
+ 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 cl_tensorContractnProd_##type(tensor_##type** MM, tensor_##type *M0, tensor_##type *M1, size_t contractionNumber) {\
+\
+    size_t len0 = M0->dim->size - contractionNumber;\
+    size_t len1 = M1->dim->size - contractionNumber;\
+\
+    size_t* tsub0 = malloc(sizeof(size_t) *len0);\
+    size_t* tsub1 = malloc(sizeof(size_t) *len1);\
+    size_t* tDk1 = malloc(sizeof(size_t) *contractionNumber);\
+    size_t* tDk0 = malloc(sizeof(size_t) *contractionNumber);\
+    subArray(tsub0, M0->dim->perm, 0, len0, 0);\
+    subArray(tsub1, M1->dim->perm, 0, len1, contractionNumber);\
+    subArray(tDk1, M1->dim->perm, 0, contractionNumber, 0);\
+    subArray(tDk0, M0->dim->perm, 0, contractionNumber, len0);\
+    dimension *dSub0 = init_dim(tsub0, len0);\
+    dimension *dSub1 = init_dim(tsub1, len1);\
+    dimension *dM1 = init_dim(tDk1, contractionNumber);\
+    dimension *dM0 = init_dim(tDk0, contractionNumber);\
+    dimension *dM;\
+    min_dimension(&dM, dM0, dM1);\
+    \
+    dimension *dd;\
+    add_dimension(&dd, dSub0, dSub1);\
+    updateRankDim(dd);\
+    *MM = CREATE_TENSOR_##type(dd);\
+    tensor_##type *M= *MM;\
+    char *file_cl_src = "../src/kernel_ProdContractnTensor.cl"; \
+    char *func_cl_name = "prodContractnTensorLin_" #type; \
+  CL_GEN_SETUP_(type,file_cl_src,func_cl_name);\
+  \
+    /*/ Set the arguments of the kernel  */ \
+    ret = clSetKernelArg(kernel, 0, sizeof(size_t), (void *)&(dSub1->rank)); \
+    ret = clSetKernelArg(kernel, 1, sizeof(size_t), (void *)&(dM->rank)); \
+    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&M0_mem_obj); \
+    ret = clSetKernelArg(kernel, 3, sizeof(cl_mem), (void *)&M1_mem_obj); \
+    ret = clSetKernelArg(kernel, 4, sizeof(cl_mem), (void *)&M_mem_obj); \
+ \
+  CL_EXEC_KERNEL(type);\
+\
 } \
 
 
 CL_GEN_FUNC_TENSOR(TYPE_FLOAT);
 CL_GEN_FUNC_TENSOR(TYPE_DOUBLE);
+
+
diff --git a/tensor_t/test/is_good.c b/tensor_t/test/is_good.c
index 92b328c..5f82ae3 100644
--- a/tensor_t/test/is_good.c
+++ b/tensor_t/test/is_good.c
@@ -85,10 +85,7 @@ TEST(tensorProd ){
 
   print_tensor_float(M,"M");
 
-  size_t x_idx=0, m_idx;
-  for(size_t i=0; i<M->dim->rank; ++i){
-     EXPECT_EQ_TYPE_FLOAT(Mn->x[i],M->x[i]); 
-  } 
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
 
   print_tensor_float(Mn,"Mn");
 }
@@ -141,13 +138,13 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
 
-  d0->perm[0]=5;
-  d0->perm[1]=2; //3;
-  d0->perm[2]=3;
+  d0->perm[0]=35;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=23;
 
-  d1->perm[0]=2;
-  d1->perm[1]=3;//3;
-  d1->perm[2]=4;
+  d1->perm[0]=32;
+  d1->perm[1]=23;//3;
+  d1->perm[2]=44;
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -161,23 +158,23 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
-  print_tensor_float(M0,"M0");
-  print_tensor_float(M1,"M1");
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
 
   tensor_TYPE_FLOAT *M;
   tensor_TYPE_FLOAT *MnO;
 
   tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
-  print_tensor_float(M,"M");
+//  print_tensor_float(M,"M");
   tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
 
 
-  print_tensor_float(MnO,"MnO");
+//  print_tensor_float(MnO,"MnO");
  
   // for(size_t i=0;i<M->dim->rank;++i)
   //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
     
-  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
 
 }
@@ -185,14 +182,14 @@ TEST(tensorContractnProd_TYPE_FLOAT2 ){
 TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
+  
+  d0->perm[0]=35;
+  d0->perm[1]=32; //3;
+  d0->perm[2]=23;
 
-  d0->perm[0]=5;
-  d0->perm[1]=2; //3;
-  d0->perm[2]=3;
-
-  d1->perm[0]=2;
-  d1->perm[1]=3;//3;
-  d1->perm[2]=4;
+  d1->perm[0]=32;
+  d1->perm[1]=23;//3;
+  d1->perm[2]=44;
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -206,23 +203,23 @@ TEST(cl_tensorContractnProd_TYPE_FLOAT2 ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
-  print_tensor_float(M0,"M0");
-  print_tensor_float(M1,"M1");
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
 
   tensor_TYPE_FLOAT *M;
   tensor_TYPE_FLOAT *MnO;
 
-  tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
-  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&M, M0,M1,2);
+//  print_tensor_float(M,"M");
   cl_tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,2);
 
 
-  print_tensor_float(MnO,"MnO");
+//  print_tensor_float(MnO,"MnO");
  
   // for(size_t i=0;i<M->dim->rank;++i)
   //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
     
-  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
 
 
 }
@@ -231,13 +228,13 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
 
-  d0->perm[0]=5;
-  d0->perm[1]=2; //3;
-  d0->perm[2]=3;
+  d0->perm[0]=125;
+  d0->perm[1]=52; //3;
+  d0->perm[2]=63;
 
-  d1->perm[0]=2;
-  d1->perm[1]=3;//3;
-  d1->perm[2]=4;
+  d1->perm[0]=52;
+  d1->perm[1]=63;//3;
+  d1->perm[2]=54;
 
   updateRankDim(d0);
   updateRankDim(d1);
@@ -251,18 +248,19 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
   for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
   for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
 
-  print_tensor_double(M0,"M0");
-  print_tensor_double(M1,"M1");
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
 
   tensor_TYPE_DOUBLE *M;
   tensor_TYPE_DOUBLE *MnO;
 
-  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
-  print_tensor_double(M,"M");
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
   cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
 
 
-  print_tensor_double(MnO,"MnO");
+  //print_tensor_double(MnO,"MnO");
  
   // for(size_t i=0;i<M->dim->rank;++i)
   //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
@@ -271,6 +269,189 @@ TEST(cl_tensorContractnProd_TYPE_DOUBLE2 ){
 
 
 }
+
+
+TEST(tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  d0->perm[0]=125;
+  d0->perm[1]=52; //3;
+  d0->perm[2]=63;
+
+  d1->perm[0]=52;
+  d1->perm[1]=63;//3;
+  d1->perm[2]=54;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+
+}
+
+TEST(TensorProdCL){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+
+  d0->perm[0]=2;
+  d0->perm[1]=3;
+  d0->perm[2]=2;
+  
+  d1->perm[0]=2;
+  d1->perm[1]=3;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = CREATE_TENSOR_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = CREATE_TENSOR_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+
+  tensor_TYPE_FLOAT *M; 
+  tensor_TYPE_FLOAT *Mn; 
+
+  tensorProd_TYPE_FLOAT(&M,M0,M1);
+  cl_tensorProd_TYPE_FLOAT(&Mn,M0,M1);
+  LOG("M->dim->rank = %ld\n",M->dim->rank);
+
+  print_tensor_float(M,"M");
+  
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->rank,Mn->x,Mn->dim->rank);
+
+
+  print_tensor_float(Mn,"Mn");
+}
+
+TEST(VS_cl_tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  d0->perm[0]=125;
+  d0->perm[1]=52; //3;
+  d0->perm[2]=63;
+
+  d1->perm[0]=52;
+  d1->perm[1]=63;//3;
+  d1->perm[2]=154;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  //tensor_TYPE_DOUBLE *M;
+  tensor_TYPE_DOUBLE *MnO;
+
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+
+}
+
+
+TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  d0->perm[0]=125;
+  d0->perm[1]=52; //3;
+  d0->perm[2]=63;
+
+  d1->perm[0]=52;
+  d1->perm[1]=63;//3;
+  d1->perm[2]=154;
+
+  updateRankDim(d0);
+  updateRankDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = CREATE_TENSOR_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = CREATE_TENSOR_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->rank = %ld\n",M0->dim->rank);
+  LOG("M1->dim->rank = %ld\n",M1->dim->rank);
+  for(size_t i=0; i<M0->dim->rank;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->rank;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M;
+  //tensor_TYPE_DOUBLE *MnO;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  //tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->rank;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->rank,MnO->x,MnO->dim->rank);
+
+
+}
+
+
+
 int main(int argc, char **argv){
   
 
diff --git a/ytest_t/libytest.so b/ytest_t/libytest.so
index a3ca4f8..a823520 100644
Binary files a/ytest_t/libytest.so and b/ytest_t/libytest.so differ
diff --git a/ytools_t/src/tools_t/tools_t.c b/ytools_t/src/tools_t/tools_t.c
index 2c3b095..0afbcb2 100644
--- a/ytools_t/src/tools_t/tools_t.c
+++ b/ytools_t/src/tools_t/tools_t.c
@@ -78,10 +78,11 @@ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){
 // with gcc we can change value of theses  PRECISION_TYPES below with: gcc -D PRECISION_TYPE_FLOAT=100000 for instance!
 #ifndef PRECISION_TYPE_FLOAT 
   /*#define PRECISION_TYPE_FLOAT 100000000*/
-  #define PRECISION_TYPE_FLOAT 100000
+  #define PRECISION_TYPE_FLOAT 10
 #endif
 #ifndef PRECISION_TYPE_DOUBLE
-  #define PRECISION_TYPE_DOUBLE 100000000000
+  /*#define PRECISION_TYPE_DOUBLE 100000000000*/
+  #define PRECISION_TYPE_DOUBLE 1000
 #endif
 #ifndef PRECISION_TYPE_L_DOUBLE
   #define PRECISION_TYPE_L_DOUBLE 100000000000000