Add sum and sum's unit test.

src/Function2D.cpp

@@ -222,7 +222,7 @@ Matrix Aurora::min(const Matrix &aMatrix, const Matrix &aOther) {
 Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
     if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
         std::cerr
-                << (aMatrix.getDimSize(2) > 1 ? "min() not support 3D data!" : "min() not support complex value type!")
+                << (aMatrix.getDimSize(2) > 1 ? "max() not support 3D data!" : "max() not support complex value type!")
                 << std::endl;
         return Matrix();
     }
@@ -244,6 +244,7 @@ Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
             return Matrix::New(ret,aMatrix.getDimSize(0),1);
         }
         case Column:
+        default:
         {
             Eigen::Map<Eigen::MatrixXd> srcMatrix(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1));
             double * ret = malloc(aMatrix.getDimSize(0));
@@ -253,3 +254,40 @@ Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
         }
     }
 }
+
+Matrix Aurora::sum(const Matrix &aMatrix, FunctionDirection direction) {
+    if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
+        std::cerr
+                << (aMatrix.getDimSize(2) > 1 ? "sum() not support 3D data!" : "sum() not support complex value type!")
+                << std::endl;
+        return Matrix();
+    }
+    switch (direction)
+    {
+        case All:
+        {
+            double * ret = malloc(1);
+            ret[0] = cblas_dasum(aMatrix.getDataSize(),aMatrix.getData(),1);
+            return Matrix::New(ret,1);
+        }
+        case Row:
+        {
+            double * ret = malloc(aMatrix.getDimSize(0));
+            for (int i = 0; i < aMatrix.getDimSize(0); ++i) {
+                ret[i] = cblas_dasum(aMatrix.getDimSize(1), aMatrix.getData() + i,
+                                     aMatrix.getDimSize(0));
+            }
+            return Matrix::New(ret,aMatrix.getDimSize(0),1);
+        }
+        case Column:
+        default:
+        {
+            double * ret = malloc(aMatrix.getDimSize(0));
+            for (int i = 0; i < aMatrix.getDimSize(1); ++i) {
+                ret[i] = cblas_dasum(aMatrix.getDimSize(0), aMatrix.getData()+aMatrix.getDimSize(0)*i,
+                                     1);
+            }
+            return Matrix::New(ret,1,aMatrix.getDimSize(1));
+        }
+    }
+}

src/Function2D.h

@@ -33,6 +33,7 @@ namespace Aurora {
      * @return
      */
     Matrix max(const Matrix& aMatrix,FunctionDirection direction = Column);
+
     /**
      * 比较两个矩阵，求对应位置的最小值，不支持三维
      * @attention 矩阵形状不一样时，如A为[MxN],则B应为标量或[1xN]的行向量
@@ -42,6 +43,14 @@ namespace Aurora {
      */
     Matrix min(const Matrix& aMatrix,const Matrix& aOther);
 
+    /**
+     * 求矩阵和，可按行、列、单元, 目前不支持三维，不支持复数
+     * @param aMatrix  矩阵
+     * @param direction 方向，Column, Row, All
+     * @return
+     */
+    Matrix sum(const Matrix& aMatrix,FunctionDirection direction = Column);
+
 };
 
 

test/Function2D_Test.cpp

@@ -131,6 +131,27 @@ TEST_F(Function2D_Test, max) {
     EXPECT_DOUBLE_EQ(3, ret.getData()[2]);
 }
 
+TEST_F(Function2D_Test, sum) {
+    double *dataB = new double[9]{2, 3, 3, 2, 2, 1, 3, 3, 3};
+    auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
+    Aurora::Matrix ret = Aurora::sum(B);
+    EXPECT_EQ(1, ret.getDimSize(0));
+    EXPECT_EQ(3, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(8, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(5, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(9, ret.getData()[2]);
+    ret = Aurora::sum(B, Aurora::All);
+    EXPECT_DOUBLE_EQ(1, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(22, ret.getData()[0]);
+    ret = Aurora::sum(B, Aurora::Row);
+    EXPECT_DOUBLE_EQ(3, ret.getDataSize());
+    EXPECT_EQ(3, ret.getDimSize(0));
+    EXPECT_EQ(1, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(7, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(8, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(7, ret.getData()[2]);
+}
+
 TEST_F(Function2D_Test, fftAndComplexAndIfft){
 //    double input[10]{1,1,0,2,2,0,1,1,0,2};
 //    std::complex<double>* complexInput = Aurora::complex(10,input);