Add index to min and max.

src/Function2D.cpp

@@ -131,7 +131,7 @@ 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) {
+Matrix Aurora::min(const Matrix &aMatrix, FunctionDirection direction, long& rowIdx, long& colIdx) {
     if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
         std::cerr
                 << (aMatrix.getDimSize(2) > 1 ? "min() not support 3D data!" : "min() not support complex value type!")
@@ -140,33 +140,49 @@ Matrix Aurora::min(const Matrix &aMatrix, FunctionDirection direction) {
     }
     switch (direction)
     {
-        case All:
+        case All: {
-        {
+            Eigen::Map<Eigen::MatrixXd> retV(aMatrix.getData(), aMatrix.getDimSize(0), aMatrix.getDimSize(1));
-            Eigen::Map<Eigen::VectorXd> retV(aMatrix.getData(),aMatrix.getDataSize());
+            double *ret = malloc(1);
-            double * ret = malloc(1);
+            ret[0] = retV.array().minCoeff(&rowIdx, &colIdx);
-            ret[0] = retV.array().minCoeff();
+            return Matrix::New(ret, 1);
-            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();
+            if (aMatrix.getDimSize(0) == 1){
+                ret[0] = srcMatrix.topRows(0).minCoeff(&rowIdx, &colIdx);
+            }
+            else{
+                Eigen::Map<Eigen::MatrixXd> retMatrix(ret,aMatrix.getDimSize(0),1);
+                retMatrix = srcMatrix.rowwise().minCoeff();
+            }
             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));
+            double * ret = malloc(aMatrix.getDimSize(1));
-            Eigen::Map<Eigen::MatrixXd> retMatrix(ret,1,aMatrix.getDimSize(1));
+
-            retMatrix = srcMatrix.colwise().minCoeff();
+            if (aMatrix.getDimSize(1) == 1){
+                ret[0] = srcMatrix.col(0).minCoeff(&rowIdx, &colIdx);
+            }
+            else {
+                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, FunctionDirection direction) {
+    long a,b;
+    return  min(aMatrix,direction,a,b);
+}
+
 Matrix Aurora::min(const Matrix &aMatrix, const Matrix &aOther) {
     if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
         std::cerr
@@ -221,6 +237,11 @@ Matrix Aurora::min(const Matrix &aMatrix, const Matrix &aOther) {
 }
 
 Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
+    long a,b;
+    return  max(aMatrix,direction,a,b);
+}
+
+Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction, long& rowIdx, long& colIdx) {
     if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
         std::cerr
                 << (aMatrix.getDimSize(2) > 1 ? "max() not support 3D data!" : "max() not support complex value type!")
@@ -231,17 +252,22 @@ Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
     {
         case All:
         {
-            Eigen::Map<Eigen::VectorXd> retV(aMatrix.getData(),aMatrix.getDataSize());
+            Eigen::Map<Eigen::MatrixXd> retV(aMatrix.getData(), aMatrix.getDimSize(0), aMatrix.getDimSize(1));
-            double * ret = malloc(1);
+            double *ret = malloc(1);
-            ret[0] = retV.array().maxCoeff();
+            ret[0] = retV.array().maxCoeff(&rowIdx, &colIdx);
             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);
+            if (aMatrix.getDimSize(0) == 1){
-            retMatrix = srcMatrix.rowwise().maxCoeff();
+                ret[0] = srcMatrix.topRows(0).maxCoeff(&rowIdx, &colIdx);
+            }
+            else{
+                Eigen::Map<Eigen::MatrixXd> retMatrix(ret,aMatrix.getDimSize(0),1);
+                retMatrix = srcMatrix.rowwise().maxCoeff();
+            }
             return Matrix::New(ret,aMatrix.getDimSize(0),1);
         }
         case Column:
@@ -249,8 +275,13 @@ Matrix Aurora::max(const Matrix &aMatrix, FunctionDirection direction) {
         {
             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));
+            if (aMatrix.getDimSize(1) == 1){
-            retMatrix = srcMatrix.colwise().maxCoeff();
+                ret[0] = srcMatrix.col(0).maxCoeff(&rowIdx, &colIdx);
+            }
+            else {
+                Eigen::Map<Eigen::MatrixXd> retMatrix(ret,1,aMatrix.getDimSize(1));
+                retMatrix = srcMatrix.colwise().maxCoeff();
+            }
             return Matrix::New(ret,1,aMatrix.getDimSize(1));
         }
     }
@@ -292,15 +323,6 @@ Matrix Aurora::sum(const Matrix &aMatrix, FunctionDirection direction) {
     }
 }
 
-void excludeNan(double * aInput, int aInputSize,double* aOutput,int& aOutputSize){
-    aOutputSize = 0;
-    for (int i = 0; i < aInputSize; ++i) {
-        if (std::isnan(aInput[i])) continue;
-        aOutput[aOutputSize]=aInput[i];
-        aOutputSize++;
-    }
-}
-
 Matrix Aurora::mean(const Matrix &aMatrix, FunctionDirection direction, bool aIncludeNan) {
     if (aMatrix.getDimSize(2)>1 || aMatrix.isComplex()) {
         std::cerr

src/Function2D.h

@@ -26,6 +26,8 @@ namespace Aurora {
      */
     Matrix min(const Matrix& aMatrix,FunctionDirection direction = Column);
 
+    Matrix min(const Matrix& aMatrix,FunctionDirection direction, long& rowIdx, long& colIdx);
+
     /**
      * 求矩阵最小值，可按行、列、单元, 目前不支持三维，不支持复数
      * @param aMatrix  矩阵
@@ -34,6 +36,8 @@ namespace Aurora {
      */
     Matrix max(const Matrix& aMatrix,FunctionDirection direction = Column);
 
+    Matrix max(const Matrix& aMatrix,FunctionDirection direction , long& rowIdx, long& colIdx);
+
     /**
      * 比较两个矩阵，求对应位置的最小值，不支持三维
      * @attention 矩阵形状不一样时，如A为[MxN],则B应为标量或[1xN]的行向量

test/Function2D_Test.cpp

@@ -96,6 +96,12 @@ TEST_F(Function2D_Test, min) {
     EXPECT_DOUBLE_EQ(2, ret.getData()[0]);
     EXPECT_DOUBLE_EQ(2, ret.getData()[1]);
     EXPECT_DOUBLE_EQ(-1, ret.getData()[2]);
+    long r,c;
+    ret = Aurora::min(A, Aurora::Column,r,c);
+    EXPECT_DOUBLE_EQ(1, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(1, ret.getData()[0]);
+    EXPECT_EQ(0, r);
+    EXPECT_EQ(0, c);
     ret = Aurora::min(A, C);
     EXPECT_DOUBLE_EQ(3, ret.getDataSize());
     EXPECT_DOUBLE_EQ(1, ret.getData()[0]);
@@ -129,6 +135,12 @@ TEST_F(Function2D_Test, max) {
     EXPECT_DOUBLE_EQ(3, ret.getData()[0]);
     EXPECT_DOUBLE_EQ(3, ret.getData()[1]);
     EXPECT_DOUBLE_EQ(3, ret.getData()[2]);
+    long r,c;
+    ret = Aurora::max(A, Aurora::Column,r,c);
+    EXPECT_DOUBLE_EQ(1, ret.getDataSize());
+    EXPECT_DOUBLE_EQ(3, ret.getData()[0]);
+    EXPECT_EQ(2, r);
+    EXPECT_EQ(0, c);
 }
 
 TEST_F(Function2D_Test, sum) {
@@ -153,6 +165,7 @@ TEST_F(Function2D_Test, sum) {
 }
 
 TEST_F(Function2D_Test, mean) {
+
     {
         double *dataB = new double[16]{1.1, 2.6, 3.8, 6.2,
                                        4.3, 5.7, 6.9, 10.6,