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

#include <rotgen/rotgen.hpp>

#include "tts.hpp"
#include "unit/common/references.hpp"
#include <Eigen/Dense>

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

    eigen_mat_t eigen_ref(rows(rotgen_input), cols(rotgen_input));

    prepare([&](auto row, auto col) { return rotgen_input(row, col); },
            eigen_ref);

    TTS_EQUAL(rotgen::norm(rotgen_input), eigen_ref.norm());
    TTS_EQUAL(rotgen::squaredNorm(rotgen_input), eigen_ref.squaredNorm());
    TTS_EQUAL(rotgen::lpNorm<1>(rotgen_input), eigen_ref.template lpNorm<1>());
    TTS_EQUAL(rotgen::lpNorm<2>(rotgen_input), eigen_ref.template lpNorm<2>());
    TTS_EQUAL(rotgen::lpNorm<rotgen::Infinity>(rotgen_input),
              eigen_ref.template lpNorm<Eigen::Infinity>());

    if constexpr (T::IsVectorAtCompileTime)
    {
      eigen_mat_t eigen_normalized = eigen_ref.normalized();
      using rotgen_mat_t =
        rotgen::matrix<typename T::value_type, rotgen::Dynamic, rotgen::Dynamic,
                       T::storage_order>;
      rotgen_mat_t rotgen_norm_ref(rows(rotgen_input), cols(rotgen_input));
      prepare([&](auto row, auto col) { return eigen_normalized(row, col); },
              rotgen_norm_ref);

      TTS_EQUAL(rotgen::normalized(rotgen_input), rotgen_norm_ref);

      auto rotgen_f_norm = rotgen_input;
      rotgen::normalize(rotgen_f_norm);
      TTS_EQUAL(rotgen_f_norm, rotgen_norm_ref);
    }
  }
}