//==================================================================================================
/*
  ROTGEN - Runtime Overlay for Eigen
  Copyright : CODE RECKONS
  SPDX-License-Identifier: BSL-1.0
*/
//==================================================================================================
#pragma once

#include <rotgen/rotgen.hpp>

#include "tts.hpp"
#include <Eigen/Dense>

namespace rotgen::tests
{
  template<typename T> void check_cwise_functions(T const& rotgen_input)
  {
    using eigen_mat_t =
      Eigen::Matrix<typename T::value_type, Eigen::Dynamic, Eigen::Dynamic>;

    using rotgen_mat_t =
      matrix<typename T::value_type, Dynamic, Dynamic, T::storage_order>;

    TTS_WHEN("Unary Cwise operations")
    {
      eigen_mat_t eigen_ref(rotgen_input.rows(), rotgen_input.cols());
      prepare([&](auto r, auto c) { return rotgen_input(r, c); }, eigen_ref);

      rotgen_mat_t rotgen_ref(rotgen_input.rows(), rotgen_input.cols());

      TTS_AND_THEN("abs()")
      {
        eigen_ref = eigen_ref.cwiseAbs();
        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
        TTS_EQUAL(rotgen::abs(rotgen_input), rotgen_ref);
      }

      TTS_AND_THEN("abs2()")
      {
        eigen_ref = eigen_ref.cwiseAbs2();
        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
        TTS_EQUAL(rotgen::abs2(rotgen_input), rotgen_ref);
      }

      TTS_AND_THEN("rec")
      {
        eigen_ref = eigen_ref.cwiseInverse();
        prepare([&](auto r, auto c) { return eigen_ref(r, c); }, rotgen_ref);
        TTS_EQUAL(rotgen::rec(rotgen_input), rotgen_ref);
      }

      TTS_AND_THEN("sqrt")
      {
        eigen_ref = eigen_ref.cwiseAbs().cwiseSqrt();
        auto mat = rotgen::abs(rotgen_input);
        auto proper_input = rotgen::sqrt(mat);

        for (rotgen::Index r = 0; r < rotgen_input.rows(); ++r)
          for (rotgen::Index c = 0; c < rotgen_input.cols(); ++c)
            TTS_ULP_EQUAL(proper_input(r, c), eigen_ref(r, c), 1);
      }
    }
  }
}