diff --git a/src/Function2D.cpp b/src/Function2D.cpp
index 9aa5da3..fb3254d 100644
--- a/src/Function2D.cpp
+++ b/src/Function2D.cpp
@@ -130,3 +130,126 @@ Matrix Aurora::std(const Matrix &aMatrix) {
 
     return Matrix::New(std,1,aMatrix.getDimSize(1), aMatrix.getDimSize(2));
 }
+
+Matrix Aurora::min(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!")
+                << std::endl;
+        return Matrix();
+    }
+    switch (direction)
+    {
+        case All:
+        {
+            Eigen::Map<Eigen::VectorXd> retV(aMatrix.getData(),aMatrix.getDataSize());
+            double * ret = malloc(1);
+            ret[0] = retV.array().minCoeff();
+            return Matrix::New(ret,1);
+        }
+        case Row:
+        {
+            Eigen::Map<Eigen::MatrixXd> srcMatrix(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1));
+            double * ret = malloc(aMatrix.getDimSize(0));
+            Eigen::Map<Eigen::MatrixXd> retMatrix(ret,aMatrix.getDimSize(0),1);
+            retMatrix = srcMatrix.rowwise().minCoeff();
+            return Matrix::New(ret,aMatrix.getDimSize(0),1);
+        }
+        case Column:
+        {
+            Eigen::Map<Eigen::MatrixXd> srcMatrix(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1));
+            double * ret = malloc(aMatrix.getDimSize(0));
+            Eigen::Map<Eigen::MatrixXd> retMatrix(ret,1,aMatrix.getDimSize(1));
+            retMatrix = srcMatrix.colwise().minCoeff();
+            return Matrix::New(ret,1,aMatrix.getDimSize(1));
+        }
+    }
+}
+
+Matrix Aurora::min(const Matrix &aMatrix, const Matrix &aOther) {
+    if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
+        std::cerr
+                << (aMatrix.getDimSize(2) > 1 ? "min() not support 3D data!" : "min() not support complex value type!")
+                << std::endl;
+        return Matrix();
+    }
+    if (aOther.getDimSize(2)>1 || aOther.isComplex()) {
+        std::cerr
+                << (aOther.getDimSize(2) > 1 ? "min() not support 3D data!" : "min() not support complex value type!")
+                << std::endl;
+        return Matrix();
+    }
+    //same shape
+    if (aMatrix.compareShape(aOther)){
+        double* output = malloc(aMatrix.getDataSize());
+        vdFminI(aMatrix.getDataSize(),aMatrix.getData(),1,aOther.getData(),1,output,1);
+        return Matrix::New(output,aMatrix);
+    }
+    // one is scalar
+    else if (aMatrix.getDataSize() == 1 || aOther.getDataSize() == 1){
+            double scalar = (aMatrix.getDataSize() == 1)?aMatrix.getData()[0]:aOther.getData()[0];
+            auto matrix = (aMatrix.getDataSize() == 1)?aOther:aMatrix;
+            double* output = malloc(matrix.getDataSize());
+            vdFminI(matrix.getDataSize(),matrix.getData(),1,&scalar,0,output,1);
+            return Matrix::New(output,matrix);
+    }
+    else if (aMatrix.getDimSize(1) == 1 || aOther.getDimSize(0) == 1) {
+        if (aMatrix.getDimSize(1) == 1){
+            double* output = malloc(aOther.getDataSize());
+            for (int i = 0; i < aOther.getDimSize(1); ++i) {
+                vdFminI(aMatrix.getDataSize(), aMatrix.getData(), 1, aOther.getData() + aOther.getDimSize(0) * i, 1,
+                        output + aOther.getDimSize(0) * i, 1);
+            }
+            return Matrix::New(output,aOther);
+        }
+        else{
+            double* output = malloc(aMatrix.getDataSize());
+            for (int i = 0; i < aMatrix.getDimSize(0); ++i) {
+                vdFminI(aOther.getDataSize(), aOther.getData(), 1, aMatrix.getData() +  i, aMatrix.getDimSize(0),
+                        output +  i, aOther.getDimSize(0));
+            }
+            return Matrix::New(output,aMatrix);
+        }
+    }
+    else{
+        std::cerr
+                << "min(A,B) with matrix must be like A[MxN] - B[1xN] or A[Mx1] - B[MxN]"
+                << std::endl;
+        return Matrix();
+    }
+}
+
+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!")
+                << std::endl;
+        return Matrix();
+    }
+    switch (direction)
+    {
+        case All:
+        {
+            Eigen::Map<Eigen::VectorXd> retV(aMatrix.getData(),aMatrix.getDataSize());
+            double * ret = malloc(1);
+            ret[0] = retV.array().maxCoeff();
+            return Matrix::New(ret,1);
+        }
+        case Row:
+        {
+            Eigen::Map<Eigen::MatrixXd> srcMatrix(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1));
+            double * ret = malloc(aMatrix.getDimSize(0));
+            Eigen::Map<Eigen::MatrixXd> retMatrix(ret,aMatrix.getDimSize(0),1);
+            retMatrix = srcMatrix.rowwise().maxCoeff();
+            return Matrix::New(ret,aMatrix.getDimSize(0),1);
+        }
+        case Column:
+        {
+            Eigen::Map<Eigen::MatrixXd> srcMatrix(aMatrix.getData(),aMatrix.getDimSize(0),aMatrix.getDimSize(1));
+            double * ret = malloc(aMatrix.getDimSize(0));
+            Eigen::Map<Eigen::MatrixXd> retMatrix(ret,1,aMatrix.getDimSize(1));
+            retMatrix = srcMatrix.colwise().maxCoeff();
+            return Matrix::New(ret,1,aMatrix.getDimSize(1));
+        }
+    }
+}
diff --git a/src/Function2D.h b/src/Function2D.h
index 1bc7873..8519ce8 100644
--- a/src/Function2D.h
+++ b/src/Function2D.h
@@ -6,12 +6,42 @@
 
 
 namespace Aurora {
+    enum FunctionDirection{
+        Column,
+        Row,
+        All
+    };
     double immse(const Matrix& aImageA, const Matrix& aImageB);
     Matrix inv(const Matrix& aMatrix);
     Matrix inv(Matrix&& aMatrix);
     Matrix interp2(const Matrix& aX, const Matrix& aY, const Matrix& aV, const Matrix& aX1, const Matrix& aY1, InterpnMethod aMethod);
     Matrix interpn(const Matrix& aX, const Matrix& aY, const Matrix& aV, const Matrix& aX1, const Matrix& aY1, InterpnMethod aMethod);
     Matrix std(const Matrix& aMatrix);
+
+    /**
+     * 求矩阵最小值，可按行、列、单元, 目前不支持三维，不支持复数
+     * @param aMatrix  矩阵
+     * @param direction 方向，Column, Row, All
+     * @return
+     */
+    Matrix min(const Matrix& aMatrix,FunctionDirection direction = Column);
+
+    /**
+     * 求矩阵最小值，可按行、列、单元, 目前不支持三维，不支持复数
+     * @param aMatrix  矩阵
+     * @param direction 方向，Column, Row, All
+     * @return
+     */
+    Matrix max(const Matrix& aMatrix,FunctionDirection direction = Column);
+    /**
+     * 比较两个矩阵，求对应位置的最小值，不支持三维
+     * @attention 矩阵形状不一样时，如A为[MxN],则B应为标量或[1xN]的行向量
+     * @param aMatrix
+     * @param aOther
+     * @return
+     */
+    Matrix min(const Matrix& aMatrix,const Matrix& aOther);
+
 };
 
 
diff --git a/test/Function2D_Test.cpp b/test/Function2D_Test.cpp
index 3e003ee..9bdb26c 100644
--- a/test/Function2D_Test.cpp
+++ b/test/Function2D_Test.cpp
@@ -72,6 +72,65 @@ TEST_F(Function2D_Test, std){
 
 }
 
+TEST_F(Function2D_Test, min) {
+    double *dataA = new double[3]{1, 2, 3};
+    double *dataB = new double[9]{2, 3, 3, 2, 2, 1, 3, 3, 3};
+    double *dataC = new double[1]{1.5};
+    auto A = Aurora::Matrix::fromRawData(dataA, 3, 1);
+    auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
+    auto C = Aurora::Matrix::fromRawData(dataC, 1);
+    auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3);
+    Aurora::Matrix ret = Aurora::min(B);
+    EXPECT_EQ(1, ret.getDimSize(0));
+    EXPECT_EQ(3, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(2, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(1, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(3, ret.getData()[2]);
+    ret = Aurora::min(B, Aurora::All);
+    EXPECT_DOUBLE_EQ(1, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(1, ret.getData()[0]);
+    ret = Aurora::min(B, Aurora::Row);
+    EXPECT_DOUBLE_EQ(3, ret.getDataSize());
+    EXPECT_EQ(3, ret.getDimSize(0));
+    EXPECT_EQ(1, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(2, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(2, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(1, ret.getData()[2]);
+    ret = Aurora::min(A, C);
+    EXPECT_DOUBLE_EQ(3, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(1, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(1.5, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(1.5, ret.getData()[2]);
+    ret = Aurora::min(B,D);
+    EXPECT_DOUBLE_EQ(9, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(1, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(1, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(1, ret.getData()[2]);
+}
+
+TEST_F(Function2D_Test, max) {
+    double *dataA = new double[3]{1, 2, 3};
+    double *dataB = new double[9]{2, 3, 3, 2, 2, 1, 3, 3, 3};
+    auto A = Aurora::Matrix::fromRawData(dataA, 3, 1);
+    auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
+    Aurora::Matrix ret = Aurora::max(B);
+    EXPECT_EQ(1, ret.getDimSize(0));
+    EXPECT_EQ(3, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(3, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(2, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(3, ret.getData()[2]);
+    ret = Aurora::max(B, Aurora::All);
+    EXPECT_DOUBLE_EQ(1, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(3, ret.getData()[0]);
+    ret = Aurora::max(B, Aurora::Row);
+    EXPECT_DOUBLE_EQ(3, ret.getDataSize());
+    EXPECT_EQ(3, ret.getDimSize(0));
+    EXPECT_EQ(1, ret.getDimSize(1));
+    EXPECT_DOUBLE_EQ(3, ret.getData()[0]);
+    EXPECT_DOUBLE_EQ(3, ret.getData()[1]);
+    EXPECT_DOUBLE_EQ(3, 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);