rotgen/test/unit/map/strides.cpp

//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#include "unit/tests.hpp"
#include <rotgen/rotgen.hpp>
#include <vector>
#include <Eigen/Core>

auto generate_data(int rows, int cols)
{
  std::vector<float> buffer(rows * cols * 3);

  for (size_t i = 0; i < buffer.size(); ++i)
    buffer[i] = static_cast<float>(1 + i);

  return buffer;
}

template<int O>
using r_mat_t = rotgen::matrix<float, rotgen::Dynamic, rotgen::Dynamic, O>;

template<int O>
using e_mat_t = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, O>;

template<typename M, typename S = rotgen::stride>
using r_map_t = rotgen::map<M, 0, S>;
template<typename M, typename S = Eigen::Stride<0, 0>>
using e_map_t = Eigen::Map<M, 0, S>;

TTS_CASE("Validate Column Major Map with regular stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::ColMajor>> r_map(buffer.data(), rows, cols);

  TTS_EQUAL(r_map.innerStride(), 1);
  TTS_EQUAL(r_map.outerStride(), 3);

  e_map_t<e_mat_t<Eigen::ColMajor>> e_map(buffer.data(), rows, cols);

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};

TTS_CASE("Validate Column Major Map with specific outer stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::ColMajor>, rotgen::outer_stride<>> r_map(
    buffer.data(), rows, cols, rotgen::outer_stride(rows + 1));

  TTS_EQUAL(r_map.innerStride(), 1);
  TTS_EQUAL(r_map.outerStride(), 4);

  e_map_t<e_mat_t<Eigen::ColMajor>, Eigen::OuterStride<>> e_map(
    buffer.data(), rows, cols, Eigen::OuterStride<>(rows + 1));

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};

TTS_CASE("Validate Column Major Map with specific inner stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::ColMajor>> r_map(buffer.data(), rows, cols,
                                           rotgen::stride(rows, 2));

  TTS_EQUAL(r_map.innerStride(), 2);
  TTS_EQUAL(r_map.outerStride(), 3);

  e_map_t<e_mat_t<Eigen::ColMajor>,
          Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>
    e_map(buffer.data(), rows, cols,
          Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>(rows, 2));

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};

TTS_CASE("Validate Row Major Map with regular stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::RowMajor>> r_map(buffer.data(), rows, cols);

  TTS_EQUAL(r_map.innerStride(), 1);
  TTS_EQUAL(r_map.outerStride(), 4);

  e_map_t<e_mat_t<Eigen::RowMajor>> e_map(buffer.data(), rows, cols);

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};

TTS_CASE("Validate Row Major Map with specific outer stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::outer_stride<>> r_map(
    buffer.data(), rows, cols, rotgen::outer_stride(cols + 1));

  TTS_EQUAL(r_map.innerStride(), 1);
  TTS_EQUAL(r_map.outerStride(), 5);

  e_map_t<e_mat_t<Eigen::RowMajor>, Eigen::OuterStride<>> e_map(
    buffer.data(), rows, cols, Eigen::OuterStride<>(cols + 1));

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};

TTS_CASE("Validate Row Major Map with specific inner stride behavior")
{
  auto rows = 3;
  auto cols = 4;
  auto buffer = generate_data(rows, cols);

  r_map_t<r_mat_t<rotgen::RowMajor>, rotgen::stride> r_map(
    buffer.data(), rows, cols, rotgen::stride(2, cols));

  TTS_EQUAL(r_map.innerStride(), 4);
  TTS_EQUAL(r_map.outerStride(), 2);

  e_map_t<e_mat_t<Eigen::RowMajor>,
          Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>>
    e_map(buffer.data(), rows, cols,
          Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>(2, cols));

  for (std::ptrdiff_t r = 0; r < rows; r++)
    for (std::ptrdiff_t c = 0; c < cols; c++)
      TTS_EQUAL(r_map(r, c), e_map(r, c));
};