[debug] try to debug littleEndian false on tensor contracted product

onetensor/tesTensor.c

@@ -560,7 +560,7 @@ TEST(tensorProdNoOpt){
   print_tensor_float(M1,"M1");
 
 
-  tensor_TYPE_FLOAT *M=NULL; 
+  //tensor_TYPE_FLOAT *M=NULL; 
   tensor_TYPE_FLOAT *Mn=NULL; 
   
   tensorProdNotOpt_TYPE_FLOAT(&Mn,M0,M1);
@@ -719,7 +719,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt ){
   print_tensor_float(M0,"M0");
   print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M=NULL;
+  //tensor_TYPE_FLOAT *M=NULL;
   tensor_TYPE_FLOAT *MnO=NULL;
 
   //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
@@ -843,7 +843,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt2 ){
   print_tensor_float(M0,"M0");
   print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M=NULL;
+  //tensor_TYPE_FLOAT *M=NULL;
   tensor_TYPE_FLOAT *MnO=NULL;
 
   //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
@@ -924,8 +924,8 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
   dimension *d1=create_dim(3);
 #if VALGRIND_
   d0->shape[0]=5;
-  d0->shape[1]=2; //3;
+  d0->shape[1]=3; //3;
-  d0->shape[2]=3;
+  d0->shape[2]=2;
 
   d1->shape[0]=3;
   d1->shape[1]=2;//3;
@@ -953,16 +953,16 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
 
   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<M0->dim->size;++i) M0->x[i]=i*2.1 +1;
-  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
+  for(size_t i=0; i<M1->dim->size;++i) M1->x[i]=i*1.3 + 2;
 
   print_tensor_float(M0,"M0");
   print_tensor_float(M1,"M1");
 
-  tensor_TYPE_FLOAT *M=NULL;
+  //tensor_TYPE_FLOAT *M=NULL;
   tensor_TYPE_FLOAT *MnO=NULL;
-
+  //PRECISION_TYPE_FLOAT  = 100000;
-  //tensorContractnProd_TYPE_FLOAT(&M, M0,M1,2);
+  //tensorContractnProd_TYPE_FLOAT(&MnO, M0,M1,2);
   tensorContractnProdNotOpt_TYPE_FLOAT(&MnO, M0,M1,2);
 
   float MMM0[d0->shape[0]][d0->shape[1]][d0->shape[2]];
@@ -971,8 +971,10 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
   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)];
+    size_t z=signedLineFromCoord(coord3, d0);
-    //printf("M0[%ld][%ld][%ld] = %f \n",i0,i1,i2,MMM0[i0][i1][i2]);
+    MMM0[i0][i1][i2]=M0->x[z];
+    //MMM0[i0][i1][i2]=M0->x[signedLineFromCoord(coord3, d0)];
+    printf("[[%ld]] M0[%ld][%ld][%ld] = %f \n",z,i0,i1,i2,MMM0[i0][i1][i2]);
   }
   }
   }
@@ -983,7 +985,10 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
   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)];
+    size_t z =signedLineFromCoord(coord23, d1);
+    MMM1[j0][j1][j2]=M1->x[z];
+    //MMM1[j0][j1][j2]=M1->x[signedLineFromCoord(coord23, d1)];
+    printf("[[%ld]] M1[%ld][%ld][%ld] = %f \n",z,j0,j1,j2,MMM1[j0][j1][j2]);
   }
   }
   }
@@ -995,7 +1000,7 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
     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]);
+    printf("[%ld] [%ld][%ld] [%ld] MMMm<> = %f \n",i0,i1,i2,j2,MMMm[i0][j2]);
       }
     }
   }
@@ -1009,12 +1014,16 @@ TEST(tensorContractnProd_TYPE_FLOATNoOpt3littleEndianFalse ){
   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)] );
+    size_t z = signedLineFromCoord(coord52, MnO->dim);
+    EXPECT_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[z] );
+    //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){
+   //if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[signedLineFromCoord(coord52, MnO->dim)] ) == false)
+   if(expected_EQ_TYPE_FLOAT(MMMm[i0][j2], MnO->x[z] ) == false){
       LOG("[ %ld, %ld] [%ld]\n",i0,j2,
-      signedLineFromCoord(coord52, MnO->dim)
+      z //signedLineFromCoord(coord52, MnO->dim)
       );
+      printDebug_dimension(MnO->dim,"MnO");
 
    }
   }
@@ -1224,6 +1233,9 @@ TEST(tensorContractnProdOpt0_TYPE_FLOAT2 ){
 
 
 TEST(tensorContractnProdThreadOpt0_TYPE_FLOAT2 ){
+  //littleEndian=false;
+  //long int old_PRECISION_TYPE_FLOAT=PRECISION_TYPE_FLOAT;
+  //PRECISION_TYPE_FLOAT=1;
   dimension *d0=create_dim(3);
   dimension *d1=create_dim(3);
 #if VALGRIND_
@@ -1282,6 +1294,8 @@ TEST(tensorContractnProdThreadOpt0_TYPE_FLOAT2 ){
   free_tensor_TYPE_FLOAT(M0);
   free_tensor_TYPE_FLOAT(M1);
   
+  //PRECISION_TYPE_FLOAT = old_PRECISION_TYPE_FLOAT ;
+  //littleEndian=true;
 }
 
 TEST(tensorContractnPro2dThreadOpt0_TYPE_FLOAT2 ){

onetensor/y_tensor_h.h

@@ -145,6 +145,92 @@ long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_s
 
 #endif /*__TOOLS_T_C_H__*/
 
+/* implementations */
+
+/*  IMPLEMENTATION_TOOLS */
+
+
+#define POW 17
+#define MMOD ((1 << (POW)) - 1)
+#define SUBA 5
+#define SUBB 8
+
+
+#define GEN_TO_STR_N(type,size,format)  \
+  TYPE_STRING type##_TO_STR(type var){  \
+    char *ret = malloc(size);                     \
+    /*int szret = */sprintf(ret,format,var);            \
+    /*ret[szret]='\0'*//*no need , already by default */;              \
+    return ret;                         \
+  }\
+
+
+#define GENERATE_FUNCTION_ALL(type)\
+  type MAX_ARRAY_##type(const type *array, size_t size){\
+    if(array == NULL) return 0;\
+    type mx =(type)array[0];\
+    for(size_t i = 0; i < size; ++i)\
+      if(COMPARE_N_##type(&mx,&array[i]) < 0) mx =(type)array[i];\
+    return mx;}\
+\
+  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size){\
+    if(array == NULL) return 0;\
+    size_t i_mx = 0;\
+    for(size_t i = 0; i < size; ++i)\
+      if(COMPARE_N_##type(&array[i_mx],&array[i]) < 0) i_mx = i;\
+    return i_mx;}\
+\
+  type MIN_ARRAY_##type(const type *array, size_t size){\
+    if(array == NULL) return 0;\
+    type mn =(type)array[0];\
+    for(size_t i = 0; i < size; ++i)\
+      if(COMPARE_N_##type(&mn,&array[i]) > 0) mn =(type)array[i];\
+    return mn;}\
+\
+  size_t ARG_MIN_ARRAY_##type(const type *array, size_t size){\
+    if(array == NULL) return 0;\
+    size_t i_mn = 0;\
+    for(size_t i = 0; i < size; ++i)\
+      if(COMPARE_N_##type(&array[i_mn],&array[i]) > 0) i_mn = i;\
+    return i_mn;}\
+\
+
+
+
+
+#define GENERATE_FUNCTION_NUMERIC(type)\
+  int COMPARE_N_##type(const void *a, const  void *b){              \
+    type diff = 0;\
+     if((*(type*)a > *(type*)b)){           \
+      diff =(*(type*)a - *(type*)b) * PRECISION_##type;           \
+    /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\
+    PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\
+    free(str_diff); free(str_a); free(str_b);\
+     */ \
+      if(diff >= 1) return 1;\
+      return 0;\
+     }else{\
+      diff =(*(type*)b - *(type*)a) * PRECISION_##type;           \
+    /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\
+    PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\
+    free(str_diff); free(str_a); free(str_b);\
+    */\
+      if(diff >= 1) return -1;\
+      return 0;\
+     }\
+    \
+    /*if (diff <= -1) return -1;                                                    \
+    if (diff >= 1) return 1;                                                    \
+    return 0;                                                    \
+  */\
+  }                                                                 \
+                                                                    \
+  void COPY_ARRAY_##type(type *dst, const type *src, size_t size){  \
+    for(size_t i = 0; i < size; ++i) dst[i]=src[i];                 \
+  }                                                                 \
+\
+
+
 
 
 #ifndef IMPLEMENTATION_TOOLS
@@ -175,7 +261,8 @@ long int PRECISION_TYPE_U_L_INT  = 1;\
 long int PRECISION_TYPE_SIZE_T  = 1;\
 \
 long int PRECISION_TYPE_FLOAT  = 100000000;\
-long int PRECISION_TYPE_DOUBLE  = 100000000000;\
+/*long int PRECISION_TYPE_FLOAT  = 100000;\
+*/long int PRECISION_TYPE_DOUBLE  = 100000000000;\
 long int PRECISION_TYPE_L_DOUBLE  = 100000000000000;\
 \
 \