From 7581a2612a0d204b64efc2e68394e0ace32d5185 Mon Sep 17 00:00:00 2001
From: fanasina <rafanasin@gmail.com>
Date: Wed, 22 Jul 2026 23:37:13 +0200
Subject: [PATCH] [add] test tensor

---
 onetensor/input.txt    |    8 +
 onetensor/tesTensor.c  | 2738 ++++++++++++++++++++++++++++++++++++++++
 onetensor/unkinput.txt |   15 +
 3 files changed, 2761 insertions(+)
 create mode 100644 onetensor/input.txt
 create mode 100644 onetensor/tesTensor.c
 create mode 100644 onetensor/unkinput.txt

diff --git a/onetensor/input.txt b/onetensor/input.txt
new file mode 100644
index 0000000..ee6b299
--- /dev/null
+++ b/onetensor/input.txt
@@ -0,0 +1,8 @@
+[6,8,1]
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+
diff --git a/onetensor/tesTensor.c b/onetensor/tesTensor.c
new file mode 100644
index 0000000..df86246
--- /dev/null
+++ b/onetensor/tesTensor.c
@@ -0,0 +1,2738 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+// for sleep !
+#ifdef __linux__ 
+  #include <unistd.h>
+#elif _WIN32 
+  #include <windows.h>
+#endif
+
+/*
+#include "ftest/ftest.h"
+#include "ftest/ftest_array.h"
+#include "fmock/fmock.h"
+*/
+
+#include "../linktest/y_test_h.h"
+
+IMPLEMENTATION_FTEST()
+
+
+//#include "shapeutation_t/shapeutation_t.h"
+//#include "tensor_t/tensor_t.h"
+
+#include "y_tensor_h.h"
+
+#ifndef _IMPLEMENTATION_DIMENSION
+#define _IMPLEMENTATION_DIMENSION
+IMPLEMENTATION_DIMENSION()
+#endif /* _IMPLEMENTATION_DIMENSION */
+
+#ifndef _IMPLEMENTATION_TENSOR
+#define _IMPLEMENTATION_TENSOR
+IMPLEMENTATION_TENSOR()
+#endif /* _IMPLEMENTATION_TENSOR */
+
+#define VALGRIND_ 1
+
+TEST(rank){
+  littleEndian =true;
+  dimension *D=create_dim(4);
+  D->shape[0]=2;
+  D->shape[1]=3;
+  D->shape[2]=5;
+  D->shape[3]=6;
+
+  updateDim(D);
+  tensor_TYPE_FLOAT *tf = create_tensor_TYPE_FLOAT(D);
+  EXPECT_EQ(tf->dim->size, 180);
+
+  free_tensor_TYPE_FLOAT(tf);
+}
+
+void print_tensor_float(tensor_TYPE_FLOAT *M, char *msg){
+  if(M==NULL) {
+    LOG("empty tensor | %s ===============\n",msg);
+    return;
+  }
+  LOG("================= %s ===============\n",msg);
+
+  /*for(size_t i=0; i<M->dim->size;++i)
+      LOG("[%ld]: %f ",i,M->x[i]);
+  */
+  print_tensor_msg_TYPE_FLOAT(M,msg);
+  LOG("%s","\n");
+}
+
+
+void print_tensor_double(tensor_TYPE_DOUBLE *M, char *msg){
+  LOG("================= %s ===============\n",msg);
+#if VALGRIND_
+  /*
+  for(size_t i=0; i<M->dim->size;++i)
+      LOG("[%ld]: %lf ",i,M->x[i]);
+  */
+  print_tensor_msg_TYPE_DOUBLE(M,msg);
+#endif
+    LOG("%s","\n");
+}
+
+TEST(tensorMinusSubhead_ ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+  //littleEndian=false;
+  size_t rnkId = 1;
+  tensor_TYPE_FLOAT *s2h = sub_copy_minus_tensor_head_TYPE_FLOAT(M0,1,rnkId);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2h, "sub s2h of M0");
+
+  printDebug_dimension(M0->dim," M0 dimension  ");
+  printDebug_dimension(s2h->dim," s2h dimension  ");
+ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M0->x,s2h->dim->size,s2h->x,s2h->dim->size);
+ 
+  for(size_t i1=0; i1<d0->shape[1];++i1){
+    for(size_t i0=0; i0<d0->shape[0];++i0){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim),rnkId,i0,i1,LineFromCoord((size_t[]){i0,i1},s2h->dim),i0,i1);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]);
+    }  
+  }
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2h);
+}
+
+TEST(tensorMinusSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+  tensor_TYPE_FLOAT *s1t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,5);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s1t, "sub s2t of M0 from 5");
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s1t);
+}
+
+
+TEST(tensorMinusSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+  //littleEndian=false;
+  size_t rnkId=3;
+  tensor_TYPE_FLOAT *s2t = sub_copy_minus_tensor_tail_TYPE_FLOAT(M0,1,rnkId);
+
+
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2t, "sub s2t of M0 from 3");
+
+  for(size_t i1=0; i1<d0->shape[1];++i1){
+    for(size_t i2=0; i2<d0->shape[2];++i2){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim),rnkId,i1,i2,LineFromCoord((size_t[]){i1,i2},s2t->dim),i1,i2);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim)],s2t->x[LineFromCoord((size_t[]){i1,i2},s2t->dim)]);
+    }  
+  }
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2t);
+}
+
+TEST(tensorSubhead_ ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+  //littleEndian=false;
+  size_t rnkId = 1;
+  tensor_TYPE_FLOAT *s2h = sub_copy_tensor_head_TYPE_FLOAT(M0,2,rnkId);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2h, "sub s2h of M0");
+
+  printDebug_dimension(M0->dim," M0 dimension  ");
+  printDebug_dimension(s2h->dim," s2h dimension  ");
+ //EXPECT_ARRAY_EQ_TYPE_FLOAT(M0->x,s2h->dim->size,s2h->x,s2h->dim->size);
+ 
+  for(size_t i1=0; i1<d0->shape[1];++i1){
+    for(size_t i0=0; i0<d0->shape[0];++i0){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim),rnkId,i0,i1,LineFromCoord((size_t[]){i0,i1},s2h->dim),i0,i1);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((size_t[]){i0,i1},s2h->dim)]);
+    }  
+  }
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2h);
+}
+TEST(tensorSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+
+  tensor_TYPE_FLOAT *s1t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,5);
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s1t, "sub s2t of M0 from 5");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s1t);
+
+}
+
+
+TEST(tensorSubtail ){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+  //littleEndian=false;
+  size_t rnkId=3;
+  tensor_TYPE_FLOAT *s2t = sub_copy_tensor_tail_TYPE_FLOAT(M0,2,rnkId);
+
+
+
+  print_tensor_float(M0, "M0 for sub");
+  print_tensor_float(s2t, "sub s2t of M0 from 3");
+
+  for(size_t i1=0; i1<d0->shape[1];++i1){
+    for(size_t i2=0; i2<d0->shape[2];++i2){
+      printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim),rnkId,i1,i2,LineFromCoord((size_t[]){i1,i2},s2t->dim),i1,i2);
+      EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((size_t[]){rnkId,i1,i2},M0->dim)],s2t->x[LineFromCoord((size_t[]){i1,i2},s2t->dim)]);
+    }  
+  }
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(s2t);
+}
+
+TEST(randomInit){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "M0 random");
+  free_tensor_TYPE_FLOAT(M0);
+}
+TEST(printT_init_false){
+  littleEndian=false;
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  //init_random_x_TYPE_FLOAT(M0,2,5,50);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+
+//  print_tensor_float(M0, "M0 ");
+  print_tensor_msg_TYPE_FLOAT(M0, "M0 ");
+  free_tensor_TYPE_FLOAT(M0);
+  
+}
+
+
+TEST(printT_Init_true){
+  littleEndian=true;
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  //init_random_x_TYPE_FLOAT(M0,2,5,50);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+
+
+//  print_tensor_float(M0, "M0 ");
+  print_tensor_msg_TYPE_FLOAT(M0, "M0 ");
+  free_tensor_TYPE_FLOAT(M0);
+  
+}
+
+TEST(sprinttens){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=2;
+
+
+  updateDim(d0);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_DOUBLE(M0,2.7,5.4,50001);
+
+  //print_tensor_double(M0, "test print M0");
+  char *tensCont = NULL;
+  size_t nbChar = sprint_tensor_TYPE_DOUBLE(&tensCont, M0, false);
+
+  LOG(" avec Sprint_tensor sans index, M0 est : \n%s \n, il y a %ld charactères\n",tensCont, nbChar);
+  
+  nbChar = sprint_tensor_TYPE_DOUBLE(&tensCont, M0, true);
+
+  LOG(" avec Sprint_tensor avec index, M0 est : \n%s \n, il y a %ld charactères\n",tensCont, nbChar);
+
+  littleEndian=false;
+ 
+  nbChar = sprint_tensor_TYPE_DOUBLE(&tensCont, M0, true);
+
+  LOG(" avec Sprint_tensor avec index et littleEndian=false, M0 est : \n%s \n, il y a %ld charactères\n",tensCont, nbChar);
+
+
+  free(tensCont);
+  free_tensor_TYPE_DOUBLE(M0);
+}
+
+
+#if 1
+
+TEST(Split_randomInit){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "M0 random");
+  print_tensor_msg_TYPE_FLOAT(M0, "M0 random");
+
+  tensor_TYPE_FLOAT *Tpart1=NULL, *Tpart2=NULL;
+
+  //split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 1, 2);
+  //split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 2, 3);
+  split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 1, 1);
+
+  print_tensor_float(Tpart1, " Tpart1 1");
+  //print_tensor_msg_TYPE_FLOAT(Tpart1, " Tpart1 1");
+  print_tensor_float(Tpart2, "Tpart2 ..");
+  //print_tensor_msg_TYPE_FLOAT(Tpart2, "Tpart2 ..");
+
+//  printDebug_dimension(Tpart1->dim,"dim part1 "); 
+//  printDebug_dimension(Tpart2->dim,"dim part2 "); 
+//  printDebug_dimension(M0->dim,"dim root "); 
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_dimension(Tpart1->dim);
+  free_dimension(Tpart2->dim);
+  free(Tpart1);
+  free(Tpart2);
+}
+#endif
+
+#if 1
+
+TEST(Split_randomInit){
+  //littleEndian=false;
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=4;
+  d0->shape[1]=3;
+  d0->shape[2]=5;
+  
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "M0 random");
+
+  tensor_TYPE_FLOAT *Tpart1=NULL, *Tpart2=NULL;
+
+  //split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 2, 4);
+  split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 0, 1);
+  //split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 2, 1);
+
+  print_tensor_float(Tpart1, " Tpart1 1");
+  print_tensor_float(Tpart2, "Tpart2 ..");
+
+  printDebug_dimension(Tpart1->dim,"dim part1 "); 
+  printDebug_dimension(Tpart2->dim,"dim part2 "); 
+  printDebug_dimension(M0->dim,"dim root "); 
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_dimension(Tpart1->dim);
+  free_dimension(Tpart2->dim);
+  free(Tpart1);
+  free(Tpart2);
+}
+#endif
+
+
+#if 1
+
+TEST(SplitOne_randomInit){
+  dimension *d0=create_dim(1);
+
+  d0->shape[0]=4;
+
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "M0 random");
+
+  tensor_TYPE_FLOAT *Tpart1=NULL, *Tpart2=NULL;
+
+  if(littleEndian){
+    split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 0, 1);
+  }else{
+    split_tensor_TYPE_FLOAT(M0,&Tpart1,&Tpart2, 0, 3);
+  }
+
+  print_tensor_float(Tpart1, " Tpart1 1");
+  print_tensor_float(Tpart2, "Tpart2 ..");
+
+  printDebug_dimension(Tpart1->dim,"dim part1 ");
+  printDebug_dimension(Tpart2->dim,"dim part2 ");
+  printDebug_dimension(M0->dim,"dim root ");
+
+  for(size_t i=0;i<(Tpart1->dim)->size;++i) Tpart1->x[i]=0;
+  print_tensor_float(Tpart1, "Tpart1 0");
+  print_tensor_float(M0, "M0 Tpart1 0");
+
+  free_tensor_TYPE_FLOAT(M0);
+  free_dimension(Tpart1->dim);
+  free_dimension(Tpart2->dim);
+  free(Tpart1);
+  free(Tpart2);
+}
+#endif
+
+TEST(tensorProdNoOpt){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+
+#else
+
+
+  d0->shape[0]=5;
+  d0->shape[1]=7; //3;
+  d0->shape[2]=12;
+
+  d1->shape[0]=2;
+  d1->shape[1]=13;//3;
+#endif
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+  
+  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  
+  float MMM0[d0->shape[0]][d0->shape[1]][d0->shape[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->shape[0]][d1->shape[1]];
+  long int coord2[2];
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+    coord2[0]=j0; coord2[1]=j1;
+    MMM1[j0][j1]=M1->x[signedLineFromCoord(coord2, d1)];
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->shape[0]][d0->shape[1]][d0->shape[2]][d1->shape[0]][d1->shape[1]];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+    MMMm[i0][i1][i2][j0][j1]=MMM0[i0][i1][i2] * MMM1[j0][j1];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+  }
+  }
+  }
+  }
+  }
+  //LOG("M->dim->size = %ld\n",M->dim->size);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+  long int coord5[5];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+    coord5[0]=i0; coord5[1]=i1;coord5[2]=i2;
+    coord5[3]=j0; coord5[4]=j1;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][i2][j0][j1], Mn->x[signedLineFromCoord(coord5, Mn->dim)] );
+  }
+  }
+  }
+  }
+  }
+
+  print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+}
+TEST(tensorProd ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+
+#else
+
+
+  d0->shape[0]=35;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=23;
+
+  d1->shape[0]=32;
+  d1->shape[1]=23;//3;
+#endif
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+
+  tensorProd_TYPE_FLOAT(&M,M0,M1);
+  tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  LOG("M->dim->size = %ld\n",M->dim->size);
+
+  print_tensor_float(M,"M");
+
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+
+  print_tensor_float(Mn,"Mn");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+}
+
+TEST(tensorContractnProd_TYPE_FLOATNoOpt ){ 
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=3;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=15;
+  d0->shape[1]=12; //3;
+  d0->shape[2]=13;
+
+  d1->shape[0]=13;
+  d1->shape[1]=15;//3;
+  d1->shape[2]=14;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,1);
+  //tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,1);
+printDebug_dimension(MnO->dim, "dim Contr 1");
+  float MMM0[d0->shape[0]][d0->shape[1]][d0->shape[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->shape[0]][d1->shape[1]][d1->shape[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->shape[0]][d0->shape[1]][d1->shape[1]][d1->shape[2]];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    MMMm[i0][i1][j1][j2]=0;
+      for(long int i2=0;i2<d0->shape[2];++i2){
+        MMMm[i0][i1][j1][j2] += MMM0[i0][i1][i2] * MMM1[i2][j1][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+  }
+  }
+  }
+  }
+  //LOG("M->dim->size = %ld\n",M->dim->size);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+  long int coord4[4];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord4[0]=i0; coord4[1]=i1; coord4[2]=j1; coord4[3]=j2;
+    //EXPECT_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] );
+   
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][i1][j1][j2], MnO->x[signedLineFromCoord(coord4, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld, %ld, %ld ] [%ld]\n",i0,i1,j1,j2,
+      signedLineFromCoord(coord4, MnO->dim)
+      );
+
+   }
+   
+  }
+  }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_FLOATNoOpt2 ){
+  littleEndian=true; //
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=35;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=23;
+
+  d1->shape[0]=32;
+  d1->shape[1]=23;//3;
+  d1->shape[2]=44;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+  float MMM0[d0->shape[0]][d0->shape[1]][d0->shape[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->shape[0]][d1->shape[1]][d1->shape[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->shape[0]][d1->shape[2]];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    MMMm[i0][j2]=0;
+    for(long int i1=0;i1<d0->shape[1];++i1){
+      for(long int i2=0;i2<d0->shape[2];++i2){
+        MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+    }
+  }
+  }
+  //LOG("M->dim->size = %ld\n",M->dim->size);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+  long int coord52[2];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord52[0]=i0; coord52[1]=j2;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
+  
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld] [%ld]\n",i0,j2,
+      signedLineFromCoord(coord52, MnO->dim)
+      );
+
+   }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
+  littleEndian=false;
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=3;
+  d1->shape[1]=2;//3;
+  d1->shape[2]=5;
+
+#else
+
+
+  d0->shape[0]=13;
+  d0->shape[1]=12; //3;
+  d0->shape[2]=35;
+
+  d1->shape[0]=35;
+  d1->shape[1]=12;//3;
+  d1->shape[2]=13;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+  float MMM0[d0->shape[0]][d0->shape[1]][d0->shape[2]];
+  long int coord3[3];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int i1=0;i1<d0->shape[1];++i1){
+  for(long int i2=0;i2<d0->shape[2];++i2){
+    coord3[0]=i0; coord3[1]=i1; coord3[2]=i2;
+    MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+  }
+  }
+  }
+
+  float MMM1[d1->shape[0]][d1->shape[1]][d1->shape[2]];
+  long int coord23[3];
+  for(long int j0=0;j0<d1->shape[0];++j0){
+  for(long int j1=0;j1<d1->shape[1];++j1){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord23[0]=j0; coord23[1]=j1; coord23[2]=j2;
+    MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+  }
+  }
+  }
+  //tensorProd_TYPE_FLOAT(&M,M0,M1);
+  float MMMm[d0->shape[0]][d1->shape[2]];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    MMMm[i0][j2]=0;
+    for(long int i1=0;i1<d0->shape[1];++i1){
+      for(long int i2=0;i2<d0->shape[2];++i2){
+        MMMm[i0][j2] += MMM0[i0][i1][i2] * MMM1[i1][i2][j2];
+    //printf("MMMm[%ld][%ld][%ld][%ld][%ld] = %f \n",i0,i1,i2,j0,j1,MMMm[i0][i1][i2][j0][j1]);
+      }
+    }
+  }
+  }
+  //LOG("M->dim->size = %ld\n",M->dim->size);
+
+  //print_tensor_float(M,"M");
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+  long int coord52[2];
+  for(long int i0=0;i0<d0->shape[0];++i0){
+  for(long int j2=0;j2<d1->shape[2];++j2){
+    coord52[0]=i0; coord52[1]=j2;
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] );
+  
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false){
+      LOG("[ %ld, %ld] [%ld]\n",i0,j2,
+      signedLineFromCoord(coord52, MnO->dim)
+      );
+
+   }
+  }
+  }
+
+  //print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  //free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+  littleEndian=true;
+
+}
+
+
+
+TEST(tensorContractnProd_TYPE_FLOAT ){ 
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=35;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=23;
+
+  d1->shape[0]=32;
+  d1->shape[1]=23;//3;
+  d1->shape[2]=44;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_float(M0,"M0");
+  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+  print_tensor_float(M,"M");
+  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //  EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnProd_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnProdOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdOpt0_TYPE_FLOAT(&M, M0,M1,2);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+
+TEST(tensorContractnProdThreadOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnPro2dThreadOpt0_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnPro2dThreadOpt0_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+TEST(tensorContractnPro2dThread_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnPro2dThread_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+
+
+
+TEST(tensorContractnProdThread_TYPE_FLOAT2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+
+  d0->shape[0]=335;
+  d0->shape[1]=32; //3;
+  d0->shape[2]=43;
+
+  d1->shape[0]=32;
+  d1->shape[1]=43;//3;
+  d1->shape[2]=244;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+//  print_tensor_float(M0,"M0");
+//  print_tensor_float(M1,"M1");
+
+  tensor_TYPE_FLOAT *M=NULL;
+  tensor_TYPE_FLOAT *MnO=NULL;
+
+  tensorContractnProdThread_TYPE_FLOAT(&M, M0,M1,2,8);
+//  print_tensor_float(M,"M");
+  tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
+
+
+//  print_tensor_float(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_FLOAT(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(MnO);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+
+}
+TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
+  dimension *d0=create_dim(2);
+  dimension *d1=create_dim(1);
+#if VALGRIND_
+  d0->shape[0]=4;
+  d0->shape[1]=2; //3;
+
+  d1->shape[0]=2;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+
+  d1->shape[0]=52;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,1);
+
+  print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+
+TEST(tensorContractnProd_TYPE_DOUBLE_2_1 ){
+  dimension *d0=create_dim(2);
+  dimension *d1=create_dim(1);
+#if VALGRIND_
+  d0->shape[0]=4;
+  d0->shape[1]=2; //3;
+
+  d1->shape[0]=2;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+
+  d1->shape[0]=52;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,1);
+
+  print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+TEST(tensorContractnProd_TYPE_DOUBLE_2_2 ){
+  dimension *d0=create_dim(2);
+  dimension *d1=create_dim(2);
+#if VALGRIND_
+  d0->shape[0]=4;
+  d0->shape[1]=2; //3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=1;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+
+  d1->shape[0]=52;
+  d1->shape[1]=1;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdNotOpt_TYPE_DOUBLE(&MnO, M0,M1,1);
+
+  print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+
+TEST(tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+  d0->shape[2]=63;
+
+  d1->shape[0]=52;
+  d1->shape[1]=63;//3;
+  d1->shape[2]=54;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  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->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+TEST(VStensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+  d0->shape[2]=63;
+
+  d1->shape[0]=52;
+  d1->shape[1]=63;//3;
+  d1->shape[2]=154;
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+TEST(Pthread_tensorContractnPro2d_TYPE_DOUBLE2 ){
+ 
+  littleEndian = false; 
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+  d0->shape[2]=63;
+
+  d1->shape[0]=52;
+  d1->shape[1]=63;//3;
+  d1->shape[2]=154;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  size_t nbthread = 5;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnPro2dThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbthread);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+  littleEndian=true;
+}
+TEST(contract_dim1){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(1);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=3;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+  d0->shape[2]=63;
+
+  d1->shape[0]=63;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  size_t nbthread = 5;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,1);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,1);
+  tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,1,nbthread);
+
+  print_tensor_double(MnO,"MnO");
+
+printDebug_dimension(M0->dim," M0 dimension  ");
+printDebug_dimension(M1->dim," M1 dimension  ");
+printDebug_dimension(M->dim," M dimension  ");
+
+
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+TEST(Pthread_tensorContractnProd_TYPE_DOUBLE2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=5;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3;//3;
+  d1->shape[2]=8;
+
+#else
+
+  d0->shape[0]=125;
+  d0->shape[1]=52; //3;
+  d0->shape[2]=63;
+
+  d1->shape[0]=52;
+  d1->shape[1]=63;//3;
+  d1->shape[2]=154;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+  //print_tensor_double(M0,"M0");
+  //print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+  tensor_TYPE_DOUBLE *MnO=NULL;
+
+  size_t nbthread = 5;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+  //print_tensor_double(M,"M");
+  //cl_tensorContractnProd_TYPE_DOUBLE(&MnO, M0,M1,2);
+  tensorContractnProdThread_TYPE_DOUBLE(&MnO, M0,M1,2,nbthread);
+
+  //print_tensor_double(MnO,"MnO");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+  EXPECT_ARRAY_EQ_TYPE_DOUBLE(M->x,M->dim->size,MnO->x,MnO->dim->size);
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(MnO);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+TEST(tensorProd_vs ){
+  
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+
+
+#if VALGRIND_
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=2;
+  
+  d1->shape[0]=2;
+  d1->shape[1]=3;
+
+#else
+
+  d0->shape[0]=212;
+  d0->shape[1]=13;
+  d0->shape[2]=22;
+  
+  d1->shape[0]=121;
+  d1->shape[1]=43;
+#endif
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+
+  tensorProd_TYPE_FLOAT(&M,M0,M1);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
+  LOG("M->dim->size = %ld\n",M->dim->size);
+
+
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+}
+TEST(tensorProd_vsThread ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+
+#if VALGRIND_
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=2;
+  
+  d1->shape[0]=2;
+  d1->shape[1]=3;
+
+#else
+
+  d0->shape[0]=212;
+  d0->shape[1]=13;
+  d0->shape[2]=22;
+  
+  d1->shape[0]=121;
+  d1->shape[1]=43;
+#endif
+
+
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+
+  size_t nbthread = 5;
+
+  tensorProdThread_TYPE_FLOAT(&M,M0,M1,nbthread);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
+  LOG("M->dim->size = %ld\n",M->dim->size);
+
+  //EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+}
+
+TEST(tensorProd_vsThread2d ){
+  //littleEndian =true;
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(2);
+
+#if VALGRIND_
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=2;
+  
+  d1->shape[0]=2;
+  d1->shape[1]=3;
+
+#else
+
+  d0->shape[0]=212;
+  d0->shape[1]=13;
+  d0->shape[2]=22;
+  
+  d1->shape[0]=121;
+  d1->shape[1]=43;
+#endif
+
+
+
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_TYPE_FLOAT(d1);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+  LOG("M1->dim->size = %ld\n",M1->dim->size);
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=i*0.01 +1;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+
+
+  tensor_TYPE_FLOAT *M=NULL; 
+  tensor_TYPE_FLOAT *Mn=NULL; 
+
+  size_t nbthread = 5;
+
+  tensorProdThrea2d_TYPE_FLOAT(&M,M0,M1,nbthread);
+  //tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
+  tensorProd_TYPE_FLOAT(&Mn,M0,M1);
+  LOG("M->dim->size = %ld\n",M->dim->size);
+  LOG("Mn->dim->size = %ld\n",Mn->dim->size);
+
+
+  EXPECT_ARRAY_EQ_TYPE_FLOAT(M->x,M->dim->size,Mn->x,Mn->dim->size);
+
+  free_tensor_TYPE_FLOAT(M);
+  free_tensor_TYPE_FLOAT(Mn);
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+}
+
+TEST(parseInput_withDim_to_tensor){
+  littleEndian=true;
+  char *input="[2,3]"\
+               "((1.21,10,0.23)"\
+               "(.56,124,22.5)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+  free_tensor_TYPE_FLOAT(t);
+}
+
+TEST(parseInput_unknownpart_to_tensor){
+  //littleEndian=true;
+  littleEndian=true;
+  char *input="[*,3]"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "(.56,124,22.5)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+  free_tensor_TYPE_FLOAT(t);
+}
+
+TEST(parseInput_unknownpart_to_tensorendfalse){
+  littleEndian=false;
+  char *input="[3,_]"\
+               "((1.21,10,0.23,21)"\
+               "((1.21,10,0.23,.1)"\
+               "(.56,124,22.5,1.44))";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+  free_tensor_TYPE_FLOAT(t);
+}
+
+TEST(transpose_parseInput_unknownpart_to_tensor){
+  littleEndian=true;
+  char *input="[*,3]"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "(.56,124,22.5)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+}
+TEST(transpose_input_to_OpT_Ranspose){
+  littleEndian=true;
+  char *input="[*,3]"\
+               "((1.1,1.2,1.3)"\
+               "((2.1,2.2,2.3)"\
+               "((3.1,3.2,3.3)"\
+               "((4.1,4.2,4.3)"\
+               "((5.1,5.2,5.3)"\
+               "((6.1,6.2,6.3)"\
+               "(7.1,7.2,7.3)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->size ,transpose_Opt0->x,transpose_Opt0->dim->size);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
+
+TEST(transpose_input_to_OpT_Ranspose2){
+  littleEndian=true;
+  char *input="[*,4,3]"\
+               "(((1.11,1.12,1.13),(1.21,1.22,1.23),(1.31,1.32,1.33),(1.41,1.42,1.43)),"\
+               "((2.11,2.12,2.13),(2.21,2.22,2.23),(2.31,2.32,2.33),(2.41,2.42,2.43)),"\
+               "((3.11,3.12,3.13),(3.21,3.22,3.23),(3.31,3.32,3.33),(3.41,3.42,3.43)),"\
+               "((4.11,4.12,4.13),(4.21,4.22,4.23),(4.31,4.32,4.33),(4.41,4.42,4.43)),"\
+               "((5.11,5.12,5.13),(5.21,5.22,5.23),(5.31,5.32,5.33),(5.41,5.42,5.43)),"\
+               "((6.11,6.12,6.13),(6.21,6.22,6.23),(6.31,6.32,6.33),(6.41,6.42,6.43)),"\
+               "((7.11,7.12,7.13),(7.21,7.22,7.23),(7.31,7.32,7.33),(7.41,7.42,7.43)),"\
+               "((8.11,8.12,8.13),(8.21,8.22,8.23),(8.31,8.32,8.33),(8.41,8.42,8.43)),"\
+               "((9.11,9.12,9.13),(9.21,9.22,9.23),(9.31,9.32,9.33),(9.41,9.42,9.43)),"\
+               "((10.11,10.12,10.13),(10.21,10.22,10.23),(10.31,10.32,10.33),(10.41,10.42,10.43)),"\
+               "((11.11,11.12,11.13),(11.21,11.22,11.23),(11.31,11.32,11.33),(11.41,11.42,11.43)),"\
+               "((12.11,12.12,12.13),(12.21,12.22,12.23),(12.31,12.32,12.33),(12.41,12.42,12.43)),"\
+               "((13.11,13.12,13.13),(13.21,13.22,13.23),(13.31,13.32,13.33),(13.41,13.42,13.43)))";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+
+  tensor_TYPE_FLOAT *transpose = transpose_notOpt_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose," transpose from input" );
+  tensor_TYPE_FLOAT *transpose_Opt0 = transpose_Opt0_tensor_TYPE_FLOAT(t);
+  print_tensor_msg_TYPE_FLOAT(transpose_Opt0," transpose_Opt0 from input" );
+
+	EXPECT_ARRAY_EQ_TYPE_FLOAT(transpose->x,transpose->dim->size ,transpose_Opt0->x,transpose_Opt0->dim->size);
+
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+  free_tensor_TYPE_FLOAT(transpose_Opt0);
+}
+TEST(shapeute_parseInput_unknownpart_to_tensor){
+  littleEndian=true;
+  char *input="[*,3]"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "((1.21,10,0.23)"\
+               "(.56,124,22.5)) ";
+
+  tensor_TYPE_FLOAT *t=parseInput_withDim_to_tensor_TYPE_FLOAT(input);
+
+  print_tensor_msg_TYPE_FLOAT(t," tensor from input" );
+
+  dimension *dshape=create_reverse_dim((t->dim)->rank);
+  tensor_TYPE_FLOAT *transpose = permute_notOpt_tensor_TYPE_FLOAT(t, dshape);
+  print_tensor_msg_TYPE_FLOAT(transpose," shapeute from input" );
+
+  free_dimension(dshape);
+  free_tensor_TYPE_FLOAT(t);
+  free_tensor_TYPE_FLOAT(transpose);
+}
+TEST(parseInputOutput_unknownpart_to_tensor){
+  littleEndian=true;
+  char *input="[*,3,2]"\
+               "((0,0,0),(1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "(0,0,0,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+TEST(parseInputOutput_knownpart_to_tensor){
+  littleEndian=true;
+  char *input="[6,3,2]"\
+               "((0,0,0),(1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "((0,0,0,1,2)"\
+               "(0,0,0,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+TEST(parseInputOutput_unknownpart2dimInput_to_tensor){
+  littleEndian=true;
+  char *input="[*,2,3,2]"\
+               "((0,0,0)(8,8,8),(1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "(0,0,0),(8,8,8),2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+TEST(parseInputOutput_knownpart2dimInput_to_tensor){
+  littleEndian=true;
+  char *input="[6,2,3,2]"\
+               "((0,0,0)(8,8,8),(1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "((0,0,0),(8,8,8),1,2)"\
+               "(0,0,0),(8,8,8),2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+TEST(parseInputOutput_unknownpart1dimInput_2output_to_tensor){
+  littleEndian=true;
+  char *input="[*,3,3,2]"\
+               "((0,0,0)(8,8)(8,8),(1,2)"\
+               "((0,0,0),(8,8)(8,8),1,2)"\
+               "((0,0,0),(8,8,(8,8),1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "(0,0,0),(8,8,8)8,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+TEST(parseInputOutput_knownpart1dimInput_2output_to_tensor){
+  littleEndian=true;
+  char *input="[6,3,3,2]"\
+               "((0,0,0)(8,8)(8,8),(1,2)"\
+               "((0,0,0),(8,8)(8,8),1,2)"\
+               "((0,0,0),(8,8,(8,8),1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "(0,0,0),(8,8,8)8,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 2);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+TEST(parseInputOutput_unknownpart1dimInput_1output_to_tensor){
+  littleEndian=true;
+  char *input="[*,8,1]"\
+               "((0,0,0)(8,8)(8,8),(1,2)"\
+               "((0,0,0),(8,8)(8,8),1,2)"\
+               "((0,0,0),(8,8,(8,8),1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "((0,0,0),(8,8,8)8,1,2)"\
+               "(0,0,0),(8,8,8)8,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+TEST(parseInputOutput_knownpart1dimInput_1output_to_tensor){
+  littleEndian=true;
+  char *input="[6,8,1]"\
+               "((0,0,0)(8,8)(8,8),(1,2)"\
+               "((0,0,0),(8,8)(8,8),1,2)"\
+               "((0,0,0),(8,8,(8,8),1,2)"\
+               "((0,0,0),(8,8,8)8,1,7)"\
+               "((0,0,0),(8,8,8)8,1,5)"\
+               "(0,0,0),(8,8,8)8,2,4)) ";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parseInputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , input, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from input" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from input" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
+  littleEndian=true;
+  char *inputfile="input.txt";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from inputfile" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+
+TEST(parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
+  littleEndian=true;
+  char *inputfile="unkinput.txt";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from inputfile" );
+
+
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+
+
+TEST(array_from_parseInputOutput_file_knownpart1dimInput_1output_to_tensor){
+  littleEndian=true;
+  char *inputfile="unkinput.txt";
+
+  tensor_TYPE_FLOAT *t0=NULL,*t1=NULL;
+  parse_file_InputOutput_withDim_to_tensors_TYPE_FLOAT(&t0,&t1 , inputfile, 1);
+
+  print_tensor_msg_TYPE_FLOAT(t0," t0 from inputfile" );
+  print_tensor_msg_TYPE_FLOAT(t1," t1 from inputfile" );
+
+  tensor_TYPE_FLOAT **arrt0 =  fromInput_to_array_tensor_TYPE_FLOAT(t0);
+  tensor_TYPE_FLOAT **arrt1 =  fromInput_to_array_tensor_TYPE_FLOAT(t1);
+
+
+  size_t sz0=(t0->dim)->shape[0];
+  size_t sz1=(t1->dim)->shape[0];
+  char msg[256];
+
+  for(size_t i=0; i< sz0; ++i){
+    sprintf(msg," array t0 [%ld ] ",i);
+    print_tensor_msg_TYPE_FLOAT(arrt0[i],msg);
+  }
+  for(size_t i=0; i< sz1; ++i){
+    sprintf(msg," array t1 [%ld ] ",i);
+    print_tensor_msg_TYPE_FLOAT(arrt1[i],msg);
+  }
+
+  for(size_t i=0; i< sz0; ++i) free_tensor_TYPE_FLOAT(arrt0[i]);
+  for(size_t i=0; i< sz1; ++i) free_tensor_TYPE_FLOAT(arrt1[i]);
+  
+  free(arrt0);
+  free(arrt1);
+
+  free_tensor_TYPE_FLOAT(t0);
+  free_tensor_TYPE_FLOAT(t1);
+}
+
+float func2(float x){
+  return x*x+1;
+}
+
+TEST(print_tensor){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "init M0 random");
+  
+  update_1tensor_func_TYPE_FLOAT(M0, func2, 5); 
+
+  print_tensor_float(M0, "x*x+1 M0 random");
+  free_tensor_TYPE_FLOAT(M0);
+}
+
+TEST(rec_in_file_tensor){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+
+  print_tensor_float(M0, "init M0 random");
+  
+  update_1tensor_func_TYPE_FLOAT(M0, func2, 5); 
+
+  fprint_tensor_TYPE_FLOAT(".ffrec_randomTens.txt",M0);
+  free_tensor_TYPE_FLOAT(M0);
+}
+
+TEST(copy_tensor){
+  dimension *d0=create_dim(3);
+
+  d0->shape[0]=2;
+  d0->shape[1]=3;
+  d0->shape[2]=4;
+
+
+  updateDim(d0);
+
+
+  tensor_TYPE_FLOAT *M0 = create_tensor_TYPE_FLOAT(d0);
+  tensor_TYPE_FLOAT *M1 = create_tensor_from_cpy_dim_TYPE_FLOAT(d0);
+
+  LOG("M0->dim->size = %ld\n",M0->dim->size);
+
+  init_random_x_TYPE_FLOAT(M0,2.7,5.4,50001);
+  init_random_x_TYPE_FLOAT(M1,2.7,5.4,50001);
+
+  print_tensor_float(M0, "init M0 random");
+
+  copy_tensor_TYPE_FLOAT(M1, M0);
+  print_tensor_float(M1, "M1 copy of M0");
+  
+  free_tensor_TYPE_FLOAT(M0);
+  free_tensor_TYPE_FLOAT(M1);
+}
+
+
+TEST(tensorContractnProd_TYPE_DOUBLE_2_2 ){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+#if VALGRIND_
+  d0->shape[0]=1;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3; //3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3; //3;
+  d1->shape[2]=1; //3;
+
+#else
+
+  d0->shape[0]=1;
+  d0->shape[1]=22; //3;
+  d0->shape[2]=52; //3;
+  d1->shape[0]=52;
+  d1->shape[1]=22; //3;
+  d1->shape[2]=1; //3;
+
+#endif
+
+  updateDim(d0);
+  updateDim(d1);
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  for(size_t i=0; i<M0->dim->size;++i) M0->x[i]=2 ;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=3;
+
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+
+  print_tensor_double(M,"M");
+ 
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+
+}
+
+
+
+TEST(scalProduct){
+  dimension *d0=create_dim(3);
+  dimension *d1=create_dim(3);
+
+  
+  dimension *d_0=create_dim(2);
+  dimension *d_1=create_dim(2);
+
+
+  d0->shape[0]=1;
+  d0->shape[1]=2; //3;
+  d0->shape[2]=3; //3;
+
+  d1->shape[0]=2;
+  d1->shape[1]=3; //3;
+  d1->shape[2]=1; //3;
+
+
+  d_0->shape[0]=2;
+  d_0->shape[1]=3; //3;
+  d_1->shape[0]=2;
+  d_1->shape[1]=3; //3;
+
+
+
+
+  tensor_TYPE_DOUBLE *M0 = create_tensor_TYPE_DOUBLE(d0);
+  tensor_TYPE_DOUBLE *M1 = create_tensor_TYPE_DOUBLE(d1);
+
+  tensor_TYPE_DOUBLE *M_0 = create_tensor_TYPE_DOUBLE(d_0);
+  tensor_TYPE_DOUBLE *M_1 = create_tensor_TYPE_DOUBLE(d_1);
+  
+  for(size_t i=0; i<M0->dim->size;++i) {
+    M0->x[i]=2 ;
+    M_0->x[i]=2 ;
+  }
+  for(size_t i=0; i<M1->dim->size;++i) {
+    M1->x[i]=3;
+    M_1->x[i]=3;
+  }
+  print_tensor_double(M0,"M0");
+  print_tensor_double(M1,"M1");
+
+  tensor_TYPE_DOUBLE *M=NULL;
+
+  tensorContractnProd_TYPE_DOUBLE(&M, M0,M1,2);
+
+  print_tensor_double(M,"M");
+ 
+  double dotProd = scalarProduct_0_TYPE_DOUBLE(M_0,M_1);
+
+  EXPECT_EQ_TYPE_DOUBLE(dotProd, M->x[0]);
+
+  // for(size_t i=0;i<M->dim->size;++i)
+  //    EXPECT_EQ_TYPE_DOUBLE(M->x[i],MnO->x[i]);
+    
+
+  free_tensor_TYPE_DOUBLE(M);
+  free_tensor_TYPE_DOUBLE(M0);
+  free_tensor_TYPE_DOUBLE(M1);
+  free_tensor_TYPE_DOUBLE(M_0);
+  free_tensor_TYPE_DOUBLE(M_1);
+
+}
+
+
+
+
+
+int main(int argc, char **argv){
+  
+
+  run_all_tests_args(argc, argv);
+
+  return 0;
+}
diff --git a/onetensor/unkinput.txt b/onetensor/unkinput.txt
new file mode 100644
index 0000000..3cdcde0
--- /dev/null
+++ b/onetensor/unkinput.txt
@@ -0,0 +1,15 @@
+[*,7,2]
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(5,9),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(5,9),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(8,8),(1,2)
+((0,0,0)(8,8)(5,9),(1,2)