Aurora/test/FunctionTester.cpp

#include <gtest/gtest.h>
#include "Matrix.h"
#include "Function.h"
#include "Function1D.h"
#include "Function2D.h"


#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #Matrix);

#define DISPLAY_MATRIX


class FunctionTester:public ::testing::Test{
protected:
    static void SetUpFunctionTester(){

    }
    static void TearDownTestCase(){
    }
    void SetUp(){
    }
    void TearDown(){
    }
};

double fourDecimalRound(double src){
    return round(src*10000.0)/10000.0;
}


TEST_F(FunctionTester, MatrixCreate) {
    double * dataA =Aurora::malloc(9);
    double * dataB = new double[9];
    double * dataC = new double[9];
    double * dataD = new double[9];
    //mkl matrix
    {
        Aurora::Matrix A = Aurora::Matrix::New(dataA, 3, 3);
        EXPECT_EQ(dataA, A.getData());
        EXPECT_EQ(9, A.getDataSize());
        EXPECT_EQ(2, A.getDims());
        EXPECT_EQ(3, A.getDimSize(0));
        EXPECT_EQ(3, A.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, A.getValueType());
        DISPLAY_MATRIX(A);
    }
    // double [] matrix
    {
        Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 3, 3);
        EXPECT_EQ(dataB, B.getData());
        EXPECT_EQ(9, B.getDataSize());
        EXPECT_EQ(2, B.getDims());
        EXPECT_EQ(3, B.getDimSize(0));
        EXPECT_EQ(3, B.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, B.getValueType());
        DISPLAY_MATRIX(B);
    }
    // copy from double [] to mkl matrix
    {
        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 3, 3);
        EXPECT_NE(dataC, C.getData());
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(2, C.getDims());
        EXPECT_EQ(3, C.getDimSize(0));
        EXPECT_EQ(3, C.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
    // 2vector
    {
        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 9);
        EXPECT_NE(dataC, C.getData());
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(2, C.getDims());
        EXPECT_EQ(9, C.getDimSize(0));
        EXPECT_EQ(1, C.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
    // 2d vector
    {
        Aurora::Matrix C = Aurora::Matrix::fromRawData(dataC, 9, 1);
        EXPECT_EQ(dataC, C.getData());
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(2, C.getDims());
        EXPECT_EQ(9, C.getDimSize(0));
        EXPECT_EQ(1, C.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
    // 2d vector column major
    {
        Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataD, 1, 9);
        EXPECT_NE(dataD, C.getData());
        delete [] dataD;
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(2, C.getDims());
        EXPECT_EQ(1, C.getDimSize(0));
        EXPECT_EQ(9, C.getDimSize(1));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
    // 3d matrix
    {
        double * tempData = new double[9];
        Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3,1);
        EXPECT_EQ(dataD, C.getData());
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(2, C.getDims());
        EXPECT_EQ(3, C.getDimSize(0));
        EXPECT_EQ(3, C.getDimSize(1));
        EXPECT_EQ(1, C.getDimSize(2));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
    // 3d matrix 2
    {
        double * tempData = new double[9];
        Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 1,3);
        EXPECT_EQ(dataD, C.getData());
        EXPECT_EQ(9, C.getDataSize());
        EXPECT_EQ(3, C.getDims());
        EXPECT_EQ(3, C.getDimSize(0));
        EXPECT_EQ(1, C.getDimSize(1));
        EXPECT_EQ(3, C.getDimSize(2));
        EXPECT_EQ(Aurora::Normal, C.getValueType());
        DISPLAY_MATRIX(C);
    }
}

TEST_F(FunctionTester, matrixSlice) {
    double * dataA =Aurora::malloc(8);
    double * dataB =Aurora::malloc(8);
    double * dataC =Aurora::malloc(8);
    for (int i = 0; i < 8; ++i) {
        dataA[i]=(double)(i);
        dataB[i]=(double)(1);
        dataC[i]=(double)(9-i);
    }
    Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2);
    Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2);
    Aurora::Matrix C = Aurora::Matrix::New(dataC,2,2,2);
    //2D slice
    EXPECT_EQ(4.0,dataA[4]);
    A(Aurora::$,Aurora::$,1) = B(0,Aurora::$,Aurora::$);
    EXPECT_EQ(1,dataA[4]);
    EXPECT_EQ(3,dataA[3]);
    A(Aurora::$,1,Aurora::$) = B(Aurora::$,Aurora::$,0);
    EXPECT_EQ(1.0,dataA[3]);
    EXPECT_EQ(0.0,dataA[0]);
    A(0,Aurora::$,Aurora::$) = B(Aurora::$,0,Aurora::$);
    EXPECT_EQ(1.0,dataA[0]);
    //vector slice
    A(0,Aurora::$,0) = C(0,0,Aurora::$);
    EXPECT_EQ(9.0,dataA[0]);
    A(Aurora::$,0,0) = C(0,Aurora::$,1);
    EXPECT_EQ(5.0,dataA[0]);
    //error slice
    EXPECT_EQ(1,A(Aurora::$,Aurora::$,Aurora::$).toMatrix().getDataSize() );
    auto D =C(0,0,0).toMatrix();
    EXPECT_EQ(1,D.getDataSize() );
    EXPECT_EQ(9,D.getData()[0] );
}

TEST_F(FunctionTester, matrixOpertaor) {
    //3D
    {
        double * dataA =new double[8];
        double * dataB =new double[8];
        double * dataD =new double[8];
        for (int i = 0; i < 8; ++i) {
            dataA[i]=(double)(i);
            dataB[i]=(double)(2);
        }
        Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,2,2,2);
        DISPLAY_MATRIX(A);
        Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,2,2,2);
        DISPLAY_MATRIX(B);
        Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,4,2);
        DISPLAY_MATRIX(D);
        auto C = (A*B)-B;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],2);
        C = A*B/2.0;
        EXPECT_EQ(C.getData()[2],2);
        C = (A*8.0/B) * (B+1.0)-2.0+8;
        EXPECT_EQ(C.getData()[2],30);
        //Error matrix
        C = A*D;
        EXPECT_EQ(C.getDataSize(),0);
    }
    //complex
    {
        double * dataA =Aurora::malloc(8,true);
        double * dataB =Aurora::malloc(8,true);
        double * dataD =new double[8];
        for (int i = 0; i < 16; ++i) {
            dataA[i]=(double)(i+1);
            dataB[i]=(double)(2);
            if(i<8) dataD[i]=(double)(2);
        }
        Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2,Aurora::Complex);
        DISPLAY_MATRIX(A);
        Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2,Aurora::Complex);
        DISPLAY_MATRIX(B);
        Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,2,2,2);
        DISPLAY_MATRIX(D);
        auto C = A + 5.0 -2.0;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],6);
        EXPECT_EQ(C.getData()[3],4);
        EXPECT_TRUE(C.isComplex());
        C = A*B-B;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],-4);
        EXPECT_EQ(C.getData()[3],12);
        EXPECT_TRUE(C.isComplex());
        C = A*B-2.0+5.0;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],1);
        EXPECT_EQ(C.getData()[3],14);
        C = A*B/2.0*3.;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],-3);
        EXPECT_EQ(C.getData()[3],21);
        C = A*B/B;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],3);
        EXPECT_EQ(C.getData()[3],4);
        C = A*B/(B*A/A);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],3);
        EXPECT_EQ(C.getData()[3],4);

        C = B*D;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],4);
        C = B/D;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],1);
        EXPECT_EQ(C.getData()[3],1);
        C = B+D;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],2);
        C = B-D;
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],0);
        EXPECT_EQ(C.getData()[3],2);

        C = B*(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],4);
        C = B/(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],1);
        EXPECT_EQ(C.getData()[3],1);
        C = B+(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],2);
        C = B-(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],0);
        EXPECT_EQ(C.getData()[3],2);

        C = (B*1.0)*(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],4);
        C = (B*1.0)/(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],1);
        EXPECT_EQ(C.getData()[3],1);
        C = (B*1.0)+(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],4);
        EXPECT_EQ(C.getData()[3],2);
        C = (B*1.0)-(D*1.0);
        DISPLAY_MATRIX(C);
        EXPECT_EQ(C.getData()[2],0);
        EXPECT_EQ(C.getData()[3],2);
    }
}

TEST_F(FunctionTester, sign) {
    double * dataA =Aurora::malloc(9);
    double * dataB =Aurora::malloc(9);
    for (int i = 0; i < 9; ++i) {
        dataA[i]=(double)(i-3);
        dataB[i]=(double)(i+2);
    }
    Aurora::Matrix A = Aurora::Matrix::New(dataA,3,3);
    Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
    auto C = sign(A*B);
    double * result = C.getData();
    EXPECT_EQ(-1, result[0]);
    EXPECT_EQ(0, result[3]);
    EXPECT_EQ(1, result[4]);
}


TEST_F(FunctionTester, immse){
    double *dataA = new double[9]{1,2,3,4,5,6,7,8,9};
    double *dataB = new double[9]{10,20,30,40,50,40,30,20,10};
    Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,3,3);
    Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,3,3);
    double v = immse(A,B);
    EXPECT_DOUBLE_EQ(fourDecimalRound(v),698.3333)<<" immse error;";
}

TEST_F(FunctionTester, 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};
    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]));
    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]));
}

TEST_F(FunctionTester, polyval){
    double dataP[3]={3,2,1};
    double dataX[3]={5,7,9};
    double*resultP = Aurora::polyval(dataX,dataP,3);
    EXPECT_DOUBLE_EQ(86., resultP[0])<<" polyval error;";
    EXPECT_DOUBLE_EQ(162., resultP[1])<<" polyval error;";
    EXPECT_DOUBLE_EQ(262., resultP[2])<<" polyval error;";
    delete [] resultP;
}

TEST_F(FunctionTester, std){
    double dataMA[9]={1, 2, 3, 2, 2, 6, 3, 3, 6};
    double* resultStd = Aurora::std(3, 3, dataMA);
    EXPECT_DOUBLE_EQ(1.0, resultStd[0])<<" std error index 0";
    EXPECT_DOUBLE_EQ(2.3094, fourDecimalRound(resultStd[1]))<<" std error index 1";
    EXPECT_DOUBLE_EQ(1.7321, fourDecimalRound(resultStd[2]))<<" std error index 2";
    delete [] resultStd;
}

TEST_F(FunctionTester, fftAndComplexAndIfft){
    double input[10]{1,1,0,2,2,0,1,1,0,2};
    std::complex<double>* complexInput = Aurora::complex(10,input);
    //复数化后，实部不变，虚部全为0
    EXPECT_DOUBLE_EQ(complexInput[1].real(),1.0)<<" complex error";
    EXPECT_DOUBLE_EQ(complexInput[1].imag(),0)<<" complex error";
    std::complex<double>* result = Aurora::fft(10,complexInput);
    delete [] complexInput;
    //检验fft结果与matlab是否对应
    EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real()))<<" fft result value error";
    EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag()))<<" fft result value error";
    //检验fft的结果是否共轭
    EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag())<<" fft result conjugate error";
    EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real())<<" fft result conjugate error";
    std::complex<double>* ifftResult = Aurora::ifft(10,result);
    EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0)<<" ifft result real value error";
    EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].imag()),0)<<" ifft result imag value error";
    delete [] result;
    delete [] ifftResult;
}

TEST_F(FunctionTester, hilbert) {
    double input[10]{1,1,0,2,2,0,1,1,0,2};
    auto result = Aurora::hilbert(10,input);
    EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].real()),1.0)<<" hilbert result real value error";
    EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].imag()),0.3249)<<" hilbert result imag value error";
    delete [] result;
    result = Aurora::hilbert(9,input);
    EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].real()),1.0)<<" hilbert result real value error";
    EXPECT_DOUBLE_EQ(fourDecimalRound(result[1].imag()),0.4253)<<" hilbert result imag value error";
}