249 lines
9.6 KiB
C++
249 lines
9.6 KiB
C++
#include <gtest/gtest.h>
|
|
#include <vector>
|
|
|
|
#include "TestUtility.h"
|
|
|
|
#include "Matrix.h"
|
|
#include "Function.h"
|
|
#include "Function1D.h"
|
|
#include "Function2D.h"
|
|
#include "Function3D.h"
|
|
|
|
|
|
class Function1D_Test:public ::testing::Test{
|
|
protected:
|
|
static void SetUpFunction1DTester(){
|
|
|
|
}
|
|
static void TearDownTestCase(){
|
|
}
|
|
void SetUp(){
|
|
}
|
|
void TearDown(){
|
|
}
|
|
|
|
};
|
|
|
|
TEST_F(Function1D_Test, sign) {
|
|
double * dataA =Aurora::malloc(9);
|
|
double * dataB =Aurora::malloc(9);
|
|
for (int i = 0; i < 9; ++i) {
|
|
dataA[i]=(double)(i-3);
|
|
dataB[i]=(double)(i+2);
|
|
}
|
|
Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3);
|
|
Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
|
|
auto C = sign(A*B);
|
|
double * result = C.getData();
|
|
EXPECT_EQ(-1, result[0]);
|
|
EXPECT_EQ(0, result[3]);
|
|
EXPECT_EQ(1, result[4]);
|
|
C = sign(A);
|
|
result = C.getData();
|
|
EXPECT_EQ(-1, result[0]);
|
|
EXPECT_EQ(0, result[3]);
|
|
EXPECT_EQ(1, result[4]);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, repmat) {
|
|
//input 1D repmat 2D
|
|
double* input = new double[10]{1,2,3,4,5,6,7,8,9,10};
|
|
Aurora::Matrix m(std::shared_ptr<double>(input,std::default_delete<double[]>()),std::vector<int>{10});
|
|
EXPECT_DOUBLE_EQ(repmat(m,1,1).getData()[7],8);
|
|
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDataSize(),60);
|
|
EXPECT_DOUBLE_EQ(repmat(m,2,3).getData()[22],3);
|
|
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(0),20);
|
|
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(1),3);
|
|
EXPECT_DOUBLE_EQ(repmat(m,2,3).getDimSize(2),1);
|
|
|
|
//input 2D repmat 2D
|
|
double* input2 = new double[10]{1,2,3,4,5,6,7,8,9,10};
|
|
Aurora::Matrix m2(std::shared_ptr<double>(input2,std::default_delete<double[]>()),std::vector<int>{5,2});
|
|
EXPECT_DOUBLE_EQ(repmat(m2,1,1).getData()[7],8);
|
|
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDataSize(),60);
|
|
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getData()[22],3);
|
|
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(0),10);
|
|
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(1),6);
|
|
EXPECT_DOUBLE_EQ(repmat(m2,2,3).getDimSize(2),1);
|
|
|
|
//input 1D repmat 3D
|
|
double* input3 = new double[10]{1,2,3,4,5,6,7,8,9,10};
|
|
Aurora::Matrix m3(std::shared_ptr<double>(input3,std::default_delete<double[]>()),std::vector<int>{10});
|
|
EXPECT_DOUBLE_EQ(repmat(m3,1,1,1).getData()[7],8);
|
|
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDataSize(),240);
|
|
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getData()[22],3);
|
|
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(0),20);
|
|
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(1),3);
|
|
EXPECT_DOUBLE_EQ(repmat(m3,2,3,4).getDimSize(2),4);
|
|
|
|
//input 2D repmat 3D
|
|
double* input4 = new double[10]{1,2,3,4,5,6,7,8,9,10};
|
|
Aurora::Matrix m4(std::shared_ptr<double>(input4,std::default_delete<double[]>()),std::vector<int>{5,2});
|
|
EXPECT_DOUBLE_EQ(repmat(m4,1,1).getData()[7],8);
|
|
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDataSize(),240);
|
|
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getData()[22],3);
|
|
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(0),10);
|
|
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(1),6);
|
|
EXPECT_DOUBLE_EQ(repmat(m4,2,3,4).getDimSize(2),4);
|
|
|
|
}
|
|
|
|
TEST_F(Function1D_Test, interp1) {
|
|
double* xD= new double[5]{1,2,3,4,5};
|
|
Aurora::Matrix x(std::shared_ptr<double>(xD,std::default_delete<double[]>()),std::vector<int>{5});
|
|
double* yD= new double[5]{1,4,9,16,25};
|
|
Aurora::Matrix y(std::shared_ptr<double>(yD,std::default_delete<double[]>()),std::vector<int>{5});
|
|
double* x1D= new double[3]{1.22,2.69,3.84};
|
|
Aurora::Matrix x1(std::shared_ptr<double>(x1D,std::default_delete<double[]>()),std::vector<int>{3});
|
|
Aurora::Matrix result = interp1(x,y,x1,Aurora::InterpnMethod::Spline);
|
|
EXPECT_DOUBLE_EQ(result.getData()[0],1.4884);
|
|
EXPECT_DOUBLE_EQ(result.getData()[1],7.2361);
|
|
EXPECT_DOUBLE_EQ(result.getData()[2],14.7456);
|
|
|
|
result = interp1(x,y,x1,Aurora::InterpnMethod::Linear);
|
|
EXPECT_DOUBLE_EQ(result.getData()[0],1.66);
|
|
EXPECT_DOUBLE_EQ(result.getData()[1],7.45);
|
|
EXPECT_DOUBLE_EQ(result.getData()[2],14.88);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, polyval){
|
|
double *dataP = new double[3]{3,2,1};
|
|
double *dataX = new double[3]{5,7,9};
|
|
auto matrixP = Aurora::Matrix::fromRawData(dataP,3);
|
|
auto matrixX = Aurora::Matrix::fromRawData(dataX,3);
|
|
auto result = Aurora::polyval(matrixP,matrixX);
|
|
EXPECT_DOUBLE_EQ(86., result.getData()[0]);
|
|
EXPECT_DOUBLE_EQ(162., result.getData()[1]);
|
|
EXPECT_DOUBLE_EQ(262., result.getData()[2]);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, complexAndEtc){
|
|
//complex
|
|
{
|
|
double *dataP =new double[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]);
|
|
}
|
|
//complex & real & imag
|
|
{
|
|
double *dataP =new double[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]);
|
|
|
|
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]);
|
|
}
|
|
}
|
|
|
|
TEST_F(Function1D_Test, ceilAndRound) {
|
|
double *dataP = new double[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]);
|
|
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]);
|
|
|
|
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]);
|
|
|
|
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]);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, absAndSqrt) {
|
|
double *dataP = new double[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]);
|
|
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]));
|
|
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]));
|
|
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_TRUE(isnanf(matrixB.getData()[2]));
|
|
}
|
|
|
|
TEST_F(Function1D_Test, log) {
|
|
double *dataP = new double[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);
|
|
|
|
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);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, exp) {
|
|
double *data1 = new double[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);
|
|
|
|
double *data2 = new double[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);
|
|
}
|
|
|
|
TEST_F(Function1D_Test, mod) {
|
|
double *data = new double[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);
|
|
}
|