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

Refactor Matrix unit test, remove log

Browse Source
This commit is contained in:
Krad
2023-04-21 17:25:22 +08:00
parent c1c09fa45f
commit 1b1ba3cc03
3 changed files with 308 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
test/FunctionTester.cpp
View File

@@ -7,15 +7,6 @@
#include "Function3D.h"
#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #Matrix);
#define DISPLAY_MATRIX
class FunctionTester:public ::testing::Test{
protected:
static void SetUpFunctionTester(){
@@ -36,263 +27,6 @@ double fourDecimalRound(double src){
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB));
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(2, 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);
double * dataC =Aurora::malloc(8);
for (int i = 0; i < 8; ++i) {
dataA[i]=(double)(i);
dataB[i]=(double)(1);
dataC[i]=(double)(9-i);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2);
Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2);
Aurora::Matrix C = Aurora::Matrix::New(dataC,2,2,2);
//2D slice
EXPECT_EQ(4.0,dataA[4]);
A(Aurora::$,Aurora::$,1) = B(0,Aurora::$,Aurora::$);
EXPECT_EQ(1,dataA[4]);
EXPECT_EQ(3,dataA[3]);
A(Aurora::$,1,Aurora::$) = B(Aurora::$,Aurora::$,0);
EXPECT_EQ(1.0,dataA[3]);
EXPECT_EQ(0.0,dataA[0]);
A(0,Aurora::$,Aurora::$) = B(Aurora::$,0,Aurora::$);
EXPECT_EQ(1.0,dataA[0]);
//vector slice
A(0,Aurora::$,0) = C(0,0,Aurora::$);
EXPECT_EQ(9.0,dataA[0]);
A(Aurora::$,0,0) = C(0,Aurora::$,1);
EXPECT_EQ(5.0,dataA[0]);
//error slice
EXPECT_EQ(1,A(Aurora::$,Aurora::$,Aurora::$).toMatrix().getDataSize() );
auto D =C(0,0,0).toMatrix();
EXPECT_EQ(1,D.getDataSize() );
EXPECT_EQ(9,D.getData()[0] );
}
TEST_F(FunctionTester, matrixOpertaor) {
//3D
{
double * dataA =new double[8];
double * dataB =new double[8];
double * dataD =new double[8];
for (int i = 0; i < 8; ++i) {
dataA[i]=(double)(i);
dataB[i]=(double)(2);
}
Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,2,2,2);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,2,2,2);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,4,2);
DISPLAY_MATRIX(D);
auto C = (A*B)-B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],2);
C = A*B/2.0;
EXPECT_EQ(C.getData()[2],2);
C = (A*8.0/B) * (B+1.0)-2.0+8;
EXPECT_EQ(C.getData()[2],30);
//Error matrix
C = A*D;
EXPECT_EQ(C.getDataSize(),0);
}
//complex
{
double * dataA =Aurora::malloc(8,true);
double * dataB =Aurora::malloc(8,true);
double * dataD =new double[8];
for (int i = 0; i < 16; ++i) {
dataA[i]=(double)(i+1);
dataB[i]=(double)(2);
if(i<8) dataD[i]=(double)(2);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2,Aurora::Complex);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2,Aurora::Complex);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,2,2,2);
DISPLAY_MATRIX(D);
auto C = A + 5.0 -2.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],6);
EXPECT_EQ(C.getData()[3],4);
EXPECT_TRUE(C.isComplex());
C = A*B-B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],-4);
EXPECT_EQ(C.getData()[3],12);
EXPECT_TRUE(C.isComplex());
C = A*B-2.0+5.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],14);
C = A*B/2.0*3.;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],-3);
EXPECT_EQ(C.getData()[3],21);
C = A*B/B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],3);
EXPECT_EQ(C.getData()[3],4);
C = A*B/(B*A/A);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],3);
EXPECT_EQ(C.getData()[3],4);
C = B*D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = B/D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = B+D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = B-D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
C = B*(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = B/(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = B+(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = B-(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
C = (B*1.0)*(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = (B*1.0)/(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = (B*1.0)+(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = (B*1.0)-(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
}
}
TEST_F(FunctionTester, sign) {
double * dataA =Aurora::malloc(9);
double * dataB =Aurora::malloc(9);
@@ -369,24 +103,24 @@ TEST_F(FunctionTester, std){
}
TEST_F(FunctionTester, fftAndComplexAndIfft){
double input[10]{1,1,0,2,2,0,1,1,0,2};
std::complex<double>* complexInput = Aurora::complex(10,input);
//复数化后，实部不变，虚部全为0
EXPECT_DOUBLE_EQ(complexInput[1].real(),1.0)<<" complex error";
EXPECT_DOUBLE_EQ(complexInput[1].imag(),0)<<" complex error";
std::complex<double>* result = Aurora::fft(10,complexInput);
delete [] complexInput;
//检验fft结果与matlab是否对应
EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real()))<<" fft result value error";
EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag()))<<" fft result value error";
//检验fft的结果是否共轭
EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag())<<" fft result conjugate error";
EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real())<<" fft result conjugate error";
std::complex<double>* ifftResult = Aurora::ifft(10,result);
EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0)<<" ifft result real value error";
EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].imag()),0)<<" ifft result imag value error";
delete [] result;
delete [] ifftResult;
// double input[10]{1,1,0,2,2,0,1,1,0,2};
// std::complex<double>* complexInput = Aurora::complex(10,input);
// //复数化后，实部不变，虚部全为0
// EXPECT_DOUBLE_EQ(complexInput[1].real(),1.0)<<" complex error";
// EXPECT_DOUBLE_EQ(complexInput[1].imag(),0)<<" complex error";
// std::complex<double>* result = Aurora::fft(10,complexInput);
// delete [] complexInput;
// //检验fft结果与matlab是否对应
// EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real()))<<" fft result value error";
// EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag()))<<" fft result value error";
// //检验fft的结果是否共轭
// EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag())<<" fft result conjugate error";
// EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real())<<" fft result conjugate error";
// std::complex<double>* ifftResult = Aurora::ifft(10,result);
// EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0)<<" ifft result real value error";
// EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].imag()),0)<<" ifft result imag value error";
// delete [] result;
// delete [] ifftResult;
}
TEST_F(FunctionTester, hilbert) {