sunwen/Aurora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add min and max to Function2D.

Browse Source
This commit is contained in:
Krad
2023-04-23 16:02:08 +08:00
parent c0e413e80c
commit 4c08268887
3 changed files with 212 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

123
src/Function2D.cpp
View File

@@ -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));
}
}
}

30
src/Function2D.h
View File

@@ -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);
};

59
test/Function2D_Test.cpp
View File

@@ -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);