Fix unittest by change double to float.

test/Function1D_Test.cpp

@@ -264,10 +264,11 @@ TEST_F(Function1D_Test, exp) {
     float *data1 = new float[4]{1,2,3,4};
     auto matrix1 = Aurora::Matrix::fromRawData(data1, 4,1,1);
     auto result = Aurora::exp(matrix1);
+
     EXPECT_FLOAT_AE(result.getData()[0],2.7183);
     EXPECT_FLOAT_AE(result.getData()[1],7.3891);
     EXPECT_FLOAT_AE(result.getData()[2],20.0855);
-    EXPECT_FLOAT_AE(result.getData()[3],54.5982);
+    EXPECT_FLOAT_AE(result.getData()[3],54.5981483);
 
     float *data2 = new float[4]{1,2,3,4};
     auto matrix2 = Aurora::Matrix::fromRawData(data2, 2,1,1,Aurora::Complex);
@@ -430,17 +431,11 @@ TEST_F(Function1D_Test, horzcat) {
     EXPECT_FLOAT_EQ(result.getDimSize(0),3);
     EXPECT_FLOAT_EQ(result.getDimSize(1),2);
 
-    auto A = Aurora::Matrix::New(Aurora::random(27),3,3,3);
+    auto A = Aurora::Matrix::fromRawData(Aurora::random(27),3,3,3);
-    auto B = Aurora::Matrix::New(Aurora::random(18),3,2,3);
+    auto B = Aurora::Matrix::fromRawData(Aurora::random(18),3,2,3);
     auto C = Aurora::horzcat(A, B);
-    A.printf();
+    B = Aurora::Matrix::fromRawData(Aurora::random(18),2,3,3);
-    B.printf();
-    C.printf();
-    B = Aurora::Matrix::New(Aurora::random(18),2,3,3);
     C = Aurora::vertcat(A, B);
-    A.printf();
-    B.printf();
-    C.printf();
 }
 
 TEST_F(Function1D_Test, vertcat) {

test/Function2D_Test.cpp

@@ -286,7 +286,7 @@ TEST_F(Function2D_Test, sort) {
     EXPECT_FLOAT_EQ(-38.5, ret.getData()[12]);
     //big sort 10w以上多线程快
     float * dataA = Aurora::random(1000000*4);
-    auto A = Aurora::Matrix::New(dataA, 1000000, 4);
+    auto A = Aurora::Matrix::fromRawData(dataA, 1000000, 4);
     ret = Aurora::sort(A);
 }
 
@@ -302,8 +302,6 @@ TEST_F(Function2D_Test, sortrows) {
     auto B = transpose(Aurora::Matrix::fromRawData(dataB, 7, 6));
     Aurora::Matrix idx ;
     auto ret = Aurora::sortrows(B,&idx);
-    ret.printf();
-    idx.printf();
 }
 
 TEST_F(Function2D_Test, median) {

test/Matrix_Test.cpp

@@ -38,7 +38,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(3, A.getDimSize(0));
         EXPECT_EQ(3, A.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, A.getValueType());
-        DISPLAY_MATRIX(A);
     }
 // float [] matrix
     {
@@ -49,7 +48,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(3, B.getDimSize(0));
         EXPECT_EQ(3, B.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, B.getValueType());
-        DISPLAY_MATRIX(B);
     }
 // copy from float [] to mkl matrix
     {
@@ -60,7 +58,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(3, C.getDimSize(0));
         EXPECT_EQ(3, C.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 // 2vector
     {
@@ -71,7 +68,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(9, C.getDimSize(0));
         EXPECT_EQ(1, C.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 // 2d vector
     {
@@ -82,7 +78,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(9, C.getDimSize(0));
         EXPECT_EQ(1, C.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 // 2d vector column major
     {
@@ -94,20 +89,18 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(1, C.getDimSize(0));
         EXPECT_EQ(9, C.getDimSize(1));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 // 3d matrix
     {
         float *tempData = new float[9];
         Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3, 1);
-        EXPECT_EQ(dataD, C.getData());
+        EXPECT_EQ(tempData, C.getData());
         EXPECT_EQ(9, C.getDataSize());
         EXPECT_EQ(2, C.getDims());
         EXPECT_EQ(3, C.getDimSize(0));
         EXPECT_EQ(3, C.getDimSize(1));
         EXPECT_EQ(1, C.getDimSize(2));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 // 3d matrix 2
     {
@@ -120,7 +113,6 @@ TEST_F(Matrix_Test, MatrixCreate) {
         EXPECT_EQ(1, C.getDimSize(1));
         EXPECT_EQ(3, C.getDimSize(2));
         EXPECT_EQ(Aurora::Normal, C.getValueType());
-        DISPLAY_MATRIX(C);
     }
 }
 
@@ -185,13 +177,9 @@ TEST_F(Matrix_Test, matrixOpertaor) {
             dataB[i] = (float) (2);
         }
         Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA, 2, 2, 2);
-        DISPLAY_MATRIX(A);
         Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 2, 2, 2);
-        DISPLAY_MATRIX(B);
         Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD, 4, 2);
-        DISPLAY_MATRIX(D);
         auto C = (A * B) - B;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 2);
         C = A * B / 2.0;
         EXPECT_EQ(C.getData()[2], 2);
@@ -212,86 +200,65 @@ TEST_F(Matrix_Test, matrixOpertaor) {
             if (i < 8) dataD[i] = (float) (2);
         }
         Aurora::Matrix A = Aurora::Matrix::New(dataA, 2, 2, 2, Aurora::Complex);
-        DISPLAY_MATRIX(A);
         Aurora::Matrix B = Aurora::Matrix::New(dataB, 2, 2, 2, Aurora::Complex);
-        DISPLAY_MATRIX(B);
         Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD, 2, 2, 2);
-        DISPLAY_MATRIX(D);
         auto C = A + 5.0 - 2.0;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 6);
         EXPECT_EQ(C.getData()[3], 4);
         EXPECT_TRUE(C.isComplex());
         C = A * B - B;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], -4);
         EXPECT_EQ(C.getData()[3], 12);
         EXPECT_TRUE(C.isComplex());
         C = A * B - 2.0 + 5.0;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 1);
         EXPECT_EQ(C.getData()[3], 14);
         C = A * B / 2.0 * 3.;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], -3);
         EXPECT_EQ(C.getData()[3], 21);
         C = A * B / B;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 3);
         EXPECT_EQ(C.getData()[3], 4);
         C = A * B / (B * A / A);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 3);
         EXPECT_EQ(C.getData()[3], 4);
 
         C = B * D;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 4);
         C = B / D;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 1);
         EXPECT_EQ(C.getData()[3], 1);
         C = B + D;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 2);
         C = B - D;
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 0);
         EXPECT_EQ(C.getData()[3], 2);
 
         C = B * (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 4);
         C = B / (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 1);
         EXPECT_EQ(C.getData()[3], 1);
         C = B + (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 2);
         C = B - (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 0);
         EXPECT_EQ(C.getData()[3], 2);
 
         C = (B * 1.0) * (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 4);
         C = (B * 1.0) / (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 1);
         EXPECT_EQ(C.getData()[3], 1);
         C = (B * 1.0) + (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 4);
         EXPECT_EQ(C.getData()[3], 2);
         C = (B * 1.0) - (D * 1.0);
-        DISPLAY_MATRIX(C);
         EXPECT_EQ(C.getData()[2], 0);
         EXPECT_EQ(C.getData()[3], 2);
 
@@ -401,7 +368,7 @@ TEST_F(Matrix_Test, matrixfunction){
     EXPECT_FLOAT_EQ(C.getData()[8], 460);
 
     float *dataE = Aurora::random(60);
-    Aurora::Matrix E = Aurora::Matrix::New(dataE, 3, 4, 5);
+    Aurora::Matrix E = Aurora::Matrix::fromRawData(dataE, 3, 4, 5);
     Aurora::Matrix block1 = E.block(0, 1, 2);
     for (size_t i = 0; i < block1.getDimSize(2); i++)
     {