Aurora/test/FunctionTester.cpp

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


#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #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) {
    printf("1");
    double * dataA =Aurora::malloc(9);
    double * dataB = new double[9];
    double * dataC = new double[9];
    double * dataD = new double[9];
    //mkl matrix
    {
        printf("2");
        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);
    printf("A:\r\n");
    A.printf();
    Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2);
    printf("B:\r\n");
    B.printf();
    Aurora::Matrix C = Aurora::Matrix::New(dataC,2,2,2);
    printf("C:\r\n");
    C.printf();
    //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];
        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)
        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*B*B/2.0;
        EXPECT_EQ(C.getData()[2],4);
    }

}

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);
    printf("A:\r\n");
    A.printf();
    Aurora::Matrix B = Aurora::Matrix::New(dataB,3,3);
    printf("B:\r\n");
    B.printf();
    printf("sign(A):\r\n");
    sign(A*B).printf();
}


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

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, inv){
    //默认是column major排布数据
    double dataMA[9]={2, 0, 2, 2, 3, 0, 3, 3, 3};
    double* result = Aurora::inv(3,dataMA);
    EXPECT_DOUBLE_EQ(0.75, fourDecimalRound(result[0]))<<" inv value error";
    EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[1]))<<" inv value error";
    EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[2]))<<" inv value error";
    EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[3]))<<" inv value error";
    EXPECT_DOUBLE_EQ(.0, fourDecimalRound(result[4]))<<" inv value error";
    EXPECT_DOUBLE_EQ(0.3333, fourDecimalRound(result[5]))<<" inv value error";
    EXPECT_DOUBLE_EQ(-0.25, fourDecimalRound(result[6]))<<" inv value error";
    EXPECT_DOUBLE_EQ(-0.5, fourDecimalRound(result[7]))<<" inv value error";
    EXPECT_DOUBLE_EQ(0.5, fourDecimalRound(result[8]))<<" inv value error";
    delete [] result;
}

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";
}