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

Arrange Test directory.

Browse Source
This commit is contained in:
Krad
2023-04-23 09:30:47 +08:00
parent 1b1ba3cc03
commit 47443b309d
7 changed files with 171 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CMakeLists.txt
View File

@@ -29,9 +29,10 @@ INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
include_directories(./src ./src/util)
file(GLOB_RECURSE test_cpp ./test/*.cpp)
file(GLOB_RECURSE test_h ./test/*.h)
enable_testing()
add_executable(Aurora_Test ${cpp_files} ${test_cpp})
add_executable(Aurora_Test ${cpp_files} ${test_cpp} ${test_h})
target_compile_options(Aurora_Test PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_COMPILE_OPTIONS>)
target_include_directories(Aurora_Test PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_INCLUDE_DIRECTORIES>)
target_link_libraries(Aurora_Test PUBLIC $<LINK_ONLY:MKL::MKL>)

16
src/Function2D.cpp
View File

@@ -1,6 +1,7 @@
#include <iostream>
#include "Function.h"
#include "Function2D.h"
#include "Function1D.h"
#include "mkl.h"
using namespace Aurora;
@@ -109,3 +110,18 @@ Matrix Aurora::interpn(const Matrix& aX, const Matrix& aY, const Matrix& aV, con
{
return Aurora::interp2(aY,aX,aV,aY1,aX1,aMethod);
}
Matrix Aurora::std(const Matrix &aMatrix) {
auto std = Aurora::malloc(aMatrix.getDimSize(1) * aMatrix.getDimSize(2));
Matrix src = aMatrix.isComplex() ? Aurora::abs(aMatrix) : aMatrix;
for (int i = 0; i < src.getDimSize(1); ++i) {
double *p = src.getData() + i * src.getDimSize(0);
double mean = cblas_dasum(src.getDimSize(0), p, 1) / src.getDimSize(0);
vdSubI(src.getDimSize(0), p, 1, &mean, 0, p, 1);
vdSqr(src.getDimSize(0), p, p);
std[i] = cblas_dasum(src.getDimSize(0), p, 1) / (src.getDimSize(0) - 1);
}
vdSqrt(src.getDimSize(1), std, std);
return Matrix::New(std,1,aMatrix.getDimSize(1), aMatrix.getDimSize(2));
}

2
src/Function2D.h
View File

@@ -11,7 +11,7 @@ namespace Aurora {
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);
};

109
test/Function1D_Test.cpp Normal file
View File

@@ -0,0 +1,109 @@
#include <gtest/gtest.h>
#include <vector>
#include "Matrix.h"
#include "Function.h"
#include "Function1D.h"
#include "Function2D.h"
#include "Function3D.h"
class Function1D_Test:public ::testing::Test{
protected:
static void SetUpFunction1DTester(){
}
static void TearDownTestCase(){
}
void SetUp(){
}
void TearDown(){
}
};
TEST_F(Function1D_Test, sign) {
double * dataA =Aurora::malloc(9);
double * dataB =Aurora::malloc(9);
for (int i = 0; i < 9; ++i) {
dataA[i]=(double)(i-3);
dataB[i]=(double)(i+2);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3);
Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
auto C = sign(A*B);
double * result = C.getData();
EXPECT_EQ(-1, result[0]);
EXPECT_EQ(0, result[3]);
EXPECT_EQ(1, result[4]);
}
TEST_F(Function1D_Test, repmat) {
//input 1D repmat 2D
double* input = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m(std::shared_ptr<double>(input,std::default_delete<double[]>()),std::vector<int>{10});
EXPECT_DOUBLE_EQ(repmat(m,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDataSize(),60);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(0),20);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(1),3);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(2),1);
//input 2D repmat 2D
double* input2 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m2(std::shared_ptr<double>(input2,std::default_delete<double[]>()),std::vector<int>{5,2});
EXPECT_DOUBLE_EQ(repmat(m2,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDataSize(),60);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(0),10);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(1),6);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(2),1);
//input 1D repmat 3D
double* input3 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m3(std::shared_ptr<double>(input3,std::default_delete<double[]>()),std::vector<int>{10});
EXPECT_DOUBLE_EQ(repmat(m3,1,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDataSize(),240);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(0),20);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(1),3);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(2),4);
//input 2D repmat 3D
double* input4 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m4(std::shared_ptr<double>(input4,std::default_delete<double[]>()),std::vector<int>{5,2});
EXPECT_DOUBLE_EQ(repmat(m4,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDataSize(),240);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(0),10);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(1),6);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(2),4);
}
TEST_F(Function1D_Test, interp1) {
double* xD= new double[5]{1,2,3,4,5};
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{5});
double* yD= new double[5]{1,4,9,16,25};
Aurora::Matrix y(std::shared_ptr<double>(yD,std::default_delete<double[]>()),std::vector<int>{5});
double* x1D= new double[3]{1.22,2.69,3.84};
Aurora::Matrix x1(std::shared_ptr<double>(x1D,std::default_delete<double[]>()),std::vector<int>{3});
Aurora::Matrix result = interp1(x,y,x1,Aurora::InterpnMethod::Spline);
EXPECT_DOUBLE_EQ(result.getData()[0],1.4884);
EXPECT_DOUBLE_EQ(result.getData()[1],7.2361);
EXPECT_DOUBLE_EQ(result.getData()[2],14.7456);
result = interp1(x,y,x1,Aurora::InterpnMethod::Linear);
EXPECT_DOUBLE_EQ(result.getData()[0],1.66);
EXPECT_DOUBLE_EQ(result.getData()[1],7.45);
EXPECT_DOUBLE_EQ(result.getData()[2],14.88);
}
TEST_F(Function1D_Test, polyval){
double dataP[3]={3,2,1};
double dataX[3]={5,7,9};
double*resultP = Aurora::polyval(dataX,dataP,3);
EXPECT_DOUBLE_EQ(86., resultP[0])<<" polyval error;";
EXPECT_DOUBLE_EQ(162., resultP[1])<<" polyval error;";
EXPECT_DOUBLE_EQ(262., resultP[2])<<" polyval error;";
delete [] resultP;
}

130
test/FunctionTester.cpp → test/Function2D_Test.cpp
View File

@@ -1,5 +1,8 @@
#include <gtest/gtest.h>
#include <vector>
#include "TestUtility.h"
#include "Matrix.h"
#include "Function.h"
#include "Function1D.h"
@@ -7,7 +10,7 @@
#include "Function3D.h"
class FunctionTester:public ::testing::Test{
class Function2D_Test: public ::testing::Test{
protected:
static void SetUpFunctionTester(){
@@ -20,31 +23,7 @@ protected:
}
};
double fourDecimalRound(double src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB));
TEST_F(FunctionTester, sign) {
double * dataA =Aurora::malloc(9);
double * dataB =Aurora::malloc(9);
for (int i = 0; i < 9; ++i) {
dataA[i]=(double)(i-3);
dataB[i]=(double)(i+2);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3);
Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
auto C = sign(A*B);
double * result = C.getData();
EXPECT_EQ(-1, result[0]);
EXPECT_EQ(0, result[3]);
EXPECT_EQ(1, result[4]);
}
TEST_F(FunctionTester, immse){
TEST_F(Function2D_Test, immse){
double *dataA = new double[9]{1,2,3,4,5,6,7,8,9};
double *dataB = new double[9]{10,20,30,40,50,40,30,20,10};
Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,3,3);
@@ -53,7 +32,7 @@ TEST_F(FunctionTester, immse){
EXPECT_DOUBLE_EQ(fourDecimalRound(v),698.3333)<<" immse error;";
}
TEST_F(FunctionTester, inv){
TEST_F(Function2D_Test, inv){
//默认是column major排布数据
double *dataA=new double[9]{2, 0, 2, 2, 3, 0, 3, 3, 3};
double *dataB=new double[9]{1, 1, 1, 1, 1, 1, 1, 1, 1};
@@ -83,26 +62,18 @@ TEST_F(FunctionTester, inv){
EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[8]));
}
TEST_F(FunctionTester, polyval){
double dataP[3]={3,2,1};
double dataX[3]={5,7,9};
double*resultP = Aurora::polyval(dataX,dataP,3);
EXPECT_DOUBLE_EQ(86., resultP[0])<<" polyval error;";
EXPECT_DOUBLE_EQ(162., resultP[1])<<" polyval error;";
EXPECT_DOUBLE_EQ(262., resultP[2])<<" polyval error;";
delete [] resultP;
TEST_F(Function2D_Test, std){
double *dataMA= new double [9]{1, 2, 3, 2, 2, 6, 3, 3, 6};
auto A = Aurora::Matrix::fromRawData(dataMA,3,3);
auto D= Aurora::std(A);
double* resultStd = D.getData();
EXPECT_DOUBLE_EQ(1.0, resultStd[0]);
EXPECT_DOUBLE_EQ(2.3094, fourDecimalRound(resultStd[1]));
EXPECT_DOUBLE_EQ(1.7321, fourDecimalRound(resultStd[2]));
}
TEST_F(FunctionTester, std){
double dataMA[9]={1, 2, 3, 2, 2, 6, 3, 3, 6};
double* resultStd = Aurora::std(3, 3, dataMA);
EXPECT_DOUBLE_EQ(1.0, resultStd[0])<<" std error index 0";
EXPECT_DOUBLE_EQ(2.3094, fourDecimalRound(resultStd[1]))<<" std error index 1";
EXPECT_DOUBLE_EQ(1.7321, fourDecimalRound(resultStd[2]))<<" std error index 2";
delete [] resultStd;
}
TEST_F(FunctionTester, fftAndComplexAndIfft){
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);
// //复数化后，实部不变，虚部全为0
@@ -123,7 +94,7 @@ TEST_F(FunctionTester, fftAndComplexAndIfft){
// delete [] ifftResult;
}
TEST_F(FunctionTester, hilbert) {
TEST_F(Function2D_Test, hilbert) {
double input[10]{1,1,0,2,2,0,1,1,0,2};
auto result = Aurora::hilbert(10,input);
EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].real()),1.0)<<" hilbert result real value error";
@@ -134,68 +105,7 @@ TEST_F(FunctionTester, hilbert) {
EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].imag()),0.4253)<<" hilbert result imag value error";
}
TEST_F(FunctionTester, repmat) {
//input 1D repmat 2D
double* input = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m(std::shared_ptr<double>(input,std::default_delete<double[]>()),std::vector<int>{10});
EXPECT_DOUBLE_EQ(repmat(m,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDataSize(),60);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(0),20);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(1),3);
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(2),1);
//input 2D repmat 2D
double* input2 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m2(std::shared_ptr<double>(input2,std::default_delete<double[]>()),std::vector<int>{5,2});
EXPECT_DOUBLE_EQ(repmat(m2,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDataSize(),60);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(0),10);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(1),6);
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(2),1);
//input 1D repmat 3D
double* input3 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m3(std::shared_ptr<double>(input3,std::default_delete<double[]>()),std::vector<int>{10});
EXPECT_DOUBLE_EQ(repmat(m3,1,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDataSize(),240);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(0),20);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(1),3);
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(2),4);
//input 2D repmat 3D
double* input4 = new double[10]{1,2,3,4,5,6,7,8,9,10};
Aurora::Matrix m4(std::shared_ptr<double>(input4,std::default_delete<double[]>()),std::vector<int>{5,2});
EXPECT_DOUBLE_EQ(repmat(m4,1,1).getData()[7],8);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDataSize(),240);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getData()[22],3);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(0),10);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(1),6);
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(2),4);
}
TEST_F(FunctionTester, interp1) {
double* xD= new double[5]{1,2,3,4,5};
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{5});
double* yD= new double[5]{1,4,9,16,25};
Aurora::Matrix y(std::shared_ptr<double>(yD,std::default_delete<double[]>()),std::vector<int>{5});
double* x1D= new double[3]{1.22,2.69,3.84};
Aurora::Matrix x1(std::shared_ptr<double>(x1D,std::default_delete<double[]>()),std::vector<int>{3});
Aurora::Matrix result = interp1(x,y,x1,Aurora::InterpnMethod::Spline);
EXPECT_DOUBLE_EQ(result.getData()[0],1.4884);
EXPECT_DOUBLE_EQ(result.getData()[1],7.2361);
EXPECT_DOUBLE_EQ(result.getData()[2],14.7456);
result = interp1(x,y,x1,Aurora::InterpnMethod::Linear);
EXPECT_DOUBLE_EQ(result.getData()[0],1.66);
EXPECT_DOUBLE_EQ(result.getData()[1],7.45);
EXPECT_DOUBLE_EQ(result.getData()[2],14.88);
}
TEST_F(FunctionTester, interp2) {
TEST_F(Function2D_Test, interp2) {
double* xD= new double[4]{1,2,3,4};
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
double* yD= new double[5]{1,4,9,16,25};
@@ -218,7 +128,7 @@ TEST_F(FunctionTester, interp2) {
EXPECT_DOUBLE_AE(result.getData()[2],18.6089);
}
TEST_F(FunctionTester, interp3) {
TEST_F(Function2D_Test, interp3) {
double* xD= new double[4]{1,2,3,4};
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
double* yD= new double[5]{1,4,9,16,25};
@@ -247,7 +157,7 @@ TEST_F(FunctionTester, interp3) {
EXPECT_DOUBLE_AE(result.getData()[2],18.6089);
}
TEST_F(FunctionTester, interpn) {
TEST_F(Function2D_Test, interpn) {
double* xD= new double[4]{1,2,3,4};
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
double* yD= new double[5]{1,4,9,16,25};

15
test/MatrixTester.cpp → test/Matrix_Test.cpp
View File

@@ -6,15 +6,11 @@
#include "Function2D.h"
#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 MatrixTester : public ::testing::Test {
class Matrix_Test : public ::testing::Test {
protected:
static void SetUpMatrixTester() {
@@ -30,8 +26,7 @@ protected:
}
};
TEST_F(MatrixTester, MatrixCreate) {
TEST_F(Matrix_Test, MatrixCreate) {
double *dataA = Aurora::malloc(9);
double *dataB = new double[9];
double *dataC = new double[9];
@@ -131,7 +126,7 @@ TEST_F(MatrixTester, MatrixCreate) {
}
}
TEST_F(MatrixTester, matrixSlice) {
TEST_F(Matrix_Test, matrixSlice) {
double *dataA = Aurora::malloc(8);
double *dataB = Aurora::malloc(8);
double *dataC = Aurora::malloc(8);
@@ -165,7 +160,7 @@ TEST_F(MatrixTester, matrixSlice) {
EXPECT_EQ(9, D.getData()[0]);
}
TEST_F(MatrixTester, matrixOpertaor) {
TEST_F(Matrix_Test, matrixOpertaor) {
//3D
{
double *dataA = new double[8];

18
test/TestUtility.h Normal file
View File

@@ -0,0 +1,18 @@
#ifndef AURORA_TESTUTILITY_H
#define AURORA_TESTUTILITY_H
#include <cmath>
#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #Matrix);
double fourDecimalRound(double src){
return round(src*10000.0)/10000.0;
}
#define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB));
#endif //AURORA_TESTUTILITY_H