diff --git a/CMakeLists.txt b/CMakeLists.txt index 990d637..16fae3f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,7 +57,7 @@ file(GLOB_RECURSE test_cpp ./test/*.cpp) enable_testing() -add_executable(Aurora_Test ${cpp_files} ${test_cpp} ) +add_executable(Aurora_Test ${cpp_files} ${test_cpp} ${cu_files} ${cuh_files}) target_include_directories(Aurora_Test PUBLIC ./test/) target_compile_options(Aurora_Test PUBLIC $) target_include_directories(Aurora_Test PUBLIC $) diff --git a/src/CudaMatrix.cpp b/src/CudaMatrix.cpp index 6a6efec..d28e4fc 100644 --- a/src/CudaMatrix.cpp +++ b/src/CudaMatrix.cpp @@ -9,7 +9,7 @@ #include #include "CudaMatrixPrivate.cuh" -using namespace Aurora; +namespace Aurora{ CudaMatrix::CudaMatrix(std::shared_ptr aData, std::vector aInfo, ValueType aValueType) : mValueType(aValueType) @@ -241,8 +241,66 @@ bool CudaMatrix::setBlockValue(int aDim,int aBeginIndx, int aEndIndex,float valu return true; } + +CudaMatrix CudaMatrix::operator+(float aScalar) const{ + if (isComplex()) + { + std::cerr<<"Complex matrix not support operator+(float aScalar)"<getDataSize() != aMatrix.getDataSize()) return CudaMatrix(); + if (this->getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<getDataSize() + <<" and the matrix1 size is "<isComplex() != aMatrix.isComplex()) { + std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(this->isComplex()?"Comples":"Real") + <<" and the matrix1 type is "<<(aMatrix.isComplex()?"Comples":"Real")<getData(),aMatrix.getData(),out.getData(),this->getDataSize()); return out; } + +CudaMatrix CudaMatrix::operator+(CudaMatrix &&aMatrix) const{ + if (this->getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<getDataSize() + <<" and the matrix1 size is "<isComplex() != aMatrix.isComplex()) { + std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(this->isComplex()?"Comples":"Real") + <<" and the matrix1 type is "<<(aMatrix.isComplex()?"Comples":"Real")<getData(),aMatrix.getData(),aMatrix.getData(),this->getDataSize()); + return aMatrix; +} + + +CudaMatrix operator+(CudaMatrix &&aMatrix,CudaMatrix &aOther){ + if (aOther.getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<getDataSize() + <<" and the matrix1 size is "<isComplex() != aMatrix.isComplex()) { + std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(this->isComplex()?"Comples":"Real") + <<" and the matrix1 type is "<<(aMatrix.isComplex()?"Comples":"Real")<getData(),aMatrix.getData(),out.getData(),this->getDataSize()); + return out; + } + CudaMatrix CudaMatrix::operator*(CudaMatrix &&aMatrix) const{ + if (this->getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<getDataSize() + <<" and the matrix1 size is "<isComplex() != aMatrix.isComplex()) { + std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(this->isComplex()?"Comples":"Real") + <<" and the matrix1 type is "<<(aMatrix.isComplex()?"Comples":"Real")<getData(),aMatrix.getData(),aMatrix.getData(),this->getDataSize()); + return aMatrix; + } + CudaMatrix operator*(CudaMatrix &&aMatrix,CudaMatrix &aOther){ + if (aOther.getDataSize() != aMatrix.getDataSize()) { + std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "< using namespace thrust::placeholders; -struct PowOperator{ +struct PowOperator: public thrust::unary_function{ float exponent; PowOperator(float v):exponent(v) {} void setExponent(float v){ @@ -25,7 +25,7 @@ void unaryAdd(float* in1, float* in2, float* out, unsigned long length) void unaryAdd(float* in1, const float& in2, float* out, unsigned long length) { - thrust::transform(thrust::device,in1,in1+length,out,in2*_1); + thrust::transform(thrust::device,in1,in1+length,out,in2 + _1); } void unaryMul(float* in1, float* in2, float* out, unsigned long length) @@ -34,6 +34,11 @@ void unaryMul(float* in1, float* in2, float* out, unsigned long length) thrust::transform(thrust::device,in1,in1+length,in2,out,op); } +void unaryMul(float* in1, const float& in2, float* out, unsigned long length) +{ + thrust::transform(thrust::device,in1, in1+length, out, in2 * _1); +} + void unaryNeg(float* in1, float* out, unsigned long length){ thrust::negate op; thrust::transform(thrust::device,in1,in1+length,out,op); @@ -49,6 +54,23 @@ void unaryDiv(float* in1, float* in2, float* out, unsigned long length){ thrust::transform(thrust::device,in1,in1+length,in2,out,op); } +void unarySub(const float& in1, float* in2, float* out, unsigned long length){ + thrust::transform(thrust::device,in2,in2+length,out,in1-_1); +} + +void unaryDiv(const float& in1, float* in2, float* out, unsigned long length){ + thrust::transform(thrust::device,in2,in2+length,out,in1/_1); + +} + +void unarySub(float* in1, const float& in2, float* out, unsigned long length){ + thrust::transform(thrust::device,in1,in1+length,out,_1-in2); +} + +void unaryDiv(float* in1, const float& in2, float* out, unsigned long length){ + thrust::transform(thrust::device,in1,in1+length,out,_1/in2); +} + void unaryPow(float* in1, float N,float* out, unsigned long length){ if (N == 0.0f) { @@ -65,7 +87,6 @@ void unaryPow(float* in1, float N,float* out, unsigned long length){ thrust::transform(thrust::device,in1,in1+length,out,op); return; } - thrust::transform(thrust::device,in1,in1+length,out,powf(_1,N)); - + thrust::transform(thrust::device,in1,in1+length,out,PowOperator(N)); } diff --git a/src/CudaMatrixPrivate.cuh b/src/CudaMatrixPrivate.cuh index 09348b3..4d8c91f 100644 --- a/src/CudaMatrixPrivate.cuh +++ b/src/CudaMatrixPrivate.cuh @@ -5,11 +5,17 @@ void unaryAdd(float* in1, float* in2, float* out, unsigned long length); void unaryAdd(float* in1, const float& in2, float* out, unsigned long length); void unaryMul(float* in1, float* in2, float* out, unsigned long length); +void unaryMul(float* in1, const float& in2, float* out, unsigned long length); + void unaryNeg(float* in1, float* out, unsigned long length); void unaryPow(float* in1, float N,float* out, unsigned long length); void unarySub(float* in1, float* in2, float* out, unsigned long length); void unaryDiv(float* in1, float* in2, float* out, unsigned long length); +void unarySub(const float& in1, float* in2, float* out, unsigned long length); +void unaryDiv(const float& in1, float* in2, float* out, unsigned long length); +void unarySub(float* in1, const float& in2, float* out, unsigned long length); +void unaryDiv(float* in1, const float& in2, float* out, unsigned long length); #endif // __CUDAMATRIX_H__ \ No newline at end of file diff --git a/src/Function.cpp b/src/Function.cpp index f16ed6a..7fbe5e5 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -3,6 +3,7 @@ // #include "Function.h" +#include //必须在mkl.h和Eigen的头之前，之后 #define MKL_Complex8 std::complex @@ -29,6 +30,17 @@ namespace Aurora { void free(void* ptr){ mkl_free(ptr); } + float* random(size_t length){ + VSLStreamStatePtr stream; + vslNewStream(&stream, VSL_BRNG_MT19937, 1); + float * ret = new float[length]; + float low = -100.0; + float high = 10000.0; + vsRngUniform(VSL_RNG_METHOD_UNIFORM_STD, stream, length, ret, low, high); + // 释放资源 + vslDeleteStream(&stream); + return ret; + } #ifdef USE_CUDA void gpuFree(void* ptr) { diff --git a/src/Function.h b/src/Function.h index 7882dd6..a1c9976 100644 --- a/src/Function.h +++ b/src/Function.h @@ -6,11 +6,13 @@ #define MATLABFUNCTIONS_MATRIXFUNCTIONS_H #include +#include namespace Aurora{ float* malloc(size_t size,bool complex = false); void free(void* ptr); void gpuFree(void* ptr); + float* random(size_t length); }; diff --git a/src/main.cxx b/src/main.cxx index 2476b87..7f602a3 100644 --- a/src/main.cxx +++ b/src/main.cxx @@ -23,17 +23,97 @@ int main() A[i] = -1; B[i] = i; } + printf("Test CudaMatrix operator+(const CudaMatrix &aMatrix) const \r\n"); + //CudaMatrix operator+(const CudaMatrix &aMatrix) const auto C = A+B; auto dA = A.toDeviceMatrix(); auto dB = B.toDeviceMatrix(); - auto dC = (dA+dB).toHostMatrix(); + auto dC = (dA+dB); + auto dhC = dC.toHostMatrix(); for (size_t i = 0; i < 1000; i++) { - if (C[i]!=dC[i]){ - printf("error value i:%zu, value1:%f, value2: %f",i,C[i],dC[i]); + if (C[i]!=dhC[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,C[i],dhC[i]); return 9; } } - + printf("Test CudaMatrix operator+(float aScalar) const \r\n"); + //CudaMatrix operator+(float aScalar) const + auto D = C+0.5; + auto dD = dC+0.5; + auto dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (D[i]!=dhD[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + printf("Test CudaMatrix operator+(float aScalar, const CudaMatrix &aMatrix) \r\n"); + // CudaMatrix operator+(float aScalar, const CudaMatrix &aMatrix) + dD = 0.5 + dC; + dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (D[i]!=dhD[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + printf("Test CudaMatrix &operator+(float aScalar, CudaMatrix &&aMatrix) \r\n"); + // CudaMatrix &operator+(float aScalar, CudaMatrix &&aMatrix) + { + auto dD2 = 0.5 + (dA+dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (D[i]!=dhD[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + } + printf("Test CudaMatrix &operator+(CudaMatrix &&aMatrix, float aScalar) \r\n"); + // CudaMatrix &operator+(CudaMatrix &&aMatrix, float aScalar) + { + + auto dD2 = (dA+dB)+0.5; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (D[i]!=dhD[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + } + //CudaMatrix operator+(CudaMatrix &&aMatrix) const + printf("Test CudaMatrix operator+(CudaMatrix &&aMatrix) const \r\n"); + { + auto D = A+C; + auto dD2 = dA+(dA+dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (C[i]!=dhC[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + } + //CudaMatrix operator+(CudaMatrix &&aMatrix,CudaMatrix &aOther) + printf("Test CudaMatrix operator+(CudaMatrix &&aMatrix,CudaMatrix &aOther) \r\n"); + { + auto D = A+C; + auto dD2 = (dA+dB)+dA; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + if (C[i]!=dhC[i]){ + printf("error value i:%zu, value1:%f, value2: %f",i,D[i],dhD[i]); + return 9; + } + } + } return 0; } diff --git a/test/CudaMatrix_Test.cpp b/test/CudaMatrix_Test.cpp new file mode 100644 index 0000000..157d423 --- /dev/null +++ b/test/CudaMatrix_Test.cpp @@ -0,0 +1,187 @@ +#include +#include "Matrix.h" +#include "CudaMatrix.h" +#include "Function.h" +#include "Function1D.h" +#include "Function2D.h" +#include "Function3D.h" + + +class CudaMatrix_Test : public ::testing::Test { +protected: + static void SetUpCudaMatrixTester() { + + } + + static void TearDownTestCase() { + } + + void SetUp() { + } + + void TearDown() { + } +}; + +TEST_F(CudaMatrix_Test, MatrixAdd) { + auto A = Aurora::zeros(1000,1,1); + auto B = Aurora::zeros(1000,1,1); + for (size_t i = 0; i < 1000; i++) + { + A[i] = -1; + B[i] = i; + } + printf("Test CudaMatrix operator+(const CudaMatrix &aMatrix) const \r\n"); + //CudaMatrix operator+(const CudaMatrix &aMatrix) const + auto C = A+B; + auto dA = A.toDeviceMatrix(); + auto dB = B.toDeviceMatrix(); + auto dC = (dA+dB); + auto dhC = dC.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(C[i],dhC[i]); + } + printf("Test CudaMatrix operator+(float aScalar) const \r\n"); + //CudaMatrix operator+(float aScalar) const + auto D = C+0.5; + auto dD = dC+0.5; + auto dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + printf("Test CudaMatrix operator+(float aScalar, const CudaMatrix &aMatrix) \r\n"); + // CudaMatrix operator+(float aScalar, const CudaMatrix &aMatrix) + dD = 0.5 + dC; + dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + printf("Test CudaMatrix &operator+(float aScalar, CudaMatrix &&aMatrix) \r\n"); + // CudaMatrix &operator+(float aScalar, CudaMatrix &&aMatrix) + { + auto dD2 = 0.5 + (dA+dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } + printf("Test CudaMatrix &operator+(CudaMatrix &&aMatrix, float aScalar) \r\n"); + // CudaMatrix &operator+(CudaMatrix &&aMatrix, float aScalar) + { + + auto dD2 = (dA+dB)+0.5; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } + //CudaMatrix operator+(CudaMatrix &&aMatrix) const + printf("Test CudaMatrix operator+(CudaMatrix &&aMatrix) const \r\n"); + { + auto D = A+C; + auto dD2 = dA+(dA+dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } + //CudaMatrix operator+(CudaMatrix &&aMatrix,CudaMatrix &aOther) + printf("Test CudaMatrix operator+(CudaMatrix &&aMatrix,CudaMatrix &aOther) \r\n"); + { + auto D = A+C; + auto dD2 = (dA+dB)+dA; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } +} + +TEST_F(CudaMatrix_Test, MatrixMul) { + auto A = Aurora::zeros(1000,1,1); + auto B = Aurora::zeros(1000,1,1); + for (size_t i = 0; i < 1000; i++) + { + A[i] = -1; + B[i] = i; + } + printf("Test CudaMatrix operator*(const CudaMatrix &aMatrix) const \r\n"); + //CudaMatrix operator*(const CudaMatrix &aMatrix) const + auto C = A*B; + auto dA = A.toDeviceMatrix(); + auto dB = B.toDeviceMatrix(); + auto dC = (dA*dB); + auto dhC = dC.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(C[i],dhC[i]); + } + printf("Test CudaMatrix operator*(float aScalar) const \r\n"); + //CudaMatrix operator*(float aScalar) const + auto D = C*0.5; + auto dD = dC*0.5; + auto dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + + printf("Test CudaMatrix operator*(float aScalar, const CudaMatrix &aMatrix) \r\n"); + // CudaMatrix operator*(float aScalar, const CudaMatrix &aMatrix) + dD = 0.5 * dC; + dhD = dD.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + printf("Test CudaMatrix &operator*(float aScalar, CudaMatrix &&aMatrix) \r\n"); + // CudaMatrix &operator*(float aScalar, CudaMatrix &&aMatrix) + { + auto dD2 = 0.5 * (dA*dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } + printf("Test CudaMatrix &operator*(CudaMatrix &&aMatrix, float aScalar) \r\n"); + // CudaMatrix &operator*(CudaMatrix &&aMatrix, float aScalar) + { + + auto dD2 = (dA*dB)*0.5; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D[i],dhD[i]); + } + } + //CudaMatrix operator*(CudaMatrix &&aMatrix) const + printf("Test CudaMatrix operator*(CudaMatrix &&aMatrix) const \r\n"); + { + auto D1 = A*C; + auto dD2 = dA*(dA*dB); + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D1[i],dhD[i]); + } + } + //CudaMatrix operator*(CudaMatrix &&aMatrix,CudaMatrix &aOther) + printf("Test CudaMatrix operator*(CudaMatrix &&aMatrix,CudaMatrix &aOther) \r\n"); + { + auto D1 = A*C; + auto dD2 = (dA*dB)*dA; + dhD = dD2.toHostMatrix(); + for (size_t i = 0; i < 1000; i++) + { + ASSERT_FLOAT_EQ(D1[i],dhD[i]); + } + } +} \ No newline at end of file diff --git a/test/Function1D_Test.cpp b/test/Function1D_Test.cpp index d30a1be..fd148ba 100644 --- a/test/Function1D_Test.cpp +++ b/test/Function1D_Test.cpp @@ -27,11 +27,11 @@ protected: }; TEST_F(Function1D_Test,compareSet){ - double * dataA =Aurora::malloc(9); - double * dataB =Aurora::malloc(9); + float * dataA =Aurora::malloc(9); + float * dataB =Aurora::malloc(9); for (int i = 0; i < 9; ++i) { - dataA[i]=(double)(i-3); - dataB[i]=(double)(i+2); + dataA[i]=(float)(i-3); + dataB[i]=(float)(i+2); } Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3); EXPECT_EQ(-3, A[0]); @@ -61,16 +61,16 @@ TEST_F(Function1D_Test,compareSet){ TEST_F(Function1D_Test, sign) { - double * dataA =Aurora::malloc(9); - double * dataB =Aurora::malloc(9); + float * dataA =Aurora::malloc(9); + float * dataB =Aurora::malloc(9); for (int i = 0; i < 9; ++i) { - dataA[i]=(double)(i-3); - dataB[i]=(double)(i+2); + dataA[i]=(float)(i-3); + dataB[i]=(float)(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(); + float * result = C.getData(); EXPECT_EQ(-1, result[0]); EXPECT_EQ(0, result[3]); EXPECT_EQ(1, result[4]); @@ -83,352 +83,352 @@ TEST_F(Function1D_Test, sign) { 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(input,std::default_delete()),std::vector{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); + float* input = new float[10]{1,2,3,4,5,6,7,8,9,10}; + Aurora::Matrix m(std::shared_ptr(input,std::default_delete()),std::vector{10}); + EXPECT_FLOAT_EQ(repmat(m,1,1).getData()[7],8); + EXPECT_FLOAT_EQ(repmat(m,2,3).getDataSize(),60); + EXPECT_FLOAT_EQ(repmat(m,2,3).getData()[22],3); + EXPECT_FLOAT_EQ(repmat(m,2,3).getDimSize(0),20); + EXPECT_FLOAT_EQ(repmat(m,2,3).getDimSize(1),3); + EXPECT_FLOAT_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(input2,std::default_delete()),std::vector{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); + float* input2 = new float[10]{1,2,3,4,5,6,7,8,9,10}; + Aurora::Matrix m2(std::shared_ptr(input2,std::default_delete()),std::vector{5,2}); + EXPECT_FLOAT_EQ(repmat(m2,1,1).getData()[7],8); + EXPECT_FLOAT_EQ(repmat(m2,2,3).getDataSize(),60); + EXPECT_FLOAT_EQ(repmat(m2,2,3).getData()[22],3); + EXPECT_FLOAT_EQ(repmat(m2,2,3).getDimSize(0),10); + EXPECT_FLOAT_EQ(repmat(m2,2,3).getDimSize(1),6); + EXPECT_FLOAT_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(input3,std::default_delete()),std::vector{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); + float* input3 = new float[10]{1,2,3,4,5,6,7,8,9,10}; + Aurora::Matrix m3(std::shared_ptr(input3,std::default_delete()),std::vector{10}); + EXPECT_FLOAT_EQ(repmat(m3,1,1,1).getData()[7],8); + EXPECT_FLOAT_EQ(repmat(m3,2,3,4).getDataSize(),240); + EXPECT_FLOAT_EQ(repmat(m3,2,3,4).getData()[22],3); + EXPECT_FLOAT_EQ(repmat(m3,2,3,4).getDimSize(0),20); + EXPECT_FLOAT_EQ(repmat(m3,2,3,4).getDimSize(1),3); + EXPECT_FLOAT_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(input4,std::default_delete()),std::vector{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); + float* input4 = new float[10]{1,2,3,4,5,6,7,8,9,10}; + Aurora::Matrix m4(std::shared_ptr(input4,std::default_delete()),std::vector{5,2}); + EXPECT_FLOAT_EQ(repmat(m4,1,1).getData()[7],8); + EXPECT_FLOAT_EQ(repmat(m4,2,3,4).getDataSize(),240); + EXPECT_FLOAT_EQ(repmat(m4,2,3,4).getData()[22],3); + EXPECT_FLOAT_EQ(repmat(m4,2,3,4).getDimSize(0),10); + EXPECT_FLOAT_EQ(repmat(m4,2,3,4).getDimSize(1),6); + EXPECT_FLOAT_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(xD,std::default_delete()),std::vector{5}); - double* yD= new double[5]{1,4,9,16,25}; - Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); - double* x1D= new double[3]{1.22,2.69,3.84}; - Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); + float* xD= new float[5]{1,2,3,4,5}; + Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{5}); + float* yD= new float[5]{1,4,9,16,25}; + Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); + float* x1D= new float[3]{1.22,2.69,3.84}; + Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{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); + EXPECT_FLOAT_EQ(result.getData()[0],1.4884); + EXPECT_FLOAT_EQ(result.getData()[1],7.2361); + EXPECT_FLOAT_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); + EXPECT_FLOAT_EQ(result.getData()[0],1.66); + EXPECT_FLOAT_EQ(result.getData()[1],7.45); + EXPECT_FLOAT_EQ(result.getData()[2],14.88); } TEST_F(Function1D_Test, polyval){ - // double *dataP = new double[3]{3,2,1}; - double *dataP = new double[6]{2.78786e-9, -1.398845e-6, 3.287156e-4, -5.799136e-2, 5.038813, 1.402385e3}; - // double *dataX = new double[3]{5,7,9}; - double *dataX = new double[1]{24.570274572648690}; + // float *dataP = new float[3]{3,2,1}; + float *dataP = new float[6]{2.78786e-9, -1.398845e-6, 3.287156e-4, -5.799136e-2, 5.038813, 1.402385e3}; + // float *dataX = new float[3]{5,7,9}; + float *dataX = new float[1]{24.570274572648690}; auto matrixP = Aurora::Matrix::fromRawData(dataP,6); auto matrixX = Aurora::Matrix::fromRawData(dataX,1); auto result = Aurora::polyval(matrixP,matrixX); - EXPECT_DOUBLE_EQ(1495.5717310876246, result.getData()[0]); - // EXPECT_DOUBLE_EQ(162., result.getData()[1]); - // EXPECT_DOUBLE_EQ(262., result.getData()[2]); + EXPECT_FLOAT_EQ(1495.5717310876246, result.getData()[0]); + // EXPECT_FLOAT_EQ(162., result.getData()[1]); + // EXPECT_FLOAT_EQ(262., result.getData()[2]); } TEST_F(Function1D_Test, complexAndEtc){ //complex { - double *dataP =new double[8]{3,2,1,6, 7, 8 , 19, 13}; + float *dataP =new float[8]{3,2,1,6, 7, 8 , 19, 13}; auto matrixAN = Aurora::Matrix::fromRawData(dataP,2,4); auto matrixBC = Aurora::complex(matrixAN); EXPECT_EQ(8, matrixBC.getDataSize()); EXPECT_EQ(Aurora::Complex, matrixBC.getValueType()); - EXPECT_DOUBLE_EQ(3, matrixBC.getData()[0]); - EXPECT_DOUBLE_EQ(0, matrixBC.getData()[3]); + EXPECT_FLOAT_EQ(3, matrixBC.getData()[0]); + EXPECT_FLOAT_EQ(0, matrixBC.getData()[3]); } //complex & real & imag { - double *dataP =new double[8]{3,2,1,6, 7, 8 , 19, 13}; + float *dataP =new float[8]{3,2,1,6, 7, 8 , 19, 13}; auto matrixAC = Aurora::Matrix::fromRawData(dataP,2,2,0,Aurora::Complex); auto matrixCN = Aurora::real(matrixAC); EXPECT_EQ(4, matrixCN.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixCN.getValueType()); - EXPECT_DOUBLE_EQ(3, matrixCN.getData()[0]); - EXPECT_DOUBLE_EQ(19, matrixCN.getData()[3]); + EXPECT_FLOAT_EQ(3, matrixCN.getData()[0]); + EXPECT_FLOAT_EQ(19, matrixCN.getData()[3]); auto matrixDN = Aurora::imag(matrixAC); EXPECT_EQ(4, matrixDN.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixDN.getValueType()); - EXPECT_DOUBLE_EQ(2, matrixDN.getData()[0]); - EXPECT_DOUBLE_EQ(13, matrixDN.getData()[3]); + EXPECT_FLOAT_EQ(2, matrixDN.getData()[0]); + EXPECT_FLOAT_EQ(13, matrixDN.getData()[3]); } } TEST_F(Function1D_Test, ceilAndRound) { - double *dataP = new double[3]{3.1, 2.5, 1.8}; + float *dataP = new float[3]{3.1, 2.5, 1.8}; auto matrixA = Aurora::Matrix::fromRawData(dataP, 3); auto matrixB = Aurora::ceil(matrixA); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(4, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(3, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[2]); + EXPECT_FLOAT_EQ(4, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(3, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[2]); matrixB = Aurora::ceil(matrixA * 0.5) ; EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[2]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(1, matrixB.getData()[2]); matrixB = Aurora::round(matrixA); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(3, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(3, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[2]); + EXPECT_FLOAT_EQ(3, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(3, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[2]); matrixB = Aurora::round(matrixA * 0.5); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[2]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(1, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(1, matrixB.getData()[2]); } TEST_F(Function1D_Test, absAndSqrt) { - double *dataP = new double[3]{1, 4, -3}; + float *dataP = new float[3]{1, 4, -3}; auto matrixA = Aurora::Matrix::fromRawData(dataP, 3); auto matrixB = Aurora::abs(matrixA); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(4, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(3, matrixB.getData()[2]); + EXPECT_FLOAT_EQ(1, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(4, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(3, matrixB.getData()[2]); matrixB = Aurora::sqrt(matrixB); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(1.7321, fourDecimalRound(matrixB.getData()[2])); + EXPECT_FLOAT_EQ(1, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(1.7321, fourDecimalRound(matrixB.getData()[2])); matrixB = Aurora::sqrt(Aurora::abs(matrixA*-1)); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[1]); - EXPECT_DOUBLE_EQ(1.7321, fourDecimalRound(matrixB.getData()[2])); + EXPECT_FLOAT_EQ(1, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(1.7321, fourDecimalRound(matrixB.getData()[2])); matrixB = Aurora::sqrt(matrixA); EXPECT_EQ(3, matrixB.getDataSize()); EXPECT_EQ(Aurora::Normal, matrixB.getValueType()); - EXPECT_DOUBLE_EQ(1, matrixB.getData()[0]); - EXPECT_DOUBLE_EQ(2, matrixB.getData()[1]); + EXPECT_FLOAT_EQ(1, matrixB.getData()[0]); + EXPECT_FLOAT_EQ(2, matrixB.getData()[1]); EXPECT_TRUE(isnanf(matrixB.getData()[2])); } TEST_F(Function1D_Test, log) { - double *dataP = new double[3]{1, 4, 6}; + float *dataP = new float[3]{1, 4, 6}; auto matrixA = Aurora::Matrix::fromRawData(dataP, 3); auto result = Aurora::log(matrixA); - EXPECT_DOUBLE_AE(result.getData()[0],0); - EXPECT_DOUBLE_AE(result.getData()[1],1.3863); - EXPECT_DOUBLE_AE(result.getData()[2],1.7918); + EXPECT_FLOAT_AE(result.getData()[0],0); + EXPECT_FLOAT_AE(result.getData()[1],1.3863); + EXPECT_FLOAT_AE(result.getData()[2],1.7918); result = Aurora::log(matrixA,10); - EXPECT_DOUBLE_AE(result.getData()[0],0); - EXPECT_DOUBLE_AE(result.getData()[1],0.6021); - EXPECT_DOUBLE_AE(result.getData()[2],0.7782); + EXPECT_FLOAT_AE(result.getData()[0],0); + EXPECT_FLOAT_AE(result.getData()[1],0.6021); + EXPECT_FLOAT_AE(result.getData()[2],0.7782); } TEST_F(Function1D_Test, exp) { - double *data1 = new double[4]{1,2,3,4}; + float *data1 = new float[4]{1,2,3,4}; auto matrix1 = Aurora::Matrix::fromRawData(data1, 4,1,1); auto result = Aurora::exp(matrix1); - EXPECT_DOUBLE_AE(result.getData()[0],2.7183); - EXPECT_DOUBLE_AE(result.getData()[1],7.3891); - EXPECT_DOUBLE_AE(result.getData()[2],20.0855); - EXPECT_DOUBLE_AE(result.getData()[3],54.5982); + EXPECT_FLOAT_AE(result.getData()[0],2.7183); + EXPECT_FLOAT_AE(result.getData()[1],7.3891); + EXPECT_FLOAT_AE(result.getData()[2],20.0855); + EXPECT_FLOAT_AE(result.getData()[3],54.5982); - double *data2 = new double[4]{1,2,3,4}; + float *data2 = new float[4]{1,2,3,4}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 2,1,1,Aurora::Complex); result = Aurora::exp(matrix2); - EXPECT_DOUBLE_AE(result.getData()[0],-1.1312); - EXPECT_DOUBLE_AE(result.getData()[1],2.4717); - EXPECT_DOUBLE_AE(result.getData()[2],-13.1288); - EXPECT_DOUBLE_AE(result.getData()[3],-15.2008); + EXPECT_FLOAT_AE(result.getData()[0],-1.1312); + EXPECT_FLOAT_AE(result.getData()[1],2.4717); + EXPECT_FLOAT_AE(result.getData()[2],-13.1288); + EXPECT_FLOAT_AE(result.getData()[3],-15.2008); } TEST_F(Function1D_Test, mod) { - double *data = new double[3]{1.22,3.23,23.2}; + float *data = new float[3]{1.22,3.23,23.2}; auto matrix = Aurora::Matrix::fromRawData(data, 3); auto result = Aurora::mod(matrix,1.2); - EXPECT_DOUBLE_AE(result.getData()[0],0.02); - EXPECT_DOUBLE_AE(result.getData()[1],0.83); - EXPECT_DOUBLE_AE(result.getData()[2],0.4); + EXPECT_FLOAT_AE(result.getData()[0],0.02); + EXPECT_FLOAT_AE(result.getData()[1],0.83); + EXPECT_FLOAT_AE(result.getData()[2],0.4); } TEST_F(Function1D_Test, acos) { - double *data = new double[3]{0.02,0.83,0.4,}; + float *data = new float[3]{0.02,0.83,0.4,}; auto matrix = Aurora::Matrix::fromRawData(data, 3); auto result = Aurora::acos(matrix); - EXPECT_DOUBLE_AE(result.getData()[0],1.5508); - EXPECT_DOUBLE_AE(result.getData()[1],0.5917); - EXPECT_DOUBLE_AE(result.getData()[2],1.1593); + EXPECT_FLOAT_AE(result.getData()[0],1.5508); + EXPECT_FLOAT_AE(result.getData()[1],0.5917); + EXPECT_FLOAT_AE(result.getData()[2],1.1593); } TEST_F(Function1D_Test, acosd) { - double *data = new double[3]{0.02,0.83,0.4,}; + float *data = new float[3]{0.02,0.83,0.4,}; auto matrix = Aurora::Matrix::fromRawData(data, 3); auto result = Aurora::acosd(matrix); - EXPECT_DOUBLE_AE(result.getData()[0],88.854); - EXPECT_DOUBLE_AE(result.getData()[1],33.9013); - EXPECT_DOUBLE_AE(result.getData()[2],66.4218); + EXPECT_FLOAT_AE(result.getData()[0],88.854); + EXPECT_FLOAT_AE(result.getData()[1],33.9013); + EXPECT_FLOAT_AE(result.getData()[2],66.4218); } TEST_F(Function1D_Test, conj) { - double *data = new double[6]{0.02,1,0.83,-1,0.4,2}; + float *data = new float[6]{0.02,1,0.83,-1,0.4,2}; auto matrix = Aurora::Matrix::fromRawData(data, 3,1,1,Aurora::Complex); auto result = Aurora::conj(matrix); - EXPECT_DOUBLE_AE(result.getData()[0],0.02); - EXPECT_DOUBLE_AE(result.getData()[1],-1); - EXPECT_DOUBLE_AE(result.getData()[2],0.83); - EXPECT_DOUBLE_AE(result.getData()[3],1); - EXPECT_DOUBLE_AE(result.getData()[4],0.4); - EXPECT_DOUBLE_AE(result.getData()[5],-2); - EXPECT_DOUBLE_AE((double)result.getValueType(), (double)Aurora::Complex); + EXPECT_FLOAT_AE(result.getData()[0],0.02); + EXPECT_FLOAT_AE(result.getData()[1],-1); + EXPECT_FLOAT_AE(result.getData()[2],0.83); + EXPECT_FLOAT_AE(result.getData()[3],1); + EXPECT_FLOAT_AE(result.getData()[4],0.4); + EXPECT_FLOAT_AE(result.getData()[5],-2); + EXPECT_FLOAT_AE((float)result.getValueType(), (float)Aurora::Complex); - data = new double[6]{0.02,1,0.83,-1,0.4,2}; + data = new float[6]{0.02,1,0.83,-1,0.4,2}; matrix = Aurora::Matrix::fromRawData(data, 6,1,1); result = Aurora::conj(matrix); - EXPECT_DOUBLE_AE(result.getData()[0],0.02); - EXPECT_DOUBLE_AE(result.getData()[1],1); - EXPECT_DOUBLE_AE(result.getData()[2],0.83); - EXPECT_DOUBLE_AE(result.getData()[3],-1); - EXPECT_DOUBLE_AE(result.getData()[4],0.4); - EXPECT_DOUBLE_AE(result.getData()[5],2); - EXPECT_DOUBLE_AE((double)result.getValueType(), (double)Aurora::Normal); + EXPECT_FLOAT_AE(result.getData()[0],0.02); + EXPECT_FLOAT_AE(result.getData()[1],1); + EXPECT_FLOAT_AE(result.getData()[2],0.83); + EXPECT_FLOAT_AE(result.getData()[3],-1); + EXPECT_FLOAT_AE(result.getData()[4],0.4); + EXPECT_FLOAT_AE(result.getData()[5],2); + EXPECT_FLOAT_AE((float)result.getValueType(), (float)Aurora::Normal); } TEST_F(Function1D_Test, norm) { //1Dim - double *data = new double[3]{1,2,-3}; + float *data = new float[3]{1,2,-3}; auto matrix = Aurora::Matrix::fromRawData(data, 3); auto result = Aurora::norm(matrix,Aurora::NormMethod::Norm1); - EXPECT_DOUBLE_AE(result,6); + EXPECT_FLOAT_AE(result,6); result = Aurora::norm(matrix,Aurora::NormMethod::Norm2); - EXPECT_DOUBLE_AE(result,3.74166); + EXPECT_FLOAT_AE(result,3.74166); result = Aurora::norm(matrix,Aurora::NormMethod::NormF); - EXPECT_DOUBLE_AE(result,3.74166); + EXPECT_FLOAT_AE(result,3.74166); //2Dims - data = new double[8]{1,2,-3,6,7,9,22.3,-8.6}; + data = new float[8]{1,2,-3,6,7,9,22.3,-8.6}; matrix = Aurora::Matrix::fromRawData(data, 4,2); result = Aurora::norm(matrix,Aurora::NormMethod::Norm1); - EXPECT_DOUBLE_AE(result,46.9); + EXPECT_FLOAT_AE(result,46.9); result = Aurora::norm(matrix,Aurora::NormMethod::Norm2); - EXPECT_DOUBLE_AE(result,26.7284); + EXPECT_FLOAT_AE(result,26.7284); result = Aurora::norm(matrix,Aurora::NormMethod::NormF); - EXPECT_DOUBLE_AE(result,27.4089); + EXPECT_FLOAT_AE(result,27.4089); //1Dim Complex - data = new double[6]{1,2,-3,4,5,-6}; + data = new float[6]{1,2,-3,4,5,-6}; matrix = Aurora::Matrix::fromRawData(data, 3,1,1,Aurora::Complex); result = Aurora::norm(matrix,Aurora::NormMethod::Norm1); - EXPECT_DOUBLE_AE(result,15.0463); + EXPECT_FLOAT_AE(result,15.0463); result = Aurora::norm(matrix,Aurora::NormMethod::Norm2); - EXPECT_DOUBLE_AE(result,9.5394); + EXPECT_FLOAT_AE(result,9.5394); result = Aurora::norm(matrix,Aurora::NormMethod::NormF); - EXPECT_DOUBLE_AE(result,9.5394); + EXPECT_FLOAT_AE(result,9.5394); //2Dims Complex - data = new double[12]{1,2,-3,4,5,-6,7,8,9,22,24,25}; + data = new float[12]{1,2,-3,4,5,-6,7,8,9,22,24,25}; matrix = Aurora::Matrix::fromRawData(data, 3,2,1,Aurora::Complex); result = Aurora::norm(matrix,Aurora::NormMethod::Norm1); - EXPECT_DOUBLE_AE(result,69.0553); + EXPECT_FLOAT_AE(result,69.0553); result = Aurora::norm(matrix,Aurora::NormMethod::Norm2); - EXPECT_DOUBLE_AE(result,43.5314); + EXPECT_FLOAT_AE(result,43.5314); result = Aurora::norm(matrix,Aurora::NormMethod::NormF); - EXPECT_DOUBLE_AE(result,44.3847); + EXPECT_FLOAT_AE(result,44.3847); } TEST_F(Function1D_Test, transpose) { - double *data = new double[6]{1,2,3,4,5,6}; + float *data = new float[6]{1,2,3,4,5,6}; auto matrix = Aurora::Matrix::fromRawData(data, 3,2); auto result = Aurora::transpose(matrix); - EXPECT_DOUBLE_EQ(result.getData()[0],1); - EXPECT_DOUBLE_EQ(result.getData()[1],4); - EXPECT_DOUBLE_EQ(result.getData()[2],2); - EXPECT_DOUBLE_EQ(result.getData()[3],5); - EXPECT_DOUBLE_EQ(result.getData()[4],3); - EXPECT_DOUBLE_EQ(result.getData()[5],6); - EXPECT_DOUBLE_EQ(result.getDimSize(0),2); - EXPECT_DOUBLE_EQ(result.getDimSize(1),3); + EXPECT_FLOAT_EQ(result.getData()[0],1); + EXPECT_FLOAT_EQ(result.getData()[1],4); + EXPECT_FLOAT_EQ(result.getData()[2],2); + EXPECT_FLOAT_EQ(result.getData()[3],5); + EXPECT_FLOAT_EQ(result.getData()[4],3); + EXPECT_FLOAT_EQ(result.getData()[5],6); + EXPECT_FLOAT_EQ(result.getDimSize(0),2); + EXPECT_FLOAT_EQ(result.getDimSize(1),3); - data = new double[12]{1,2,3,4,5,6,7,8,9,10,11,12}; + data = new float[12]{1,2,3,4,5,6,7,8,9,10,11,12}; matrix = Aurora::Matrix::fromRawData(data, 3,2,1,Aurora::Complex); result = Aurora::transpose(matrix); - EXPECT_DOUBLE_EQ(result.getData()[0],1); - EXPECT_DOUBLE_EQ(result.getData()[1],2); - EXPECT_DOUBLE_EQ(result.getData()[2],7); - EXPECT_DOUBLE_EQ(result.getData()[3],8); - EXPECT_DOUBLE_EQ(result.getData()[4],3); - EXPECT_DOUBLE_EQ(result.getData()[5],4); - EXPECT_DOUBLE_EQ(result.getData()[6],9); - EXPECT_DOUBLE_EQ(result.getData()[7],10); - EXPECT_DOUBLE_EQ(result.getData()[8],5); - EXPECT_DOUBLE_EQ(result.getData()[9],6); - EXPECT_DOUBLE_EQ(result.getData()[10],11); - EXPECT_DOUBLE_EQ(result.getData()[11],12); - EXPECT_DOUBLE_EQ(result.getDimSize(0),2); - EXPECT_DOUBLE_EQ(result.getDimSize(1),3); - EXPECT_DOUBLE_EQ(result.getDimSize(0),2); - EXPECT_DOUBLE_EQ(result.getDimSize(1),3); + EXPECT_FLOAT_EQ(result.getData()[0],1); + EXPECT_FLOAT_EQ(result.getData()[1],2); + EXPECT_FLOAT_EQ(result.getData()[2],7); + EXPECT_FLOAT_EQ(result.getData()[3],8); + EXPECT_FLOAT_EQ(result.getData()[4],3); + EXPECT_FLOAT_EQ(result.getData()[5],4); + EXPECT_FLOAT_EQ(result.getData()[6],9); + EXPECT_FLOAT_EQ(result.getData()[7],10); + EXPECT_FLOAT_EQ(result.getData()[8],5); + EXPECT_FLOAT_EQ(result.getData()[9],6); + EXPECT_FLOAT_EQ(result.getData()[10],11); + EXPECT_FLOAT_EQ(result.getData()[11],12); + EXPECT_FLOAT_EQ(result.getDimSize(0),2); + EXPECT_FLOAT_EQ(result.getDimSize(1),3); + EXPECT_FLOAT_EQ(result.getDimSize(0),2); + EXPECT_FLOAT_EQ(result.getDimSize(1),3); } TEST_F(Function1D_Test, horzcat) { - double *data1 = new double[6]{1,2,3,4,5,6}; + float *data1 = new float[6]{1,2,3,4,5,6}; auto matrix1 = Aurora::Matrix::fromRawData(data1, 3,2); - double *data2 = new double[9]{7,8,9,10,11,12,13,14,15}; + float *data2 = new float[9]{7,8,9,10,11,12,13,14,15}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 3,3); auto result = Aurora::horzcat(matrix1,matrix2); - EXPECT_DOUBLE_EQ(result.getData()[0],1); - EXPECT_DOUBLE_EQ(result.getData()[1],2); - EXPECT_DOUBLE_EQ(result.getData()[10],11); - EXPECT_DOUBLE_EQ(result.getData()[14],15); - EXPECT_DOUBLE_EQ(result.getDimSize(0),3); - EXPECT_DOUBLE_EQ(result.getDimSize(1),5); + EXPECT_FLOAT_EQ(result.getData()[0],1); + EXPECT_FLOAT_EQ(result.getData()[1],2); + EXPECT_FLOAT_EQ(result.getData()[10],11); + EXPECT_FLOAT_EQ(result.getData()[14],15); + EXPECT_FLOAT_EQ(result.getDimSize(0),3); + EXPECT_FLOAT_EQ(result.getDimSize(1),5); - data1 = new double[6]{1,2,3,4,5,6}; + data1 = new float[6]{1,2,3,4,5,6}; matrix1 = Aurora::Matrix::fromRawData(data1, 3,1,1,Aurora::Complex); - data2 = new double[6]{7,8,9,10,11,12}; + data2 = new float[6]{7,8,9,10,11,12}; matrix2 = Aurora::Matrix::fromRawData(data2, 3,1,1,Aurora::Complex); result = Aurora::horzcat(matrix1,matrix2); - EXPECT_DOUBLE_EQ(result.getData()[0],1); - EXPECT_DOUBLE_EQ(result.getData()[1],2); - EXPECT_DOUBLE_EQ(result.getData()[8],5); - EXPECT_DOUBLE_EQ(result.getData()[9],6); - EXPECT_DOUBLE_EQ(result.getDimSize(0),3); - EXPECT_DOUBLE_EQ(result.getDimSize(1),2); + EXPECT_FLOAT_EQ(result.getData()[0],1); + EXPECT_FLOAT_EQ(result.getData()[1],2); + EXPECT_FLOAT_EQ(result.getData()[8],5); + EXPECT_FLOAT_EQ(result.getData()[9],6); + EXPECT_FLOAT_EQ(result.getDimSize(0),3); + EXPECT_FLOAT_EQ(result.getDimSize(1),2); auto A = Aurora::Matrix::New(Aurora::random(27),3,3,3); auto B = Aurora::Matrix::New(Aurora::random(18),3,2,3); @@ -444,125 +444,125 @@ TEST_F(Function1D_Test, horzcat) { } TEST_F(Function1D_Test, vertcat) { - double *data1 = new double[6]{1,2,3,4,5,6}; + float *data1 = new float[6]{1,2,3,4,5,6}; auto matrix1 = Aurora::Matrix::fromRawData(data1, 2,3); - double *data2 = new double[9]{7,8,9,10,11,12,13,14,15}; + float *data2 = new float[9]{7,8,9,10,11,12,13,14,15}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 3,3); auto result = Aurora::vertcat(matrix1,matrix2); - EXPECT_DOUBLE_EQ(result.getData()[0],1); - EXPECT_DOUBLE_EQ(result.getData()[1],2); - EXPECT_DOUBLE_EQ(result.getData()[5],3); - EXPECT_DOUBLE_EQ(result.getData()[8],11); - EXPECT_DOUBLE_EQ(result.getDimSize(0),5); - EXPECT_DOUBLE_EQ(result.getDimSize(1),3); + EXPECT_FLOAT_EQ(result.getData()[0],1); + EXPECT_FLOAT_EQ(result.getData()[1],2); + EXPECT_FLOAT_EQ(result.getData()[5],3); + EXPECT_FLOAT_EQ(result.getData()[8],11); + EXPECT_FLOAT_EQ(result.getDimSize(0),5); + EXPECT_FLOAT_EQ(result.getDimSize(1),3); } TEST_F(Function1D_Test, vecnrom) { //1Dim - double *data = new double[3]{1,2,-3}; + float *data = new float[3]{1,2,-3}; auto matrix = Aurora::Matrix::fromRawData(data, 3); auto result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm1,1); - EXPECT_DOUBLE_AE(result.getData()[0],6); + EXPECT_FLOAT_AE(result.getData()[0],6); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm2,1); - EXPECT_DOUBLE_AE(result.getData()[0],3.74166); + EXPECT_FLOAT_AE(result.getData()[0],3.74166); //2Dims - data = new double[8]{1,2,-3,6,7,9,22.3,-8.6}; + data = new float[8]{1,2,-3,6,7,9,22.3,-8.6}; matrix = Aurora::Matrix::fromRawData(data, 4,2); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm1,1); - EXPECT_DOUBLE_AE(result.getData()[0],12); - EXPECT_DOUBLE_AE(result.getData()[1],46.9); + EXPECT_FLOAT_AE(result.getData()[0],12); + EXPECT_FLOAT_AE(result.getData()[1],46.9); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm2,1); - EXPECT_DOUBLE_AE(result.getData()[0],7.0711); - EXPECT_DOUBLE_AE(result.getData()[1],26.4811); + EXPECT_FLOAT_AE(result.getData()[0],7.0711); + EXPECT_FLOAT_AE(result.getData()[1],26.4811); //1Dim Complex - data = new double[6]{1,2,-3,4,5,-6}; + data = new float[6]{1,2,-3,4,5,-6}; matrix = Aurora::Matrix::fromRawData(data, 3,1,1,Aurora::Complex); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm1,1); - EXPECT_DOUBLE_AE(result.getData()[0],15.0463); + EXPECT_FLOAT_AE(result.getData()[0],15.0463); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm2,1); - EXPECT_DOUBLE_AE(result.getData()[0],9.5394); + EXPECT_FLOAT_AE(result.getData()[0],9.5394); //2Dims Complex - data = new double[12]{1,2,-3,4,5,-6,7,8,9,22,24,25}; + data = new float[12]{1,2,-3,4,5,-6,7,8,9,22,24,25}; matrix = Aurora::Matrix::fromRawData(data, 3,2,1,Aurora::Complex); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm1,1); - EXPECT_DOUBLE_AE(result.getData()[0],15.0463); - EXPECT_DOUBLE_AE(result.getData()[1],69.0553); + EXPECT_FLOAT_AE(result.getData()[0],15.0463); + EXPECT_FLOAT_AE(result.getData()[1],69.0553); result = Aurora::vecnorm(matrix,Aurora::NormMethod::Norm2,1); - EXPECT_DOUBLE_AE(result.getData()[0],9.5394); - EXPECT_DOUBLE_AE(result.getData()[1],43.3474); + EXPECT_FLOAT_AE(result.getData()[0],9.5394); + EXPECT_FLOAT_AE(result.getData()[1],43.3474); } TEST_F(Function1D_Test, linspace) { auto result = Aurora::linspace(-5,5,7); - EXPECT_DOUBLE_AE(result.getData()[0],-5); - EXPECT_DOUBLE_AE(result.getData()[1],-3.3333); - EXPECT_DOUBLE_AE(result.getData()[2],-1.6667); - EXPECT_DOUBLE_AE(result.getData()[3],0); - EXPECT_DOUBLE_AE(result.getData()[4],1.6667); - EXPECT_DOUBLE_AE(result.getData()[5], 3.3333); - EXPECT_DOUBLE_AE(result.getData()[6], 5.0000); + EXPECT_FLOAT_AE(result.getData()[0],-5); + EXPECT_FLOAT_AE(result.getData()[1],-3.3333); + EXPECT_FLOAT_AE(result.getData()[2],-1.6667); + EXPECT_FLOAT_AE(result.getData()[3],0); + EXPECT_FLOAT_AE(result.getData()[4],1.6667); + EXPECT_FLOAT_AE(result.getData()[5], 3.3333); + EXPECT_FLOAT_AE(result.getData()[6], 5.0000); } TEST_F(Function1D_Test, auroraUnion) { - double* data1 = new double[9]{3,3,2,2,2,1,4,4,7}; + float* data1 = new float[9]{3,3,2,2,2,1,4,4,7}; auto matrix1 = Aurora::Matrix::fromRawData(data1, 9,1,1); - double* data2 = new double[8]{6,6,7,7,8,1,2}; + float* data2 = new float[8]{6,6,7,7,8,1,2}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 7,1,1); auto result = Aurora::auroraUnion(matrix1, matrix2); - EXPECT_DOUBLE_AE(result.getData()[0],1); - EXPECT_DOUBLE_AE(result.getData()[1],2); - EXPECT_DOUBLE_AE(result.getData()[2],3); - EXPECT_DOUBLE_AE(result.getData()[3],4); - EXPECT_DOUBLE_AE(result.getData()[4],6); - EXPECT_DOUBLE_AE(result.getData()[5],7); - EXPECT_DOUBLE_AE(result.getData()[6],8); + EXPECT_FLOAT_AE(result.getData()[0],1); + EXPECT_FLOAT_AE(result.getData()[1],2); + EXPECT_FLOAT_AE(result.getData()[2],3); + EXPECT_FLOAT_AE(result.getData()[3],4); + EXPECT_FLOAT_AE(result.getData()[4],6); + EXPECT_FLOAT_AE(result.getData()[5],7); + EXPECT_FLOAT_AE(result.getData()[6],8); } TEST_F(Function1D_Test, intersect) { - double* data1 = new double[9]{3,3,2,2,2,1,4,4,7}; + float* data1 = new float[9]{3,3,2,2,2,1,4,4,7}; auto matrix1 = Aurora::Matrix::fromRawData(data1, 9,1,1); - double* data2 = new double[8]{6,6,7,7,8,1,2}; + float* data2 = new float[8]{6,6,7,7,8,1,2}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 7,1,1); auto result = Aurora::intersect(matrix1, matrix2); - EXPECT_DOUBLE_AE(result.getData()[0],1); - EXPECT_DOUBLE_AE(result.getData()[1],2); - EXPECT_DOUBLE_AE(result.getData()[2],7); + EXPECT_FLOAT_AE(result.getData()[0],1); + EXPECT_FLOAT_AE(result.getData()[1],2); + EXPECT_FLOAT_AE(result.getData()[2],7); Aurora::Matrix ia; result = Aurora::intersect(matrix1, matrix2, ia); - EXPECT_DOUBLE_AE(result.getData()[0],1); - EXPECT_DOUBLE_AE(result.getData()[1],2); - EXPECT_DOUBLE_AE(result.getData()[2],7); - EXPECT_DOUBLE_AE(ia.getData()[0],6); - EXPECT_DOUBLE_AE(ia.getData()[1],3); - EXPECT_DOUBLE_AE(ia.getData()[2],9); + EXPECT_FLOAT_AE(result.getData()[0],1); + EXPECT_FLOAT_AE(result.getData()[1],2); + EXPECT_FLOAT_AE(result.getData()[2],7); + EXPECT_FLOAT_AE(ia.getData()[0],6); + EXPECT_FLOAT_AE(ia.getData()[1],3); + EXPECT_FLOAT_AE(ia.getData()[2],9); } TEST_F(Function1D_Test, reshape) { - double* data = new double[9]{3,3,2,2,2,1,4,4,7}; + float* data = new float[9]{3,3,2,2,2,1,4,4,7}; auto matrix = Aurora::Matrix::fromRawData(data, 9,1,1); auto result = Aurora::reshape(matrix,3,3,1); - EXPECT_DOUBLE_AE(result.getDimSize(0),3); - EXPECT_DOUBLE_AE(result.getDimSize(1),3); - EXPECT_DOUBLE_AE(result.getDimSize(2),1); + EXPECT_FLOAT_AE(result.getDimSize(0),3); + EXPECT_FLOAT_AE(result.getDimSize(1),3); + EXPECT_FLOAT_AE(result.getDimSize(2),1); result = Aurora::reshape(matrix,3,1,3); - EXPECT_DOUBLE_AE(result.getDimSize(0),3); - EXPECT_DOUBLE_AE(result.getDimSize(1),1); - EXPECT_DOUBLE_AE(result.getDimSize(2),3); + EXPECT_FLOAT_AE(result.getDimSize(0),3); + EXPECT_FLOAT_AE(result.getDimSize(1),1); + EXPECT_FLOAT_AE(result.getDimSize(2),3); result = Aurora::reshape(matrix,1,3,3); - EXPECT_DOUBLE_AE(result.getDimSize(0),1); - EXPECT_DOUBLE_AE(result.getDimSize(1),3); - EXPECT_DOUBLE_AE(result.getDimSize(2),3); + EXPECT_FLOAT_AE(result.getDimSize(0),1); + EXPECT_FLOAT_AE(result.getDimSize(1),3); + EXPECT_FLOAT_AE(result.getDimSize(2),3); } TEST_F(Function1D_Test, padding) { - double *input = new double[18]{10,2,1,3,4,4,16,3,1,2,15,-2,1,-3,4,-4,1,-3}; + float *input = new float[18]{10,2,1,3,4,4,16,3,1,2,15,-2,1,-3,4,-4,1,-3}; auto ma = Aurora::Matrix::fromRawData(input,18,1,1); Aurora::padding(ma,20,1); auto result = ma.getData(); @@ -586,33 +586,33 @@ TEST_F(Function1D_Test, convertfp16tofloat) { } TEST_F(Function1D_Test, nanAndFinite){ - double n=std::nan(""); - double infinite=std::numeric_limits::infinity(); + float n=std::nan(""); + float infinite=std::numeric_limits::infinity(); - double* data = new double[9]{infinite,3,n,2,2,1,4,4,7}; + float* data = new float[9]{infinite,3,n,2,2,1,4,4,7}; auto matrix = Aurora::Matrix::fromRawData(data, 9,1,1); auto r = Aurora::isnan(matrix); - EXPECT_DOUBLE_EQ(r.getData()[0],0); - EXPECT_DOUBLE_EQ(r.getData()[1],0); - EXPECT_DOUBLE_EQ(r.getData()[2],1); + EXPECT_FLOAT_EQ(r.getData()[0],0); + EXPECT_FLOAT_EQ(r.getData()[1],0); + EXPECT_FLOAT_EQ(r.getData()[2],1); r = Aurora::isfinite(matrix); - EXPECT_DOUBLE_EQ(r.getData()[0],0); - EXPECT_DOUBLE_EQ(r.getData()[1],1); - EXPECT_DOUBLE_EQ(r.getData()[2],0); + EXPECT_FLOAT_EQ(r.getData()[0],0); + EXPECT_FLOAT_EQ(r.getData()[1],1); + EXPECT_FLOAT_EQ(r.getData()[2],0); Aurora::nantoval(matrix,1); - EXPECT_DOUBLE_EQ(matrix.getData()[2],1); + EXPECT_FLOAT_EQ(matrix.getData()[2],1); - double* data2 = new double[1]{n}; + float* data2 = new float[1]{n}; auto matrix2 = Aurora::Matrix::fromRawData(data2, 1,1,1); r = Aurora::isnan(matrix2); - EXPECT_DOUBLE_EQ(r.getData()[0],1); + EXPECT_FLOAT_EQ(r.getData()[0],1); r = Aurora::isfinite(matrix2); - EXPECT_DOUBLE_EQ(r.getData()[0],0); + EXPECT_FLOAT_EQ(r.getData()[0],0); Aurora::nantoval(matrix2,1); - EXPECT_DOUBLE_EQ(matrix2.getData()[0],1); + EXPECT_FLOAT_EQ(matrix2.getData()[0],1); } diff --git a/test/Function2D_Test.cpp b/test/Function2D_Test.cpp index 4b0c563..b70d91a 100644 --- a/test/Function2D_Test.cpp +++ b/test/Function2D_Test.cpp @@ -23,59 +23,59 @@ protected: }; 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}; + float *dataA = new float[9]{1,2,3,4,5,6,7,8,9}; + float *dataB = new float[9]{10,20,30,40,50,40,30,20,10}; Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,3,3); Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,3,3); - double v = immse(A,B); - EXPECT_DOUBLE_EQ(fourDecimalRound(v),698.3333)<<" immse error;"; + float v = immse(A,B); + EXPECT_FLOAT_EQ(fourDecimalRound(v),698.3333)<<" immse error;"; } 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}; + float *dataA=new float[9]{2, 0, 2, 2, 3, 0, 3, 3, 3}; + float *dataB=new float[9]{1, 1, 1, 1, 1, 1, 1, 1, 1}; Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,3,3); Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,3,3); auto invA = Aurora::inv(A); - double* result = invA.getData(); - EXPECT_DOUBLE_EQ(0.75, fourDecimalRound(result[0])); - EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[1])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[2])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[3])); - EXPECT_DOUBLE_EQ(.0, fourDecimalRound(result[4])); - EXPECT_DOUBLE_EQ(0.3333, fourDecimalRound(result[5])); - EXPECT_DOUBLE_EQ(-0.25, fourDecimalRound(result[6])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[7])); - EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[8])); + float* result = invA.getData(); + EXPECT_FLOAT_EQ(0.75, fourDecimalRound(result[0])); + EXPECT_FLOAT_EQ(0.5, fourDecimalRound(result[1])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[2])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[3])); + EXPECT_FLOAT_EQ(.0, fourDecimalRound(result[4])); + EXPECT_FLOAT_EQ(0.3333, fourDecimalRound(result[5])); + EXPECT_FLOAT_EQ(-0.25, fourDecimalRound(result[6])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[7])); + EXPECT_FLOAT_EQ(0.5, fourDecimalRound(result[8])); invA = Aurora::inv(A*B); result = invA.getData(); - EXPECT_DOUBLE_EQ(0.75, fourDecimalRound(result[0])); - EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[1])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[2])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[3])); - EXPECT_DOUBLE_EQ(.0, fourDecimalRound(result[4])); - EXPECT_DOUBLE_EQ(0.3333, fourDecimalRound(result[5])); - EXPECT_DOUBLE_EQ(-0.25, fourDecimalRound(result[6])); - EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[7])); - EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[8])); + EXPECT_FLOAT_EQ(0.75, fourDecimalRound(result[0])); + EXPECT_FLOAT_EQ(0.5, fourDecimalRound(result[1])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[2])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[3])); + EXPECT_FLOAT_EQ(.0, fourDecimalRound(result[4])); + EXPECT_FLOAT_EQ(0.3333, fourDecimalRound(result[5])); + EXPECT_FLOAT_EQ(-0.25, fourDecimalRound(result[6])); + EXPECT_FLOAT_EQ(-0.5, fourDecimalRound(result[7])); + EXPECT_FLOAT_EQ(0.5, fourDecimalRound(result[8])); } TEST_F(Function2D_Test, std){ - double *dataMA= new double [9]{1, 2, 3, 2, 2, 6, 3, 3, 6}; + float *dataMA= new float [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])); + float* resultStd = D.getData(); + EXPECT_FLOAT_EQ(1.0, resultStd[0]); + EXPECT_FLOAT_EQ(2.3094, fourDecimalRound(resultStd[1])); + EXPECT_FLOAT_EQ(1.7321, fourDecimalRound(resultStd[2])); } 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}; + float *dataA = new float[3]{1, 2, 3}; + float *dataB = new float[9]{2, 3, 3, 2, 2, -1, 3, 3, 3}; + float *dataC = new float[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); @@ -83,45 +83,45 @@ TEST_F(Function2D_Test, min) { 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]); + EXPECT_FLOAT_EQ(2, ret.getData()[0]); + EXPECT_FLOAT_EQ(-1, ret.getData()[1]); + EXPECT_FLOAT_EQ(3, ret.getData()[2]); ret = Aurora::min(B, Aurora::All); - EXPECT_DOUBLE_EQ(1, ret.getDataSize()); - EXPECT_DOUBLE_EQ(-1, ret.getData()[0]); + EXPECT_FLOAT_EQ(1, ret.getDataSize()); + EXPECT_FLOAT_EQ(-1, ret.getData()[0]); ret = Aurora::min(B, Aurora::Row); - EXPECT_DOUBLE_EQ(3, ret.getDataSize()); + EXPECT_FLOAT_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]); + EXPECT_FLOAT_EQ(2, ret.getData()[0]); + EXPECT_FLOAT_EQ(2, ret.getData()[1]); + EXPECT_FLOAT_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_FLOAT_EQ(1, ret.getDataSize()); + EXPECT_FLOAT_EQ(1, ret.getData()[0]); EXPECT_EQ(0, r); EXPECT_EQ(0, c); ret = Aurora::min(D); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(1, ret.getData()[0]); + EXPECT_FLOAT_EQ(1, ret.getData()[0]); 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]); + EXPECT_FLOAT_EQ(3, ret.getDataSize()); + EXPECT_FLOAT_EQ(1, ret.getData()[0]); + EXPECT_FLOAT_EQ(1.5, ret.getData()[1]); + EXPECT_FLOAT_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]); + EXPECT_FLOAT_EQ(9, ret.getDataSize()); + EXPECT_FLOAT_EQ(1, ret.getData()[0]); + EXPECT_FLOAT_EQ(1, ret.getData()[1]); + EXPECT_FLOAT_EQ(1, ret.getData()[2]); } TEST_F(Function2D_Test, max) { - double *dataA = new double[3]{1, 2, 3}; - double *dataC = new double[3]{1, 2, 4}; - double *dataB = new double[9]{2, 3, 3, 2, 2, 1, 3, 3, 3}; + float *dataA = new float[3]{1, 2, 3}; + float *dataC = new float[3]{1, 2, 4}; + float *dataB = new float[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); auto C = Aurora::Matrix::fromRawData(dataC, 3, 1); @@ -129,66 +129,66 @@ TEST_F(Function2D_Test, max) { 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]); + EXPECT_FLOAT_EQ(3, ret.getData()[0]); + EXPECT_FLOAT_EQ(2, ret.getData()[1]); + EXPECT_FLOAT_EQ(3, ret.getData()[2]); ret = Aurora::max(B, Aurora::All); - EXPECT_DOUBLE_EQ(1, ret.getDataSize()); - EXPECT_DOUBLE_EQ(3, ret.getData()[0]); + EXPECT_FLOAT_EQ(1, ret.getDataSize()); + EXPECT_FLOAT_EQ(3, ret.getData()[0]); ret = Aurora::max(B, Aurora::Row); - EXPECT_DOUBLE_EQ(3, ret.getDataSize()); + EXPECT_FLOAT_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]); + EXPECT_FLOAT_EQ(3, ret.getData()[0]); + EXPECT_FLOAT_EQ(3, ret.getData()[1]); + EXPECT_FLOAT_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_FLOAT_EQ(1, ret.getDataSize()); + EXPECT_FLOAT_EQ(3, ret.getData()[0]); EXPECT_EQ(2, r); EXPECT_EQ(0, c); auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3); ret = Aurora::max(D); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(3, ret.getData()[0]); + EXPECT_FLOAT_EQ(3, ret.getData()[0]); ret = Aurora::max(A,C); - EXPECT_DOUBLE_EQ(4, ret.getData()[2]); + EXPECT_FLOAT_EQ(4, ret.getData()[2]); } TEST_F(Function2D_Test, sum) { - double *dataB = new double[9]{2, 3, 3, 2, 2, 1, 3, 3, -3}; + float *dataB = new float[9]{2, 3, 3, 2, 2, 1, 3, 3, -3}; auto B = Aurora::Matrix::fromRawData(dataB, 3, 3); Aurora::Matrix ret = Aurora::sum(B); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(3, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(8, ret.getData()[0]); - EXPECT_DOUBLE_EQ(5, ret.getData()[1]); - EXPECT_DOUBLE_EQ(3, ret.getData()[2]); + EXPECT_FLOAT_EQ(8, ret.getData()[0]); + EXPECT_FLOAT_EQ(5, ret.getData()[1]); + EXPECT_FLOAT_EQ(3, ret.getData()[2]); ret = Aurora::sum(B, Aurora::All); - EXPECT_DOUBLE_EQ(1, ret.getDataSize()); - EXPECT_DOUBLE_EQ(16, ret.getData()[0]); + EXPECT_FLOAT_EQ(1, ret.getDataSize()); + EXPECT_FLOAT_EQ(16, ret.getData()[0]); ret = Aurora::sum(B, Aurora::Row); - EXPECT_DOUBLE_EQ(3, ret.getDataSize()); + EXPECT_FLOAT_EQ(3, ret.getDataSize()); EXPECT_EQ(3, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(7, ret.getData()[0]); - EXPECT_DOUBLE_EQ(8, ret.getData()[1]); - EXPECT_DOUBLE_EQ(1, ret.getData()[2]); - double *dataA = new double[3]{1, 2, 3}; + EXPECT_FLOAT_EQ(7, ret.getData()[0]); + EXPECT_FLOAT_EQ(8, ret.getData()[1]); + EXPECT_FLOAT_EQ(1, ret.getData()[2]); + float *dataA = new float[3]{1, 2, 3}; auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3); ret = Aurora::sum(D); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(6, ret.getData()[0]); + EXPECT_FLOAT_EQ(6, ret.getData()[0]); } TEST_F(Function2D_Test, mean) { { - double *dataB = new double[16]{1.1, 2.6, 3.8, 6.2, + float *dataB = new float[16]{1.1, 2.6, 3.8, 6.2, 4.3, 5.7, 6.9, 10.6, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3, 26.5, -7.7}; @@ -196,28 +196,28 @@ TEST_F(Function2D_Test, mean) { auto r = Aurora::mean(B, Aurora::All); EXPECT_EQ(1, r.getDimSize(0)); EXPECT_EQ(1, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(7.9625, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(7.9625, fourDecimalRound(r.getData()[0])); r = Aurora::mean(B); EXPECT_EQ(1, r.getDimSize(0)); EXPECT_EQ(4, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(3.4250, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(6.8750, fourDecimalRound(r.getData()[1])); - EXPECT_DOUBLE_EQ(9.0750, fourDecimalRound(r.getData()[2])); - EXPECT_DOUBLE_EQ(12.4750, fourDecimalRound(r.getData()[3])); + EXPECT_FLOAT_EQ(3.4250, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(6.8750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(9.0750, fourDecimalRound(r.getData()[2])); + EXPECT_FLOAT_EQ(12.4750, fourDecimalRound(r.getData()[3])); r = Aurora::mean(B, Aurora::Row); EXPECT_EQ(4, r.getDimSize(0)); EXPECT_EQ(1, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(7.5750, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(7.4750, fourDecimalRound(r.getData()[1])); - EXPECT_DOUBLE_EQ(11.7250, fourDecimalRound(r.getData()[2])); - EXPECT_DOUBLE_EQ(5.0750, fourDecimalRound(r.getData()[3])); + EXPECT_FLOAT_EQ(7.5750, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(7.4750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(11.7250, fourDecimalRound(r.getData()[2])); + EXPECT_FLOAT_EQ(5.0750, fourDecimalRound(r.getData()[3])); } //with nan { - double tnan = std::nan(""); - double *dataB = new double[16]{1.1, 2.6, 3.8, 6.2, + float tnan = std::nan(""); + float *dataB = new float[16]{1.1, 2.6, 3.8, 6.2, 4.3, 5.7, 6.9, 10.6, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3,tnan , -7.7}; @@ -230,44 +230,44 @@ TEST_F(Function2D_Test, mean) { r = Aurora::mean(B); EXPECT_EQ(1, r.getDimSize(0)); EXPECT_EQ(4, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(3.4250, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(6.8750, fourDecimalRound(r.getData()[1])); - EXPECT_DOUBLE_EQ(9.0750, fourDecimalRound(r.getData()[2])); + EXPECT_FLOAT_EQ(3.4250, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(6.8750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(9.0750, fourDecimalRound(r.getData()[2])); EXPECT_TRUE(std::isnan(r.getData()[3])); r = Aurora::mean(B, Aurora::Row); EXPECT_EQ(4, r.getDimSize(0)); EXPECT_EQ(1, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(7.5750, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(7.4750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(7.5750, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(7.4750, fourDecimalRound(r.getData()[1])); EXPECT_TRUE(std::isnan(r.getData()[2])); - EXPECT_DOUBLE_EQ(5.0750, fourDecimalRound(r.getData()[3])); + EXPECT_FLOAT_EQ(5.0750, fourDecimalRound(r.getData()[3])); r = Aurora::mean(B, Aurora::All,false); EXPECT_EQ(1, r.getDimSize(0)); EXPECT_EQ(1, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(6.7267, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(6.7267, fourDecimalRound(r.getData()[0])); r = Aurora::mean(B, Aurora::Column, false); EXPECT_EQ(1, r.getDimSize(0)); EXPECT_EQ(4, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(3.4250, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(6.8750, fourDecimalRound(r.getData()[1])); - EXPECT_DOUBLE_EQ(9.0750, fourDecimalRound(r.getData()[2])); - EXPECT_DOUBLE_EQ(7.8, fourDecimalRound(r.getData()[3])); + EXPECT_FLOAT_EQ(3.4250, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(6.8750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(9.0750, fourDecimalRound(r.getData()[2])); + EXPECT_FLOAT_EQ(7.8, fourDecimalRound(r.getData()[3])); r = Aurora::mean(B, Aurora::Row, false); EXPECT_EQ(4, r.getDimSize(0)); EXPECT_EQ(1, r.getDimSize(1)); - EXPECT_DOUBLE_EQ(7.5750, fourDecimalRound(r.getData()[0])); - EXPECT_DOUBLE_EQ(7.4750, fourDecimalRound(r.getData()[1])); - EXPECT_DOUBLE_EQ(6.8, fourDecimalRound(r.getData()[2])); - EXPECT_DOUBLE_EQ(5.0750, fourDecimalRound(r.getData()[3])); + EXPECT_FLOAT_EQ(7.5750, fourDecimalRound(r.getData()[0])); + EXPECT_FLOAT_EQ(7.4750, fourDecimalRound(r.getData()[1])); + EXPECT_FLOAT_EQ(6.8, fourDecimalRound(r.getData()[2])); + EXPECT_FLOAT_EQ(5.0750, fourDecimalRound(r.getData()[3])); } } TEST_F(Function2D_Test, sort) { - double *dataB = new double[16]{1.1, 2.6, 6.2, 3.8, + float *dataB = new float[16]{1.1, 2.6, 6.2, 3.8, 4.3, 10.6, 5.7, 6.9, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3,7 , -7.7}; @@ -275,23 +275,23 @@ TEST_F(Function2D_Test, sort) { auto ret = Aurora::sort(B); EXPECT_EQ(4, ret.getDimSize(0)); EXPECT_EQ(4, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(3.8, ret.getData()[2]); - EXPECT_DOUBLE_EQ(5.7, ret.getData()[5]); - EXPECT_DOUBLE_EQ(-7.7, ret.getData()[12]); + EXPECT_FLOAT_EQ(3.8, ret.getData()[2]); + EXPECT_FLOAT_EQ(5.7, ret.getData()[5]); + EXPECT_FLOAT_EQ(-7.7, ret.getData()[12]); ret = Aurora::sort(B*5); EXPECT_EQ(4, ret.getDimSize(0)); EXPECT_EQ(4, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(19, ret.getData()[2]); - EXPECT_DOUBLE_EQ(28.5, ret.getData()[5]); - EXPECT_DOUBLE_EQ(-38.5, ret.getData()[12]); + EXPECT_FLOAT_EQ(19, ret.getData()[2]); + EXPECT_FLOAT_EQ(28.5, ret.getData()[5]); + EXPECT_FLOAT_EQ(-38.5, ret.getData()[12]); //big sort 10w以上多线程快 - double * dataA = Aurora::random(1000000*4); + float * dataA = Aurora::random(1000000*4); auto A = Aurora::Matrix::New(dataA, 1000000, 4); ret = Aurora::sort(A); } TEST_F(Function2D_Test, sortrows) { - double *dataB = new double[42]{ + float *dataB = new float[42]{ 95, 27, 95, 79, 67, 70, 69, 95, 7, 48, 95, 75, 3, 31, 95, 7, 48, 65, 74, 27, 95, @@ -307,7 +307,7 @@ TEST_F(Function2D_Test, sortrows) { } TEST_F(Function2D_Test, median) { - double *dataB = new double[20]{1.1, 2.6, 3.8, 6.2, + float *dataB = new float[20]{1.1, 2.6, 3.8, 6.2, 4.3, 5.7, 6.9, 10.6, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3,26.5 , -7.7, @@ -316,96 +316,96 @@ TEST_F(Function2D_Test, median) { auto ret = Aurora::median(B); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(5, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(3.2, ret.getData()[0]); - EXPECT_DOUBLE_EQ(6.3, ret.getData()[1]); - EXPECT_DOUBLE_EQ(9, ret.getData()[2]); - EXPECT_DOUBLE_EQ(15.55, ret.getData()[3]); - EXPECT_DOUBLE_EQ(7.25, ret.getData()[4]); - double *dataA = new double[3]{1, 2, 3}; + EXPECT_FLOAT_EQ(3.2, ret.getData()[0]); + EXPECT_FLOAT_EQ(6.3, ret.getData()[1]); + EXPECT_FLOAT_EQ(9, ret.getData()[2]); + EXPECT_FLOAT_EQ(15.55, ret.getData()[3]); + EXPECT_FLOAT_EQ(7.25, ret.getData()[4]); + float *dataA = new float[3]{1, 2, 3}; auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3); ret = Aurora::median(D); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(2, ret.getData()[0]); + EXPECT_FLOAT_EQ(2, ret.getData()[0]); } TEST_F(Function2D_Test, fftAndComplexAndIfft){ - double *input = new double[20]{1,1,0,2,2,0,1,1,0,2,1,1,0,2,2,0,1,1,0,2}; + float *input = new float[20]{1,1,0,2,2,0,1,1,0,2,1,1,0,2,2,0,1,1,0,2}; auto ma = Aurora::Matrix::fromRawData(input,10,2); auto fftrett = Aurora::fft(ma); - std::complex* result = (std::complex*)fftrett.getData(); + std::complex* result = (std::complex*)fftrett.getData(); //检验fft结果与matlab是否对应 - EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real())); - EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag())); - EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[11].real())); - EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[12].imag())); + EXPECT_FLOAT_EQ(0.0729, fourDecimalRound(result[1].real())); + EXPECT_FLOAT_EQ(2.4899, fourDecimalRound(result[2].imag())); + EXPECT_FLOAT_EQ(0.0729, fourDecimalRound(result[11].real())); + EXPECT_FLOAT_EQ(2.4899, fourDecimalRound(result[12].imag())); //检验fft的结果是否共轭 - EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag()); - EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real()); + EXPECT_FLOAT_EQ(0, result[4].imag()+result[6].imag()); + EXPECT_FLOAT_EQ(0, result[4].real()-result[6].real()); auto ret= Aurora::ifft(fftrett); - std::complex* ifftResult = (std::complex*)ret.getData(); - EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0); - EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[3].real()),2.0); - EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[11].real()),1.0); - EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[13].real()),2.0); + std::complex* ifftResult = (std::complex*)ret.getData(); + EXPECT_FLOAT_EQ(fourDecimalRound(ifftResult[1].real()),1.0); + EXPECT_FLOAT_EQ(fourDecimalRound(ifftResult[3].real()),2.0); + EXPECT_FLOAT_EQ(fourDecimalRound(ifftResult[11].real()),1.0); + EXPECT_FLOAT_EQ(fourDecimalRound(ifftResult[13].real()),2.0); Aurora::fftshift(fftrett); - EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[6].real())); - EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[7].imag())); - EXPECT_DOUBLE_EQ(-2., fourDecimalRound(result[10].real())); - EXPECT_DOUBLE_EQ(-0.2245, fourDecimalRound(result[11].imag())); + EXPECT_FLOAT_EQ(0.0729, fourDecimalRound(result[6].real())); + EXPECT_FLOAT_EQ(2.4899, fourDecimalRound(result[7].imag())); + EXPECT_FLOAT_EQ(-2., fourDecimalRound(result[10].real())); + EXPECT_FLOAT_EQ(-0.2245, fourDecimalRound(result[11].imag())); auto fftrett2 = Aurora::fft(ma,5); - auto result2 = (std::complex*)fftrett2.getData(); + auto result2 = (std::complex*)fftrett2.getData(); //检验fft结果与matlab是否对应 - EXPECT_DOUBLE_EQ(0.3090, fourDecimalRound(result2[1].real())); - EXPECT_DOUBLE_EQ(-1.3143, fourDecimalRound(result2[2].imag())); - EXPECT_DOUBLE_EQ(-0.8090, fourDecimalRound(result2[7].real())); - EXPECT_DOUBLE_EQ(1.3143, fourDecimalRound(result2[8].imag())); + EXPECT_FLOAT_EQ(0.3090, fourDecimalRound(result2[1].real())); + EXPECT_FLOAT_EQ(-1.3143, fourDecimalRound(result2[2].imag())); + EXPECT_FLOAT_EQ(-0.8090, fourDecimalRound(result2[7].real())); + EXPECT_FLOAT_EQ(1.3143, fourDecimalRound(result2[8].imag())); auto fftrett3 = Aurora::fft(ma,12); - auto result3 = (std::complex*)fftrett3.getData(); + auto result3 = (std::complex*)fftrett3.getData(); //检验fft结果与matlab是否对应 - EXPECT_DOUBLE_EQ(-1.0, fourDecimalRound(result3[1].real())); - EXPECT_DOUBLE_EQ(-3.4641, fourDecimalRound(result3[4].imag())); - EXPECT_DOUBLE_EQ(-1.0, fourDecimalRound(result3[13].real())); - EXPECT_DOUBLE_EQ(-3.4641, fourDecimalRound(result3[16].imag())); + EXPECT_FLOAT_EQ(-1.0, fourDecimalRound(result3[1].real())); + EXPECT_FLOAT_EQ(-3.4641, fourDecimalRound(result3[4].imag())); + EXPECT_FLOAT_EQ(-1.0, fourDecimalRound(result3[13].real())); + EXPECT_FLOAT_EQ(-3.4641, fourDecimalRound(result3[16].imag())); { - auto fm = Aurora::Matrix::fromRawData(new double[7]{1,2,3, 4, 5, 6, 7},7,1); + auto fm = Aurora::Matrix::fromRawData(new float[7]{1,2,3, 4, 5, 6, 7},7,1); Aurora::fftshift(fm); - EXPECT_DOUBLE_EQ(5, fm[0]); - EXPECT_DOUBLE_EQ(1, fm[3]); - EXPECT_DOUBLE_EQ(4, fm[6]); + EXPECT_FLOAT_EQ(5, fm[0]); + EXPECT_FLOAT_EQ(1, fm[3]); + EXPECT_FLOAT_EQ(4, fm[6]); Aurora::ifftshift(fm); - EXPECT_DOUBLE_EQ(1, fm[0]); - EXPECT_DOUBLE_EQ(4, fm[3]); - EXPECT_DOUBLE_EQ(7, fm[6]); + EXPECT_FLOAT_EQ(1, fm[0]); + EXPECT_FLOAT_EQ(4, fm[3]); + EXPECT_FLOAT_EQ(7, fm[6]); } } TEST_F(Function2D_Test, hilbert) { - double *input = new double[20]{1,1,0,2,2,0,1,1,0,2,1,1,0,2,2,0,1,1,0,2}; + float *input = new float[20]{1,1,0,2,2,0,1,1,0,2,1,1,0,2,2,0,1,1,0,2}; auto ma = Aurora::Matrix::fromRawData(input,10,2); auto ret = Aurora::hilbert(ma); - auto result = (std::complex*)ret.getData(); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].real()),1.0); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].imag()),0.3249); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[11].real()),1.0); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[11].imag()),0.3249); + auto result = (std::complex*)ret.getData(); + EXPECT_FLOAT_EQ(fourDecimalRound(result[1].real()),1.0); + EXPECT_FLOAT_EQ(fourDecimalRound(result[1].imag()),0.3249); + EXPECT_FLOAT_EQ(fourDecimalRound(result[11].real()),1.0); + EXPECT_FLOAT_EQ(fourDecimalRound(result[11].imag()),0.3249); } TEST_F(Function2D_Test, ifft_symmetric) { - double *input = new double[18]{10,2,1,3,4,4,16,3,1,2,15,-2,1,-3,4,-4,1,-3}; + float *input = new float[18]{10,2,1,3,4,4,16,3,1,2,15,-2,1,-3,4,-4,1,-3}; auto ma = Aurora::Matrix::fromRawData(input,9,1,1,Aurora::Complex); auto ret = Aurora::ifft_symmetric(ma,18); auto result = ret.getData(); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[0]),5.3333); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[1]),1.1188); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[11]),2.8506); - EXPECT_DOUBLE_EQ(fourDecimalRound(result[17]),1.1188); + EXPECT_FLOAT_EQ(fourDecimalRound(result[0]),5.3333); + EXPECT_FLOAT_EQ(fourDecimalRound(result[1]),1.1188); + EXPECT_FLOAT_EQ(fourDecimalRound(result[11]),2.8506); + EXPECT_FLOAT_EQ(fourDecimalRound(result[17]),1.1188); } TEST_F(Function2D_Test, prod) { - double *dataB = new double[20]{1.1, 2.6, 3.8, 6.2, + float *dataB = new float[20]{1.1, 2.6, 3.8, 6.2, 4.3, 5.7, 6.9, 10.6, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3,26.5 , -7.7, @@ -414,37 +414,37 @@ TEST_F(Function2D_Test, prod) { auto ret = Aurora::prod(B); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(5, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(0.0067, fourDecimalRound(ret.getData()[0]/10000)); - EXPECT_DOUBLE_EQ(0.1793, fourDecimalRound(ret.getData()[1]/10000)); - EXPECT_DOUBLE_EQ(0.6402, fourDecimalRound(ret.getData()[2]/10000)); - EXPECT_DOUBLE_EQ(-4.8307, fourDecimalRound(ret.getData()[3]/10000)); - EXPECT_DOUBLE_EQ(0.2608, fourDecimalRound(ret.getData()[4]/10000)); - double *dataA = new double[3]{1, 2, 3}; + EXPECT_FLOAT_EQ(0.0067, fourDecimalRound(ret.getData()[0]/10000)); + EXPECT_FLOAT_EQ(0.1793, fourDecimalRound(ret.getData()[1]/10000)); + EXPECT_FLOAT_EQ(0.6402, fourDecimalRound(ret.getData()[2]/10000)); + EXPECT_FLOAT_EQ(-4.8307, fourDecimalRound(ret.getData()[3]/10000)); + EXPECT_FLOAT_EQ(0.2608, fourDecimalRound(ret.getData()[4]/10000)); + float *dataA = new float[3]{1, 2, 3}; auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3); ret = Aurora::prod(D); EXPECT_EQ(1, ret.getDimSize(0)); EXPECT_EQ(1, ret.getDimSize(1)); - EXPECT_DOUBLE_EQ(6, ret.getData()[0]); + EXPECT_FLOAT_EQ(6, ret.getData()[0]); } TEST_F(Function2D_Test, dot) { { - double *dataA = new double[8]; - double *dataB = new double[8]; + float *dataA = new float[8]; + float *dataB = new float[8]; for (int i = 0; i < 8; ++i) { - dataA[i] = (double) (i); - dataB[i] = (double) (2); + dataA[i] = (float) (i); + dataB[i] = (float) (2); } Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA, 4, 2); Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 4, 2); auto C = Aurora::dot(A, B); EXPECT_EQ(1, C.getDimSize(0)); EXPECT_EQ(2, C.getDimSize(1)); - EXPECT_DOUBLE_EQ(12, fourDecimalRound(C.getData()[0])); - EXPECT_DOUBLE_EQ(44, fourDecimalRound(C.getData()[1])); + EXPECT_FLOAT_EQ(12, fourDecimalRound(C.getData()[0])); + EXPECT_FLOAT_EQ(44, fourDecimalRound(C.getData()[1])); } { - double *dataB = new double[20]{1.1, 2.6, 3.8, 6.2, + float *dataB = new float[20]{1.1, 2.6, 3.8, 6.2, 4.3, 5.7, 6.9, 10.6, 7.1, 8.3, 9.7, 11.2, 17.8, 13.3,26.5 , -7.7, @@ -453,56 +453,56 @@ TEST_F(Function2D_Test, dot) { auto C = Aurora::dot(Aurora::fft(B),Aurora::fft(B)); EXPECT_EQ(1, C.getDimSize(0)); EXPECT_EQ(5, C.getDimSize(1)); - EXPECT_DOUBLE_EQ(0.2434, fourDecimalRound(C.getData()[0]/1000)); - EXPECT_DOUBLE_EQ(0., fourDecimalRound(C.getData()[1]/1000)); - EXPECT_DOUBLE_EQ(0.8438, fourDecimalRound(C.getData()[2]/1000)); - EXPECT_DOUBLE_EQ(0., fourDecimalRound(C.getData()[3]/1000)); - EXPECT_DOUBLE_EQ(1.3553, fourDecimalRound(C.getData()[4]/1000)); - EXPECT_DOUBLE_EQ(0., fourDecimalRound(C.getData()[5]/1000)); - EXPECT_DOUBLE_EQ(5.0211, fourDecimalRound(C.getData()[6]/1000)); - EXPECT_DOUBLE_EQ(0., fourDecimalRound(C.getData()[7]/1000)); - EXPECT_DOUBLE_EQ(0.9238, fourDecimalRound(C.getData()[8]/1000)); - EXPECT_DOUBLE_EQ(0., fourDecimalRound(C.getData()[9]/1000)); + EXPECT_FLOAT_EQ(0.2434, fourDecimalRound(C.getData()[0]/1000)); + EXPECT_FLOAT_EQ(0., fourDecimalRound(C.getData()[1]/1000)); + EXPECT_FLOAT_EQ(0.8438, fourDecimalRound(C.getData()[2]/1000)); + EXPECT_FLOAT_EQ(0., fourDecimalRound(C.getData()[3]/1000)); + EXPECT_FLOAT_EQ(1.3553, fourDecimalRound(C.getData()[4]/1000)); + EXPECT_FLOAT_EQ(0., fourDecimalRound(C.getData()[5]/1000)); + EXPECT_FLOAT_EQ(5.0211, fourDecimalRound(C.getData()[6]/1000)); + EXPECT_FLOAT_EQ(0., fourDecimalRound(C.getData()[7]/1000)); + EXPECT_FLOAT_EQ(0.9238, fourDecimalRound(C.getData()[8]/1000)); + EXPECT_FLOAT_EQ(0., fourDecimalRound(C.getData()[9]/1000)); } } TEST_F(Function2D_Test, interp2) { - double* xD= new double[4]{1,2,3,4}; - Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); - double* yD= new double[5]{1,4,9,16,25}; - Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); - double* x1D= new double[3]{1.22,2.69,3.84}; - Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); - double* y1D= new double[3]{4.5823,10.552,18}; - Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); - double* vD= new double[20]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; - Aurora::Matrix v(std::shared_ptr(vD,std::default_delete()),std::vector{5,4}); + float* xD= new float[4]{1,2,3,4}; + Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); + float* yD= new float[5]{1,4,9,16,25}; + Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); + float* x1D= new float[3]{1.22,2.69,3.84}; + Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); + float* y1D= new float[3]{4.5823,10.552,18}; + Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); + float* vD= new float[20]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; + Aurora::Matrix v(std::shared_ptr(vD,std::default_delete()),std::vector{5,4}); Aurora::Matrix result = interp2(x,y,v,x1,y1,Aurora::InterpnMethod::Spline); - EXPECT_DOUBLE_AE(result.getData()[0],303.5663); - EXPECT_DOUBLE_AE(result.getData()[1],243.6711); - EXPECT_DOUBLE_AE(result.getData()[2],-47.32); + EXPECT_FLOAT_AE(result.getData()[0],303.5663); + EXPECT_FLOAT_AE(result.getData()[1],243.6711); + EXPECT_FLOAT_AE(result.getData()[2],-47.32); result = interp2(x,y,v,x1,y1,Aurora::InterpnMethod::Linear); - EXPECT_DOUBLE_AE(result.getData()[0],302.6298); - EXPECT_DOUBLE_AE(result.getData()[1],261.1313); - EXPECT_DOUBLE_AE(result.getData()[2],18.6089); + EXPECT_FLOAT_AE(result.getData()[0],302.6298); + EXPECT_FLOAT_AE(result.getData()[1],261.1313); + EXPECT_FLOAT_AE(result.getData()[2],18.6089); } TEST_F(Function2D_Test, sub2ind) { - double* dI1= new double[4]{1,2,1,2}; - Aurora::Matrix I1(std::shared_ptr(dI1,std::default_delete()),std::vector{4}); - double* dI2= new double[4]{2,2,1,1}; - Aurora::Matrix I2(std::shared_ptr(dI2,std::default_delete()),std::vector{4}); - double* dI4= new double[4]{1,1,2,2}; - Aurora::Matrix I3(std::shared_ptr(dI4,std::default_delete()),std::vector{4}); - double* dsz= new double[3]{2,2,2}; - Aurora::Matrix sz(std::shared_ptr(dsz,std::default_delete()),std::vector{3}); + float* dI1= new float[4]{1,2,1,2}; + Aurora::Matrix I1(std::shared_ptr(dI1,std::default_delete()),std::vector{4}); + float* dI2= new float[4]{2,2,1,1}; + Aurora::Matrix I2(std::shared_ptr(dI2,std::default_delete()),std::vector{4}); + float* dI4= new float[4]{1,1,2,2}; + Aurora::Matrix I3(std::shared_ptr(dI4,std::default_delete()),std::vector{4}); + float* dsz= new float[3]{2,2,2}; + Aurora::Matrix sz(std::shared_ptr(dsz,std::default_delete()),std::vector{3}); auto ma = Aurora::sub2ind(sz, {I1, I2, I3}); - EXPECT_DOUBLE_EQ(3, ma.getData()[0]); - EXPECT_DOUBLE_EQ(4, ma.getData()[1]); - EXPECT_DOUBLE_EQ(5, ma.getData()[2]); - EXPECT_DOUBLE_EQ(6, ma.getData()[3]); + EXPECT_FLOAT_EQ(3, ma.getData()[0]); + EXPECT_FLOAT_EQ(4, ma.getData()[1]); + EXPECT_FLOAT_EQ(5, ma.getData()[2]); + EXPECT_FLOAT_EQ(6, ma.getData()[3]); } diff --git a/test/Function3D_Test.cpp b/test/Function3D_Test.cpp index da2e7de..3eacbb3 100644 --- a/test/Function3D_Test.cpp +++ b/test/Function3D_Test.cpp @@ -24,73 +24,73 @@ protected: }; TEST_F(Function3D_Test, interp3) { - double* xD= new double[4]{1,2,3,4}; - Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); - double* yD= new double[5]{1,4,9,16,25}; - Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); - double* zD= new double[3]{22,33,56}; - Aurora::Matrix z(std::shared_ptr(zD,std::default_delete()),std::vector{3}); - double* x1D= new double[3]{1.22,2.69,3.84}; - Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); - double* y1D= new double[3]{4.5823,10.552,18}; - Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); - double* z1D= new double[3]{22.256,40.22,48}; - Aurora::Matrix z1(std::shared_ptr(z1D,std::default_delete()),std::vector{3}); - double* vD= new double[60]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, + float* xD= new float[4]{1,2,3,4}; + Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); + float* yD= new float[5]{1,4,9,16,25}; + Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); + float* zD= new float[3]{22,33,56}; + Aurora::Matrix z(std::shared_ptr(zD,std::default_delete()),std::vector{3}); + float* x1D= new float[3]{1.22,2.69,3.84}; + Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); + float* y1D= new float[3]{4.5823,10.552,18}; + Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); + float* z1D= new float[3]{22.256,40.22,48}; + Aurora::Matrix z1(std::shared_ptr(z1D,std::default_delete()),std::vector{3}); + float* vD= new float[60]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, 158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, 158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; - Aurora::Matrix v(std::shared_ptr(vD,std::default_delete()),std::vector{5,4,3}); + Aurora::Matrix v(std::shared_ptr(vD,std::default_delete()),std::vector{5,4,3}); Aurora::Matrix result = interp3(x,y,z,v,x1,y1,z1,Aurora::InterpnMethod::Spline); - EXPECT_DOUBLE_AE(result.getData()[0],303.5663); - EXPECT_DOUBLE_AE(result.getData()[1],243.6711); - EXPECT_DOUBLE_AE(result.getData()[2],-47.32); + EXPECT_FLOAT_AE(result.getData()[0],303.5663); + EXPECT_FLOAT_AE(result.getData()[1],243.6711); + EXPECT_FLOAT_AE(result.getData()[2],-47.32); result = interp3(x,y,z,v,x1,y1,z1,Aurora::InterpnMethod::Linear); - EXPECT_DOUBLE_AE(result.getData()[0],302.6298); - EXPECT_DOUBLE_AE(result.getData()[1],261.1313); - EXPECT_DOUBLE_AE(result.getData()[2],18.6089); + EXPECT_FLOAT_AE(result.getData()[0],302.6298); + EXPECT_FLOAT_AE(result.getData()[1],261.1313); + EXPECT_FLOAT_AE(result.getData()[2],18.6089); } TEST_F(Function3D_Test, interpn) { - double* xD= new double[4]{1,2,3,4}; - Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); - double* yD= new double[5]{1,4,9,16,25}; - Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); - double* zD= new double[3]{22,33,56}; - Aurora::Matrix z(std::shared_ptr(zD,std::default_delete()),std::vector{3}); - double* x1D= new double[3]{1.22,2.69,3.84}; - Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); - double* y1D= new double[3]{2.5823,3.552,3.888}; - Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); - double* z1D= new double[3]{22.256,40.22,48}; - Aurora::Matrix z1(std::shared_ptr(z1D,std::default_delete()),std::vector{3}); - double* v2D= new double[20]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; - Aurora::Matrix v2(std::shared_ptr(v2D,std::default_delete()),std::vector{5,4}); - double* v3D= new double[60]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, + float* xD= new float[4]{1,2,3,4}; + Aurora::Matrix x(std::shared_ptr(xD,std::default_delete()),std::vector{4}); + float* yD= new float[5]{1,4,9,16,25}; + Aurora::Matrix y(std::shared_ptr(yD,std::default_delete()),std::vector{5}); + float* zD= new float[3]{22,33,56}; + Aurora::Matrix z(std::shared_ptr(zD,std::default_delete()),std::vector{3}); + float* x1D= new float[3]{1.22,2.69,3.84}; + Aurora::Matrix x1(std::shared_ptr(x1D,std::default_delete()),std::vector{3}); + float* y1D= new float[3]{2.5823,3.552,3.888}; + Aurora::Matrix y1(std::shared_ptr(y1D,std::default_delete()),std::vector{3}); + float* z1D= new float[3]{22.256,40.22,48}; + Aurora::Matrix z1(std::shared_ptr(z1D,std::default_delete()),std::vector{3}); + float* v2D= new float[20]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; + Aurora::Matrix v2(std::shared_ptr(v2D,std::default_delete()),std::vector{5,4}); + float* v3D= new float[60]{158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, 158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25, 158,256,332,428,22,56,487,54,26,333,541,554,445,48,22,54,36,98,11,25}; - Aurora::Matrix v3(std::shared_ptr(v3D,std::default_delete()),std::vector{5,4,3}); + Aurora::Matrix v3(std::shared_ptr(v3D,std::default_delete()),std::vector{5,4,3}); Aurora::Matrix result = interpn(y,x,v2,x1,y1,Aurora::InterpnMethod::Spline); - EXPECT_DOUBLE_AE(result.getData()[0],399.2742); - EXPECT_DOUBLE_AE(result.getData()[1],387.7651); - EXPECT_DOUBLE_AE(result.getData()[2],135.6138); + EXPECT_FLOAT_AE(result.getData()[0],399.2742); + EXPECT_FLOAT_AE(result.getData()[1],387.7651); + EXPECT_FLOAT_AE(result.getData()[2],135.6138); result = interpn(y,x,v2,x1,y1,Aurora::InterpnMethod::Linear); - EXPECT_DOUBLE_AE(result.getData()[0],352.1727); - EXPECT_DOUBLE_AE(result.getData()[1],269.8596); - EXPECT_DOUBLE_AE(result.getData()[2],94.7908); + EXPECT_FLOAT_AE(result.getData()[0],352.1727); + EXPECT_FLOAT_AE(result.getData()[1],269.8596); + EXPECT_FLOAT_AE(result.getData()[2],94.7908); result = interpn(y,x,z,v3,x1,y1,z1,Aurora::InterpnMethod::Spline); - EXPECT_DOUBLE_AE(result.getData()[0],399.2742); - EXPECT_DOUBLE_AE(result.getData()[1],387.7651); - EXPECT_DOUBLE_AE(result.getData()[2],135.6138); + EXPECT_FLOAT_AE(result.getData()[0],399.2742); + EXPECT_FLOAT_AE(result.getData()[1],387.7651); + EXPECT_FLOAT_AE(result.getData()[2],135.6138); result = interpn(y,x,z,v3,x1,y1,z1,Aurora::InterpnMethod::Linear); - EXPECT_DOUBLE_AE(result.getData()[0],352.1727); - EXPECT_DOUBLE_AE(result.getData()[1],269.8596); - EXPECT_DOUBLE_AE(result.getData()[2],94.7908); + EXPECT_FLOAT_AE(result.getData()[0],352.1727); + EXPECT_FLOAT_AE(result.getData()[1],269.8596); + EXPECT_FLOAT_AE(result.getData()[2],94.7908); } TEST_F(Function3D_Test, zerosAndones){ @@ -118,25 +118,25 @@ TEST_F(Function3D_Test, zerosAndones){ Aurora::Matrix onesM = Aurora::ones( 9, 9,9); EXPECT_EQ(729,onesM.getDataSize()); for (int i = 0; i < onesM.getDataSize(); ++i) { - EXPECT_DOUBLE_EQ(1.0,onesM.getData()[i])<<" error at index："<9?1.0:0.0); + EXPECT_FLOAT_AE(ZZ[i], i>9?1.0:0.0); } + } \ No newline at end of file diff --git a/test/TestUtility.h b/test/TestUtility.h index 89a5f20..01dc465 100644 --- a/test/TestUtility.h +++ b/test/TestUtility.h @@ -8,11 +8,11 @@ printf("%s:\r\n", #Matrix);\ Matrix.printf();\ printf("%s end================================\r\n", #Matrix); -inline double fourDecimalRound(double src){ +inline float fourDecimalRound(float src){ return round(src*10000.0)/10000.0; } -#define EXPECT_DOUBLE_AE(valueA,valueB)\ - EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB)); +#define EXPECT_FLOAT_AE(valueA,valueB)\ + EXPECT_FLOAT_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB)); #endif //AURORA_TESTUTILITY_H