#include <gtest/gtest.h>
#include <chrono>
#include "AuroraDefs.h"
#include "CudaMatrix.h"
#include "Function.h"
#include "Matrix.h"
#include "TestUtility.h"

#include "Function2D.h"
#include "Function2D.cuh"

class Function2D_Cuda_Test:public ::testing::Test
{
protected:
    static void SetUpFunction2DCudaTester(){

    }
    static void TearDownTestCase(){
    }
    public:
    Aurora::Matrix B;
    Aurora::CudaMatrix dB;

    void SetUp(){

    }
    void TearDown(){
    }

};

TEST_F(Function2D_Cuda_Test, min)
{
    // big data for test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
    //     Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
    {
        float *dataB = Aurora::random(4096*41472);
        B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);

        auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }


        ret1 = Aurora::min(B, Aurora::FunctionDirection::Row,r,c);

        ret2 = Aurora::min(dB, Aurora::FunctionDirection::Row,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // different size speed 
    // Aurora::Matrix Aurora::min(const Aurora::Matrix &aMatrix,
    //     Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
    // in col wise
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);

        auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        B.forceReshape( 111,3157, 1);
        dB = B.toDeviceMatrix();

        ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);

        ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, float aValue)
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, 500.5f);


        auto ret2 = Aurora::min(dB, 500.5f);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with same size matrix
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157*111);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::min(B, A);

        auto ret2 = Aurora::min(dB, dA);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with col-vec and matrix 
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::min(B, A);

        auto ret2 = Aurora::min(dB, dA);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }

        ret2 = Aurora::min(dA, dB);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with row-vec and matrix 
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(111);
        auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::min(B, A);

        auto ret2 = Aurora::min(dB, dA);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
}

TEST_F(Function2D_Cuda_Test, max)
{
    // big data for test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
    //     Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
    {
        float *dataB = Aurora::random(4096*41472);
        B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
        dB = B.toDeviceMatrix();
        long r,c;
        auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);

        auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }

        ret1 = Aurora::max(B, Aurora::FunctionDirection::Row,r,c);

        ret2 = Aurora::max(dB, Aurora::FunctionDirection::Row,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // different size speed 
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix,
    //     Aurora::FunctionDirection direction, long &rowIdx, long &colIdx)
    // in col wise
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);

        auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        B.forceReshape( 111,3157, 1);
        dB = B.toDeviceMatrix();

        ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);

        ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, float aValue)
    {
        float *dataB = Aurora::random(3157*111);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::max(B, 500.5f);

        auto ret2 = Aurora::max(dB, 500.5f);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with same size matrix
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157*111);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, A);

        auto ret2 = Aurora::max(dB, dA);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with col-vec and matrix 
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(3157);
        auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);
        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;

        auto ret1 = Aurora::max(B, A);

        // mat x vec
        auto ret2 = Aurora::max(dB, dA);
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        // vec x mat
        ret2 = Aurora::max(dA, dB);
        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
    // test
    // Aurora::Matrix Aurora::max(const Aurora::Matrix &aMatrix, 
    //                          const Aurora::Matrix &aOther)
    // with row-vec and matrix 
    {
        float *dataB = Aurora::random(3157*111);
        float *dataA = Aurora::random(111);
        auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);

        B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
        auto dA = A.toDeviceMatrix();
        dB = B.toDeviceMatrix();
        long r,c;
        auto  start_time_ = std::chrono::high_resolution_clock::now();

        auto ret1 = Aurora::max(B, A);
        // mat x vec
        auto ret2 = Aurora::max(dB, dA);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        //vec x mat
        ret2 = Aurora::max(dA, dB);

        ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
    }
}

TEST_F(Function2D_Cuda_Test, sum)
{
    //
    {
        // float *dataB = Aurora::random(4096*50000);
        float* dataB = new float[4096*5000];
        for (size_t i = 0; i < 4096*5000; i++)
        {
            dataB[i] = (i%2==0?1.0f:0.0f);
        }
        
        B = Aurora::Matrix::fromRawData(dataB, 4096, 5000);
        // B = Aurora::Matrix::fromRawData(dataB, 200, 200);

        auto dD = B.toDeviceMatrix();

        auto ret1 = Aurora::sum(B, Aurora::FunctionDirection::All);

        auto ret2 = Aurora::sum(dD, Aurora::FunctionDirection::All);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }


        ret1 = Aurora::sum(B, Aurora::FunctionDirection::Column);

        ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Column);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }


        ret1 = Aurora::sum(B, Aurora::FunctionDirection::Row);

        ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Row);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }
    }
    //complex type
    {
        float* dataB = new float[3000*2000*2];
        for (size_t i = 0; i < 3000*4000; i++)
        {
            dataB[i] = i%2==0?2.0f:1.0f;
        }
        
        B = Aurora::Matrix::fromRawData(dataB,3000, 2000,1,Aurora::Complex);

        auto dD = B.toDeviceMatrix();

        auto ret1 = Aurora::sum(B, Aurora::FunctionDirection::All);

        auto ret2 = Aurora::sum(dD, Aurora::FunctionDirection::All);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize()*2; i++)
        {
            EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }

        ret1 = Aurora::sum(B, Aurora::FunctionDirection::Column);

        ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Column);
        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }


        ret1 = Aurora::sum(B, Aurora::FunctionDirection::Row);

        ret2 = Aurora::sum(dD, Aurora::FunctionDirection::Row);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }
    }
}

TEST_F(Function2D_Cuda_Test, mean)
{
    //
    {
        float* dataB = new float[4096*500];
        for (size_t i = 0; i < 4096*500; i++)
        {
            dataB[i] = (float)(i%2==0?1:0);
        }
        
        B = Aurora::Matrix::fromRawData(dataB, 4096, 500);
        // B = Aurora::Matrix::fromRawData(dataB, 200, 200);

        auto dD = B.toDeviceMatrix();

        auto ret1 = Aurora::mean(B, Aurora::FunctionDirection::All);

        auto ret2 = Aurora::mean(dD, Aurora::FunctionDirection::All);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }


        ret1 = Aurora::mean(B, Aurora::FunctionDirection::Column);

        ret2 = Aurora::mean(dD, Aurora::FunctionDirection::Column);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }


        ret1 = Aurora::mean(B, Aurora::FunctionDirection::Row);

        ret2 = Aurora::mean(dD, Aurora::FunctionDirection::Row);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));

        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_AE(ret1[i], ret2.getValue(i))
        }
    }
}

TEST_F(Function2D_Cuda_Test, sort)
{
    //
    {
        float* dataB = Aurora::random(25000000);
        B = Aurora::Matrix::fromRawData(dataB, 500, 500);
        // B = Aurora::Matrix::fromRawData(dataB, 200, 200);

        auto dD = B.toDeviceMatrix();

        auto ret1 = Aurora::sort(B, Aurora::Column);

        auto ret2 = Aurora::sort(dD,Aurora::Column);

        EXPECT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
        EXPECT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
        EXPECT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
        for (size_t i = 0; i < ret1.getDataSize(); i++)
        {
            EXPECT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
        }
        
    }
}

TEST_F(Function2D_Cuda_Test, immse) {
    auto matrixHost1 = Aurora::Matrix::fromRawData(Aurora::random(10000), 50,200);
    auto matrixHost2 = Aurora::Matrix::fromRawData(Aurora::random(10000), 50,200);
    auto matrixDevice1 = matrixHost1.toDeviceMatrix();
    auto matrixDevice2 = matrixHost1.toDeviceMatrix();
    auto result1 = Aurora::immse(matrixHost1, matrixHost2);
    auto result2 = Aurora::immse(matrixDevice1, matrixDevice2);
    EXPECT_FLOAT_AE(result1, result2);
}

TEST_F(Function2D_Cuda_Test, sortRows) {
    auto matrixHost1 = Aurora::Matrix::fromRawData(Aurora::random(10000), 50,200);
    Aurora::Matrix matrixHost2;
    auto matrixDevice1 = matrixHost1.toDeviceMatrix();
    Aurora::CudaMatrix matrixDevice2;
    auto result1 = Aurora::sortrows(matrixHost1, &matrixHost2);
    auto result2 = Aurora::sortrows(matrixDevice1, matrixDevice2).toHostMatrix();
    auto result3 = matrixHost2;
    auto result4 = matrixDevice2.toHostMatrix();
    ASSERT_FLOAT_EQ(result1.getDataSize(), result2.getDataSize());
    for (size_t i = 0; i < result1.getDataSize(); i++)
    {
        ASSERT_FLOAT_EQ(result1[i], result2[i]);
    }

    ASSERT_FLOAT_EQ(result3.getDataSize(), result4.getDataSize());
    for (size_t i = 0; i < result3.getDataSize(); i++)
    {
        ASSERT_FLOAT_EQ(result3[i], result4[i]);
    }
}

TEST_F(Function2D_Cuda_Test, inv) {
    auto matrixHost = Aurora::Matrix::fromRawData(new float[16]{4,6,7,8,9,3,7,5,4,3,2,1,2,3,4,5}, 4,4);
    auto matrixDevice = matrixHost.toDeviceMatrix();
    auto result1 = Aurora::inv(matrixHost);
    auto result2 = Aurora::inv(matrixDevice).toHostMatrix();
    ASSERT_FLOAT_EQ(result1.getDataSize(), result2.getDataSize());
    for (size_t i = 0; i < result1.getDataSize(); i++)
    {
        EXPECT_FLOAT_AE(result1[i], result2[i]);
    }
}