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


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

#define EXPECT_DOUBLE_AE(valueA,valueB)\
    EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB));

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

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

    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);

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

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

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

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

    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);

    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);

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