Fix UnitTest add cudamatrix add and mul
This commit is contained in:
kradchen
@@ -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_PROPERTY:MKL::MKL,INTERFACE_COMPILE_OPTIONS>)
|
||||
target_include_directories(Aurora_Test PUBLIC $<TARGET_PROPERTY:MKL::MKL,INTERFACE_INCLUDE_DIRECTORIES>)
|
||||
|
||||
@@ -9,7 +9,7 @@
|
||||
#include <cuda_runtime.h>
|
||||
#include "CudaMatrixPrivate.cuh"
|
||||
|
||||
using namespace Aurora;
|
||||
namespace Aurora{
|
||||
|
||||
CudaMatrix::CudaMatrix(std::shared_ptr<float> aData, std::vector<int> 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)"<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = getDataSize() * getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
auto out = CudaMatrix::fromRawData(data, getDimSize(0), getDimSize(1), getDimSize(2), getValueType());
|
||||
unaryAdd(getData(),aScalar,out.getData(),getDataSize());
|
||||
return out;
|
||||
}
|
||||
|
||||
CudaMatrix operator+(float aScalar, const CudaMatrix &aMatrix){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = aMatrix.getDataSize() * aMatrix.getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
auto out = CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2), aMatrix.getValueType());
|
||||
unaryAdd(aMatrix.getData(),aScalar,out.getData(),aMatrix.getDataSize());
|
||||
return out;
|
||||
}
|
||||
|
||||
CudaMatrix& operator+(float aScalar, CudaMatrix &&aMatrix){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return aMatrix;
|
||||
}
|
||||
unaryAdd(aMatrix.getData(),aScalar,aMatrix.getData(),aMatrix.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
|
||||
CudaMatrix& operator+(CudaMatrix &&aMatrix,float aScalar){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return aMatrix;
|
||||
}
|
||||
unaryAdd(aMatrix.getData(),aScalar,aMatrix.getData(),aMatrix.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
|
||||
CudaMatrix CudaMatrix::operator+(const CudaMatrix &aMatrix) const{
|
||||
if (this->getDataSize() != aMatrix.getDataSize()) return CudaMatrix();
|
||||
if (this->getDataSize() != aMatrix.getDataSize()) {
|
||||
std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<<this->getDataSize()
|
||||
<<" and the matrix1 size is "<<aMatrix.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (this->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")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = getDataSize() * getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
@@ -250,4 +308,128 @@ CudaMatrix CudaMatrix::operator+(const CudaMatrix &aMatrix) const{
|
||||
unaryAdd(this->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 "<<this->getDataSize()
|
||||
<<" and the matrix1 size is "<<aMatrix.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (this->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")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
unaryAdd(this->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 "<<aMatrix.getDataSize()
|
||||
<<" and the matrix1 size is "<<aOther.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (aOther.isComplex() != aMatrix.isComplex()) {
|
||||
std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(aMatrix.isComplex()?"Comples":"Real")
|
||||
<<" and the matrix1 type is "<<(aOther.isComplex()?"Comples":"Real")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
unaryAdd(aOther.getData(),aMatrix.getData(),aMatrix.getData(),aOther.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
|
||||
// mul
|
||||
CudaMatrix CudaMatrix::operator*(float aScalar) const{
|
||||
if (isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = getDataSize() * getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
auto out = CudaMatrix::fromRawData(data, getDimSize(0), getDimSize(1), getDimSize(2), getValueType());
|
||||
unaryMul(getData(),aScalar,out.getData(),getDataSize());
|
||||
return out;
|
||||
}
|
||||
CudaMatrix operator*(float aScalar, const CudaMatrix &aMatrix){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = aMatrix.getDataSize() * aMatrix.getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
auto out = CudaMatrix::fromRawData(data, aMatrix.getDimSize(0), aMatrix.getDimSize(1), aMatrix.getDimSize(2), aMatrix.getValueType());
|
||||
unaryMul(aMatrix.getData(),aScalar,out.getData(),aMatrix.getDataSize());
|
||||
return out;
|
||||
}
|
||||
CudaMatrix& operator*(float aScalar, CudaMatrix &&aMatrix){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return aMatrix;
|
||||
}
|
||||
unaryMul(aMatrix.getData(),aScalar,aMatrix.getData(),aMatrix.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
CudaMatrix& operator*(CudaMatrix &&aMatrix,float aScalar){
|
||||
if (aMatrix.isComplex())
|
||||
{
|
||||
std::cerr<<"Complex matrix not support operator+(float aScalar)"<<std::endl;
|
||||
return aMatrix;
|
||||
}
|
||||
unaryMul(aMatrix.getData(),aScalar,aMatrix.getData(),aMatrix.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
CudaMatrix CudaMatrix::operator*(const CudaMatrix &aMatrix) const{
|
||||
if (this->getDataSize() != aMatrix.getDataSize()) {
|
||||
std::cerr<<"operator+ must with Same DataSize, now the matrix0 size is "<<this->getDataSize()
|
||||
<<" and the matrix1 size is "<<aMatrix.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (this->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")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
float* data = nullptr;
|
||||
unsigned long long size = getDataSize() * getValueType();
|
||||
cudaMalloc((void**)&data, sizeof(float) * size);
|
||||
auto out = CudaMatrix::fromRawData(data, getDimSize(0), getDimSize(1), getDimSize(2), getValueType());
|
||||
unaryMul(this->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 "<<this->getDataSize()
|
||||
<<" and the matrix1 size is "<<aMatrix.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (this->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")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
unaryMul(this->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 "<<aMatrix.getDataSize()
|
||||
<<" and the matrix1 size is "<<aOther.getDataSize()<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
if (aOther.isComplex() != aMatrix.isComplex()) {
|
||||
std::cerr<<"operator+ must with Data type, now the matrix0 type is "<<(aMatrix.isComplex()?"Comples":"Real")
|
||||
<<" and the matrix1 type is "<<(aOther.isComplex()?"Comples":"Real")<<std::endl;
|
||||
return CudaMatrix();
|
||||
}
|
||||
unaryMul(aOther.getData(),aMatrix.getData(),aMatrix.getData(),aOther.getDataSize());
|
||||
return aMatrix;
|
||||
}
|
||||
}
|
||||
#endif // USE_CUDA
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
#include <thrust/execution_policy.h>
|
||||
using namespace thrust::placeholders;
|
||||
|
||||
struct PowOperator{
|
||||
struct PowOperator: public thrust::unary_function<float, float>{
|
||||
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<float> 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));
|
||||
}
|
||||
|
||||
|
||||
@@ -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__
|
||||
@@ -3,6 +3,7 @@
|
||||
//
|
||||
|
||||
#include "Function.h"
|
||||
#include <cstddef>
|
||||
|
||||
//必须在mkl.h和Eigen的头之前，<complex>之后
|
||||
#define MKL_Complex8 std::complex<float>
|
||||
@@ -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)
|
||||
{
|
||||
|
||||
@@ -6,11 +6,13 @@
|
||||
#define MATLABFUNCTIONS_MATRIXFUNCTIONS_H
|
||||
|
||||
#include <complex>
|
||||
#include <cstddef>
|
||||
|
||||
namespace Aurora{
|
||||
float* malloc(size_t size,bool complex = false);
|
||||
void free(void* ptr);
|
||||
void gpuFree(void* ptr);
|
||||
float* random(size_t length);
|
||||
};
|
||||
|
||||
|
||||
|
||||
86
src/main.cxx
86
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;
|
||||
}
|
||||
|
||||
187
test/CudaMatrix_Test.cpp
Normal file
187
test/CudaMatrix_Test.cpp
Normal file
@@ -0,0 +1,187 @@
|
||||
#include <gtest/gtest.h>
|
||||
#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]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<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);
|
||||
float* input = new float[10]{1,2,3,4,5,6,7,8,9,10};
|
||||
Aurora::Matrix m(std::shared_ptr<float>(input,std::default_delete<float[]>()),std::vector<int>{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<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);
|
||||
float* input2 = new float[10]{1,2,3,4,5,6,7,8,9,10};
|
||||
Aurora::Matrix m2(std::shared_ptr<float>(input2,std::default_delete<float[]>()),std::vector<int>{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<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);
|
||||
float* input3 = new float[10]{1,2,3,4,5,6,7,8,9,10};
|
||||
Aurora::Matrix m3(std::shared_ptr<float>(input3,std::default_delete<float[]>()),std::vector<int>{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<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);
|
||||
float* input4 = new float[10]{1,2,3,4,5,6,7,8,9,10};
|
||||
Aurora::Matrix m4(std::shared_ptr<float>(input4,std::default_delete<float[]>()),std::vector<int>{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<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});
|
||||
float* xD= new float[5]{1,2,3,4,5};
|
||||
Aurora::Matrix x(std::shared_ptr<float>(xD,std::default_delete<float[]>()),std::vector<int>{5});
|
||||
float* yD= new float[5]{1,4,9,16,25};
|
||||
Aurora::Matrix y(std::shared_ptr<float>(yD,std::default_delete<float[]>()),std::vector<int>{5});
|
||||
float* x1D= new float[3]{1.22,2.69,3.84};
|
||||
Aurora::Matrix x1(std::shared_ptr<float>(x1D,std::default_delete<float[]>()),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);
|
||||
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<double>::infinity();
|
||||
float n=std::nan("");
|
||||
float infinite=std::numeric_limits<float>::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);
|
||||
}
|
||||
|
||||
@@ -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<double>* result = (std::complex<double>*)fftrett.getData();
|
||||
std::complex<float>* result = (std::complex<float>*)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<double>* ifftResult = (std::complex<double>*)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<float>* ifftResult = (std::complex<float>*)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<double>*)fftrett2.getData();
|
||||
auto result2 = (std::complex<float>*)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<double>*)fftrett3.getData();
|
||||
auto result3 = (std::complex<float>*)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<double>*)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<float>*)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<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
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});
|
||||
double* y1D= new double[3]{4.5823,10.552,18};
|
||||
Aurora::Matrix y1(std::shared_ptr<double>(y1D,std::default_delete<double[]>()),std::vector<int>{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<double>(vD,std::default_delete<double[]>()),std::vector<int>{5,4});
|
||||
float* xD= new float[4]{1,2,3,4};
|
||||
Aurora::Matrix x(std::shared_ptr<float>(xD,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* yD= new float[5]{1,4,9,16,25};
|
||||
Aurora::Matrix y(std::shared_ptr<float>(yD,std::default_delete<float[]>()),std::vector<int>{5});
|
||||
float* x1D= new float[3]{1.22,2.69,3.84};
|
||||
Aurora::Matrix x1(std::shared_ptr<float>(x1D,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* y1D= new float[3]{4.5823,10.552,18};
|
||||
Aurora::Matrix y1(std::shared_ptr<float>(y1D,std::default_delete<float[]>()),std::vector<int>{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<float>(vD,std::default_delete<float[]>()),std::vector<int>{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<double>(dI1,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
double* dI2= new double[4]{2,2,1,1};
|
||||
Aurora::Matrix I2(std::shared_ptr<double>(dI2,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
double* dI4= new double[4]{1,1,2,2};
|
||||
Aurora::Matrix I3(std::shared_ptr<double>(dI4,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
double* dsz= new double[3]{2,2,2};
|
||||
Aurora::Matrix sz(std::shared_ptr<double>(dsz,std::default_delete<double[]>()),std::vector<int>{3});
|
||||
float* dI1= new float[4]{1,2,1,2};
|
||||
Aurora::Matrix I1(std::shared_ptr<float>(dI1,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* dI2= new float[4]{2,2,1,1};
|
||||
Aurora::Matrix I2(std::shared_ptr<float>(dI2,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* dI4= new float[4]{1,1,2,2};
|
||||
Aurora::Matrix I3(std::shared_ptr<float>(dI4,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* dsz= new float[3]{2,2,2};
|
||||
Aurora::Matrix sz(std::shared_ptr<float>(dsz,std::default_delete<float[]>()),std::vector<int>{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]);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -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<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
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* zD= new double[3]{22,33,56};
|
||||
Aurora::Matrix z(std::shared_ptr<double>(zD,std::default_delete<double[]>()),std::vector<int>{3});
|
||||
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});
|
||||
double* y1D= new double[3]{4.5823,10.552,18};
|
||||
Aurora::Matrix y1(std::shared_ptr<double>(y1D,std::default_delete<double[]>()),std::vector<int>{3});
|
||||
double* z1D= new double[3]{22.256,40.22,48};
|
||||
Aurora::Matrix z1(std::shared_ptr<double>(z1D,std::default_delete<double[]>()),std::vector<int>{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<float>(xD,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* yD= new float[5]{1,4,9,16,25};
|
||||
Aurora::Matrix y(std::shared_ptr<float>(yD,std::default_delete<float[]>()),std::vector<int>{5});
|
||||
float* zD= new float[3]{22,33,56};
|
||||
Aurora::Matrix z(std::shared_ptr<float>(zD,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* x1D= new float[3]{1.22,2.69,3.84};
|
||||
Aurora::Matrix x1(std::shared_ptr<float>(x1D,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* y1D= new float[3]{4.5823,10.552,18};
|
||||
Aurora::Matrix y1(std::shared_ptr<float>(y1D,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* z1D= new float[3]{22.256,40.22,48};
|
||||
Aurora::Matrix z1(std::shared_ptr<float>(z1D,std::default_delete<float[]>()),std::vector<int>{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<double>(vD,std::default_delete<double[]>()),std::vector<int>{5,4,3});
|
||||
Aurora::Matrix v(std::shared_ptr<float>(vD,std::default_delete<float[]>()),std::vector<int>{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<double>(xD,std::default_delete<double[]>()),std::vector<int>{4});
|
||||
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* zD= new double[3]{22,33,56};
|
||||
Aurora::Matrix z(std::shared_ptr<double>(zD,std::default_delete<double[]>()),std::vector<int>{3});
|
||||
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});
|
||||
double* y1D= new double[3]{2.5823,3.552,3.888};
|
||||
Aurora::Matrix y1(std::shared_ptr<double>(y1D,std::default_delete<double[]>()),std::vector<int>{3});
|
||||
double* z1D= new double[3]{22.256,40.22,48};
|
||||
Aurora::Matrix z1(std::shared_ptr<double>(z1D,std::default_delete<double[]>()),std::vector<int>{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<double>(v2D,std::default_delete<double[]>()),std::vector<int>{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<float>(xD,std::default_delete<float[]>()),std::vector<int>{4});
|
||||
float* yD= new float[5]{1,4,9,16,25};
|
||||
Aurora::Matrix y(std::shared_ptr<float>(yD,std::default_delete<float[]>()),std::vector<int>{5});
|
||||
float* zD= new float[3]{22,33,56};
|
||||
Aurora::Matrix z(std::shared_ptr<float>(zD,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* x1D= new float[3]{1.22,2.69,3.84};
|
||||
Aurora::Matrix x1(std::shared_ptr<float>(x1D,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* y1D= new float[3]{2.5823,3.552,3.888};
|
||||
Aurora::Matrix y1(std::shared_ptr<float>(y1D,std::default_delete<float[]>()),std::vector<int>{3});
|
||||
float* z1D= new float[3]{22.256,40.22,48};
|
||||
Aurora::Matrix z1(std::shared_ptr<float>(z1D,std::default_delete<float[]>()),std::vector<int>{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<float>(v2D,std::default_delete<float[]>()),std::vector<int>{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<double>(v3D,std::default_delete<double[]>()),std::vector<int>{5,4,3});
|
||||
Aurora::Matrix v3(std::shared_ptr<float>(v3D,std::default_delete<float[]>()),std::vector<int>{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："<<i;
|
||||
EXPECT_FLOAT_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
}
|
||||
|
||||
onesM = Aurora::ones( 9, 9);
|
||||
EXPECT_EQ(81,onesM.getDataSize());
|
||||
for (int i = 0; i < onesM.getDataSize(); ++i) {
|
||||
EXPECT_DOUBLE_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
EXPECT_FLOAT_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
}
|
||||
|
||||
onesM = Aurora::ones( 9, 1);
|
||||
EXPECT_EQ(9,onesM.getDataSize());
|
||||
for (int i = 0; i < onesM.getDataSize(); ++i) {
|
||||
EXPECT_DOUBLE_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
EXPECT_FLOAT_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
}
|
||||
|
||||
onesM = Aurora::ones( 9);
|
||||
EXPECT_EQ(81,onesM.getDataSize());
|
||||
for (int i = 0; i < onesM.getDataSize(); ++i) {
|
||||
EXPECT_DOUBLE_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
EXPECT_FLOAT_EQ(1.0,onesM.getData()[i])<<" error at index："<<i;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -25,10 +25,10 @@ protected:
|
||||
};
|
||||
|
||||
TEST_F(Matrix_Test, MatrixCreate) {
|
||||
double *dataA = Aurora::malloc(9);
|
||||
double *dataB = new double[9];
|
||||
double *dataC = new double[9];
|
||||
double *dataD = new double[9];
|
||||
float *dataA = Aurora::malloc(9);
|
||||
float *dataB = new float[9];
|
||||
float *dataC = new float[9];
|
||||
float *dataD = new float[9];
|
||||
//mkl matrix
|
||||
{
|
||||
Aurora::Matrix A = Aurora::Matrix::New(dataA, 3, 3);
|
||||
@@ -40,7 +40,7 @@ TEST_F(Matrix_Test, MatrixCreate) {
|
||||
EXPECT_EQ(Aurora::Normal, A.getValueType());
|
||||
DISPLAY_MATRIX(A);
|
||||
}
|
||||
// double [] matrix
|
||||
// float [] matrix
|
||||
{
|
||||
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 3, 3);
|
||||
EXPECT_EQ(dataB, B.getData());
|
||||
@@ -51,7 +51,7 @@ TEST_F(Matrix_Test, MatrixCreate) {
|
||||
EXPECT_EQ(Aurora::Normal, B.getValueType());
|
||||
DISPLAY_MATRIX(B);
|
||||
}
|
||||
// copy from double [] to mkl matrix
|
||||
// copy from float [] to mkl matrix
|
||||
{
|
||||
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 3, 3);
|
||||
EXPECT_NE(dataC, C.getData());
|
||||
@@ -98,7 +98,7 @@ TEST_F(Matrix_Test, MatrixCreate) {
|
||||
}
|
||||
// 3d matrix
|
||||
{
|
||||
double *tempData = new double[9];
|
||||
float *tempData = new float[9];
|
||||
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3, 1);
|
||||
EXPECT_EQ(dataD, C.getData());
|
||||
EXPECT_EQ(9, C.getDataSize());
|
||||
@@ -111,7 +111,7 @@ TEST_F(Matrix_Test, MatrixCreate) {
|
||||
}
|
||||
// 3d matrix 2
|
||||
{
|
||||
double *tempData = new double[9];
|
||||
float *tempData = new float[9];
|
||||
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 1, 3);
|
||||
EXPECT_EQ(tempData, C.getData());
|
||||
EXPECT_EQ(9, C.getDataSize());
|
||||
@@ -125,13 +125,13 @@ TEST_F(Matrix_Test, MatrixCreate) {
|
||||
}
|
||||
|
||||
TEST_F(Matrix_Test, matrixSlice) {
|
||||
double *dataA = Aurora::malloc(8);
|
||||
double *dataB = Aurora::malloc(8);
|
||||
double *dataC = Aurora::malloc(8);
|
||||
float *dataA = Aurora::malloc(8);
|
||||
float *dataB = Aurora::malloc(8);
|
||||
float *dataC = Aurora::malloc(8);
|
||||
for (int i = 0; i < 8; ++i) {
|
||||
dataA[i] = (double) (i);
|
||||
dataB[i] = (double) (1);
|
||||
dataC[i] = (double) (9 - i);
|
||||
dataA[i] = (float) (i);
|
||||
dataB[i] = (float) (1);
|
||||
dataC[i] = (float) (9 - i);
|
||||
}
|
||||
Aurora::Matrix A = Aurora::Matrix::New(dataA, 2, 2, 2);
|
||||
Aurora::Matrix B = Aurora::Matrix::New(dataB, 2, 2, 2);
|
||||
@@ -158,9 +158,9 @@ TEST_F(Matrix_Test, matrixSlice) {
|
||||
EXPECT_EQ(9, D.getData()[0]);
|
||||
|
||||
|
||||
double *dataD = Aurora::malloc(27);
|
||||
float *dataD = Aurora::malloc(27);
|
||||
for (int i = 0; i < 27; ++i) {
|
||||
dataD[i] = (double) (i);
|
||||
dataD[i] = (float) (i);
|
||||
}
|
||||
Aurora::Matrix D1 = Aurora::Matrix::New(dataD, 3, 3, 3);
|
||||
auto r1 = D1.block(0, 0, 1);
|
||||
@@ -177,12 +177,12 @@ TEST_F(Matrix_Test, matrixSlice) {
|
||||
TEST_F(Matrix_Test, matrixOpertaor) {
|
||||
//3D
|
||||
{
|
||||
double *dataA = new double[8];
|
||||
double *dataB = new double[8];
|
||||
double *dataD = new double[8];
|
||||
float *dataA = new float[8];
|
||||
float *dataB = new float[8];
|
||||
float *dataD = 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, 2, 2, 2);
|
||||
DISPLAY_MATRIX(A);
|
||||
@@ -203,13 +203,13 @@ TEST_F(Matrix_Test, matrixOpertaor) {
|
||||
}
|
||||
//complex
|
||||
{
|
||||
double *dataA = Aurora::malloc(8, true);
|
||||
double *dataB = Aurora::malloc(8, true);
|
||||
double *dataD = new double[8];
|
||||
float *dataA = Aurora::malloc(8, true);
|
||||
float *dataB = Aurora::malloc(8, true);
|
||||
float *dataD = new float[8];
|
||||
for (int i = 0; i < 16; ++i) {
|
||||
dataA[i] = (double) (i + 1);
|
||||
dataB[i] = (double) (2);
|
||||
if (i < 8) dataD[i] = (double) (2);
|
||||
dataA[i] = (float) (i + 1);
|
||||
dataB[i] = (float) (2);
|
||||
if (i < 8) dataD[i] = (float) (2);
|
||||
}
|
||||
Aurora::Matrix A = Aurora::Matrix::New(dataA, 2, 2, 2, Aurora::Complex);
|
||||
DISPLAY_MATRIX(A);
|
||||
@@ -302,11 +302,11 @@ TEST_F(Matrix_Test, matrixOpertaor) {
|
||||
}
|
||||
|
||||
TEST_F(Matrix_Test, matrixCompare){
|
||||
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, 2, 2, 2);
|
||||
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 2, 2, 2);
|
||||
@@ -374,33 +374,33 @@ TEST_F(Matrix_Test, matrixCompare){
|
||||
}
|
||||
|
||||
TEST_F(Matrix_Test, matrixfunction){
|
||||
double *dataA = new double[9]{1,6,9,4,1,0,5,8,1};
|
||||
double *dataB = new double[3]{1,2,3};
|
||||
float *dataA = new float[9]{1,6,9,4,1,0,5,8,1};
|
||||
float *dataB = new float[3]{1,2,3};
|
||||
Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA, 3, 3);
|
||||
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 1, 3);
|
||||
auto C = B.mul(A);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[0], 40);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[1], 6);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[2], 24);
|
||||
EXPECT_FLOAT_EQ(C.getData()[0], 40);
|
||||
EXPECT_FLOAT_EQ(C.getData()[1], 6);
|
||||
EXPECT_FLOAT_EQ(C.getData()[2], 24);
|
||||
B.forceReshape(3, 1, 1);
|
||||
C = A.mul(B);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[0], 24);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[1], 32);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[2], 12);
|
||||
double *dataD = new double[9]{2.1,3,9,-3,1,0,51,-8,1};
|
||||
EXPECT_FLOAT_EQ(C.getData()[0], 24);
|
||||
EXPECT_FLOAT_EQ(C.getData()[1], 32);
|
||||
EXPECT_FLOAT_EQ(C.getData()[2], 12);
|
||||
float *dataD = new float[9]{2.1,3,9,-3,1,0,51,-8,1};
|
||||
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD, 3, 3);
|
||||
C = A.mul(D);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[0], 59.1);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[1], 87.6);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[2], 27.9);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[3], 1);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[4], -17);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[5], -27);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[6], 24);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[7], 306);
|
||||
EXPECT_DOUBLE_EQ(C.getData()[8], 460);
|
||||
EXPECT_FLOAT_EQ(C.getData()[0], 59.1);
|
||||
EXPECT_FLOAT_EQ(C.getData()[1], 87.6);
|
||||
EXPECT_FLOAT_EQ(C.getData()[2], 27.9);
|
||||
EXPECT_FLOAT_EQ(C.getData()[3], 1);
|
||||
EXPECT_FLOAT_EQ(C.getData()[4], -17);
|
||||
EXPECT_FLOAT_EQ(C.getData()[5], -27);
|
||||
EXPECT_FLOAT_EQ(C.getData()[6], 24);
|
||||
EXPECT_FLOAT_EQ(C.getData()[7], 306);
|
||||
EXPECT_FLOAT_EQ(C.getData()[8], 460);
|
||||
|
||||
double *dataE = Aurora::random(60);
|
||||
float *dataE = Aurora::random(60);
|
||||
Aurora::Matrix E = Aurora::Matrix::New(dataE, 3, 4, 5);
|
||||
Aurora::Matrix block1 = E.block(0, 1, 2);
|
||||
for (size_t i = 0; i < block1.getDimSize(2); i++)
|
||||
@@ -411,7 +411,7 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
{
|
||||
auto index1 = k+j*E.getDimSize(0)+i*E.getDimSize(1)*E.getDimSize(0);
|
||||
auto index2 = k-1+j*block1.getDimSize(0)+i*block1.getDimSize(1)*block1.getDimSize(0);
|
||||
EXPECT_DOUBLE_AE(E[index1],block1[index2]);
|
||||
EXPECT_FLOAT_AE(E[index1],block1[index2]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -422,7 +422,7 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
{
|
||||
for (size_t k = 1; k < E.getDimSize(0); k++)
|
||||
{
|
||||
EXPECT_DOUBLE_AE(E(k,i,j).toMatrix().getScalar(),-1);
|
||||
EXPECT_FLOAT_AE(E(k,i,j).toMatrix().getScalar(),-1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -432,7 +432,7 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
{
|
||||
for (size_t j = 0; j < 5; j++)
|
||||
{
|
||||
EXPECT_DOUBLE_AE(E(0,i,j).toMatrix().getScalar(), 0.0);
|
||||
EXPECT_FLOAT_AE(E(0,i,j).toMatrix().getScalar(), 0.0);
|
||||
}
|
||||
}
|
||||
auto z2 = Aurora::zeros(3,2,5);
|
||||
@@ -444,7 +444,7 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
{
|
||||
for (size_t k = 0; k < 3; k++)
|
||||
{
|
||||
EXPECT_DOUBLE_AE(E(k,i,j).toMatrix().getScalar(), 0.0);
|
||||
EXPECT_FLOAT_AE(E(k,i,j).toMatrix().getScalar(), 0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -458,7 +458,7 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
{
|
||||
for (size_t k = 0; k < 3; k++)
|
||||
{
|
||||
EXPECT_DOUBLE_AE(E(k,i,j).toMatrix().getScalar(), 1.0);
|
||||
EXPECT_FLOAT_AE(E(k,i,j).toMatrix().getScalar(), 1.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -467,7 +467,8 @@ TEST_F(Matrix_Test, matrixfunction){
|
||||
EXPECT_TRUE(ZZ.setBlock(1, 10, 19, OO));
|
||||
for (size_t i = 0; i < ZZ.getDataSize(); i++)
|
||||
{
|
||||
EXPECT_DOUBLE_AE(ZZ[i], i>9?1.0:0.0);
|
||||
EXPECT_FLOAT_AE(ZZ[i], i>9?1.0:0.0);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user