fanasina/onefileheader_tensor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
onefileheader_tensor/onetensor/tesTensor.c
T

2817 lines
68 KiB
C
Raw Permalink Blame History

#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 "../link_repo_ytest/y_test_h.h"
IMPLEMENTATION_FTEST()
#include "y_tensor_h.h"
//#include "shapeutation_t/shapeutation_t.h"
//#include "tensor_t/tensor_t.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(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
//littleEndian=false;
long 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(long i1=0; i1<d0->shape[1];++i1){
for(long i0=0; i0<d0->shape[0];++i0){
printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((long[]){i0,i1,rnkId},M0->dim),rnkId,i0,i1,LineFromCoord((long[]){i0,i1},s2h->dim),i0,i1);
EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((long[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((long[]){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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
//littleEndian=false;
long 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(long i1=0; i1<d0->shape[1];++i1){
for(long i2=0; i2<d0->shape[2];++i2){
printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((long[]){rnkId,i1,i2},M0->dim),rnkId,i1,i2,LineFromCoord((long[]){i1,i2},s2t->dim),i1,i2);
EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((long[]){rnkId,i1,i2},M0->dim)],s2t->x[LineFromCoord((long[]){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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
//littleEndian=false;
long 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(long i1=0; i1<d0->shape[1];++i1){
for(long i0=0; i0<d0->shape[0];++i0){
printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((long[]){i0,i1,rnkId},M0->dim),rnkId,i0,i1,LineFromCoord((long[]){i0,i1},s2h->dim),i0,i1);
EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((long[]){i0,i1,rnkId},M0->dim)],s2h->x[LineFromCoord((long[]){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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
//littleEndian=false;
long 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(long i1=0; i1<d0->shape[1];++i1){
for(long i2=0; i2<d0->shape[2];++i2){
printf("EXPECT_EQ_TYPE_FLOAT c0[%ld](%ld,%ld,%ld) : s[%ld](%ld,%ld) \n",LineFromCoord((long[]){rnkId,i1,i2},M0->dim),rnkId,i1,i2,LineFromCoord((long[]){i1,i2},s2t->dim),i1,i2);
EXPECT_EQ_TYPE_FLOAT(M0->x[LineFromCoord((long[]){rnkId,i1,i2},M0->dim)],s2t->x[LineFromCoord((long[]){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(long 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(long 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;
long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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]=3; //3;
d0->shape[2]=2;
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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*2.1 +1;
for(long 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 *MnO=NULL;
//PRECISION_TYPE_FLOAT = 100000;
//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]];
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;
long z=signedLineFromCoord(coord3, d0);
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]);
}
}
}
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;
long 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]);
}
}
}
//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("[%ld] [%ld][%ld] [%ld] MMMm<> = %f \n",i0,i1,i2,j2,MMMm[i0][j2]);
}
}
}
}
//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;
long 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[z] ) == false){
LOG("[ %ld, %ld] [%ld]\n",i0,j2,
z //signedLineFromCoord(coord52, MnO->dim)
);
printDebug_dimension(MnO->dim,"MnO");
}
}
}
//print_tensor_float(M,"M");
print_tensor_float(MnO,"MnO");
// for(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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 ){
//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_
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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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);
//PRECISION_TYPE_FLOAT = old_PRECISION_TYPE_FLOAT ;
//littleEndian=true;
}
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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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;
long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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;
long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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;
long 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(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.1 +1;
for(long i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=i*0.01 +1;
for(long i=0; i<M1->dim->size;++i) M1->x[i]=i*0.003 + 2;
tensor_TYPE_FLOAT *M=NULL;
tensor_TYPE_FLOAT *Mn=NULL;
long 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_OpT0_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_OpT0_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(transpose_input_to_OpT1_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_Opt1_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_OpT1_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_Opt1_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);
long sz0=(t0->dim)->shape[0];
long sz1=(t1->dim)->shape[0];
char msg[256];
for(long i=0; i< sz0; ++i){
sprintf(msg," array t0 [%ld ] ",i);
print_tensor_msg_TYPE_FLOAT(arrt0[i],msg);
}
for(long i=0; i< sz1; ++i){
sprintf(msg," array t1 [%ld ] ",i);
print_tensor_msg_TYPE_FLOAT(arrt1[i],msg);
}
for(long i=0; i< sz0; ++i) free_tensor_TYPE_FLOAT(arrt0[i]);
for(long 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(long i=0; i<M0->dim->size;++i) M0->x[i]=2 ;
for(long 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(long 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(long i=0; i<M0->dim->size;++i) {
M0->x[i]=2 ;
M_0->x[i]=2 ;
}
for(long 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(long 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;
}
Reference in New Issue View Git Blame Copy Permalink