diff --git a/src/Matrix.h b/src/Matrix.h
index c876949..d62e31e 100644
--- a/src/Matrix.h
+++ b/src/Matrix.h
@@ -53,7 +53,7 @@ namespace Aurora {
          * @param type
          * @return
          */
-        static Matrix fromRawData(double *data, int rows, int cols = 0, int slices = 0, ValueType type = Normal);
+        static Matrix fromRawData(double *data, int rows, int cols = 1, int slices = 1, ValueType type = Normal);
 
         /**
          * Create from a Raw data(double array) with copy the data to a new mkl memory.
@@ -64,7 +64,7 @@ namespace Aurora {
          * @param type
          * @return
          */
-        static Matrix copyFromRawData(double *data, int rows, int cols = 0, int slices = 0, ValueType type = Normal);
+        static Matrix copyFromRawData(double *data, int rows, int cols = 1, int slices = 1, ValueType type = Normal);
 
         /**
          * New a mkl calculate based Matrix
@@ -76,7 +76,7 @@ namespace Aurora {
          * @param type
          * @return
          */
-        static Matrix New(double *data, int rows, int cols = 0, int slices = 0, ValueType type = Normal);
+        static Matrix New(double *data, int rows, int cols = 1, int slices = 1, ValueType type = Normal);
 
         /**
          * New a mkl calculate based Matrix
diff --git a/test/FunctionTester.cpp b/test/FunctionTester.cpp
index a3c666e..a6df6b9 100644
--- a/test/FunctionTester.cpp
+++ b/test/FunctionTester.cpp
@@ -4,6 +4,12 @@
 #include "Function1D.h"
 
 
+#define DISPLAY_MATRIX(Matrix)\
+printf("=====================================\r\n");\
+printf("%s:\r\n", #Matrix);\
+Matrix.printf();\
+printf("%s end================================\r\n", #Matrix);
+
 class FunctionTester:public ::testing::Test{
 protected:
     static void SetUpFunctionTester(){
@@ -21,6 +27,107 @@ double fourDecimalRound(double src){
     return round(src*10000.0)/10000.0;
 }
 
+
+TEST_F(FunctionTester, MatrixCreate) {
+    double * dataA =Aurora::malloc(9);
+    double * dataB = new double[9];
+    double * dataC = new double[9];
+    double * dataD = new double[9];
+    //mkl matrix
+    {
+        Aurora::Matrix A = Aurora::Matrix::New(dataA, 3, 3);
+        EXPECT_EQ(dataA, A.getData());
+        EXPECT_EQ(9, A.getDataSize());
+        EXPECT_EQ(2, A.getDims());
+        EXPECT_EQ(3, A.getDimSize(0));
+        EXPECT_EQ(3, A.getDimSize(1));
+        EXPECT_EQ(Aurora::Normal, A.getValueType());
+        DISPLAY_MATRIX(A)
+    }
+    // double [] matrix
+    {
+        Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 3, 3);
+        EXPECT_EQ(dataB, B.getData());
+        EXPECT_EQ(9, B.getDataSize());
+        EXPECT_EQ(2, B.getDims());
+        EXPECT_EQ(3, B.getDimSize(0));
+        EXPECT_EQ(3, B.getDimSize(1));
+        EXPECT_EQ(Aurora::Normal, B.getValueType());
+        DISPLAY_MATRIX(B)
+    }
+    // copy from double [] to mkl matrix
+    {
+        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 3, 3);
+        EXPECT_NE(dataC, 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(Aurora::Normal, C.getValueType());
+        DISPLAY_MATRIX(C)
+    }
+    // 2vector
+    {
+        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 9);
+        EXPECT_NE(dataC, C.getData());
+        EXPECT_EQ(9, C.getDataSize());
+        EXPECT_EQ(2, C.getDims());
+        EXPECT_EQ(9, C.getDimSize(0));
+        EXPECT_EQ(1, C.getDimSize(1));
+        EXPECT_EQ(Aurora::Normal, C.getValueType());
+        DISPLAY_MATRIX(C)
+    }
+    // 2d vector
+    {
+        Aurora::Matrix C = Aurora::Matrix::fromRawData(dataC, 9, 1);
+        EXPECT_EQ(dataC, C.getData());
+        EXPECT_EQ(9, C.getDataSize());
+        EXPECT_EQ(2, C.getDims());
+        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
+    {
+        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataD, 1, 9);
+        EXPECT_NE(dataD, C.getData());
+        delete [] dataD;
+        EXPECT_EQ(9, C.getDataSize());
+        EXPECT_EQ(2, C.getDims());
+        EXPECT_EQ(1, C.getDimSize(0));
+        EXPECT_EQ(9, C.getDimSize(1));
+        EXPECT_EQ(Aurora::Normal, C.getValueType());
+        DISPLAY_MATRIX(C)
+    }
+    // 3d matrix
+    {
+        double * tempData = new double[9];
+        Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3,1);
+        EXPECT_EQ(dataD, C.getData());
+        EXPECT_EQ(9, C.getDataSize());
+        EXPECT_EQ(3, 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
+    {
+        double * tempData = new double[9];
+        Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 1,3);
+        EXPECT_EQ(dataD, C.getData());
+        EXPECT_EQ(9, C.getDataSize());
+        EXPECT_EQ(3, C.getDims());
+        EXPECT_EQ(3, C.getDimSize(0));
+        EXPECT_EQ(1, C.getDimSize(1));
+        EXPECT_EQ(3, C.getDimSize(2));
+        EXPECT_EQ(Aurora::Normal, C.getValueType());
+        DISPLAY_MATRIX(C)
+    }
+}
+
 TEST_F(FunctionTester, matrixSlice) {
     double * dataA =Aurora::malloc(8);
     double * dataB =Aurora::malloc(8);
@@ -79,26 +186,6 @@ TEST_F(FunctionTester, sign) {
     sign(A*B).printf();
 }
 
-TEST_F(FunctionTester, matrix) {
-    double * dataA =Aurora::malloc(9);
-    double * dataB =Aurora::malloc(9);
-    for (int i = 0; i < 9; ++i) {
-        dataA[i]=(double)(i+1);
-        dataB[i]=(double)(i+2);
-    }
-    Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3);
-    A.printf();
-    Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
-    printf("B:\r\n");
-    B.printf();
-    printf("A*B:\r\n");
-    (A*B).printf();
-    printf("A*B+A:\r\n");
-    (A*B+A).printf();
-    A = (A*B+A)+3.;
-    A.printf();
-}
-
 
 TEST_F(FunctionTester, immse){
     double dataA[9]={1,2,3,4,5,6,7,8,9};