DatafieldTest.cpp

#include "Base/Axis/MakeScale.h"
#include "Base/Axis/Scale.h"
#include "Device/Data/DataUtil.h"
#include "Device/Data/Datafield.h"
#include "Tests/GTestWrapper/google_test.h"

TEST(DatafieldTest, createRearrangedDataSet)
{
    Datafield input_data{
        {newEquiDivision("axis0", 2, 1.0, 2.0), newEquiDivision("axis1", 3, 3.0, 4.0)}};
    input_data.setVector(std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0});

    std::unique_ptr<Datafield> output_data;
    output_data = std::make_unique<Datafield>(DataUtil::createRearrangedDataSet(input_data, 5));

    EXPECT_EQ(size_t(3), output_data->axis(0).size());
    EXPECT_EQ(size_t(2), output_data->axis(1).size());

    EXPECT_EQ(input_data[2], (*output_data)[0]);
    EXPECT_EQ(input_data[5], (*output_data)[1]);
    EXPECT_EQ(input_data[1], (*output_data)[2]);
    EXPECT_EQ(input_data[4], (*output_data)[3]);
    EXPECT_EQ(input_data[0], (*output_data)[4]);
    EXPECT_EQ(input_data[3], (*output_data)[5]);

    output_data = std::make_unique<Datafield>(DataUtil::createRearrangedDataSet(input_data, -6));

    EXPECT_EQ(size_t(2), output_data->axis(0).size());
    EXPECT_EQ(size_t(3), output_data->axis(1).size());

    EXPECT_EQ(input_data[5], (*output_data)[0]);
    EXPECT_EQ(input_data[4], (*output_data)[1]);
    EXPECT_EQ(input_data[3], (*output_data)[2]);
    EXPECT_EQ(input_data[2], (*output_data)[3]);
    EXPECT_EQ(input_data[1], (*output_data)[4]);
    EXPECT_EQ(input_data[0], (*output_data)[5]);

    output_data = std::make_unique<Datafield>(DataUtil::createRearrangedDataSet(input_data, 3));

    EXPECT_EQ(size_t(3), output_data->axis(0).size());
    EXPECT_EQ(size_t(2), output_data->axis(1).size());

    EXPECT_EQ(input_data[3], (*output_data)[0]);
    EXPECT_EQ(input_data[0], (*output_data)[1]);
    EXPECT_EQ(input_data[4], (*output_data)[2]);
    EXPECT_EQ(input_data[1], (*output_data)[3]);
    EXPECT_EQ(input_data[5], (*output_data)[4]);
    EXPECT_EQ(input_data[2], (*output_data)[5]);
}

TEST(DatafieldTest, create2DArrayfromDatafield)
{
    Datafield out_data{
        {newEquiDivision("axis0", 3, 1.0, 3.0), newEquiDivision("axis1", 2, 10., 20.)}};
    EXPECT_EQ(6u, out_data.size());

    EXPECT_EQ(3u, out_data.axis(0).size()); // no. of rows
    EXPECT_EQ(2u, out_data.axis(1).size()); // no. of cols

    std::vector<double> arr_in{1, 2, 3, 4, 5, 6};
    out_data.setVector(arr_in);

    EXPECT_EQ(arr_in[0], out_data[0]);
    EXPECT_EQ(arr_in[1], out_data[1]);
    EXPECT_EQ(arr_in[2], out_data[2]);
    EXPECT_EQ(arr_in[3], out_data[3]);
    EXPECT_EQ(arr_in[4], out_data[4]);
    EXPECT_EQ(arr_in[5], out_data[5]);

    auto arr_out = out_data.flatVector();
    EXPECT_EQ(arr_in, arr_out);

    auto array_2d = out_data.values2D();

    std::vector<std::vector<double>> array_expected_2d{{arr_in[0], arr_in[1], arr_in[2]},
                                                       {arr_in[3], arr_in[4], arr_in[5]}};
    EXPECT_EQ(array_expected_2d, array_2d);
}

TEST(DatafieldTest, vecvecToDatafield)
{
    std::vector<double> arr_in{1, 2, 3, 4, 5, 6};
    std::vector<std::vector<double>> array_2d{{arr_in[0], arr_in[1], arr_in[2]},
                                              {arr_in[3], arr_in[4], arr_in[5]}};
    const Datafield data = DataUtil::vecvecToDatafield(array_2d);
    EXPECT_EQ(arr_in, data.flatVector());
}

TEST(DatafieldTest, DatafieldToVector2D)
{
    Datafield data(
        {newEquiDivision("axis0", 3, 10.0, 20.0), newEquiDivision("axis1", 2, 30.0, 40.0)});
    const std::vector<double> values = {0., 1., 2., 10., 11., 12.};

    data.setVector(values);

    auto vec = data.values2D();
    const std::vector<std::vector<double>> expected = {{0., 1., 2.}, {10., 11., 12.}};
    EXPECT_EQ(vec, expected);
}