rotgen/include/rotgen/functions/generators.hpp

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

#include <rotgen/detail/assert.hpp>
#include <rotgen/detail/helpers.hpp>

#include <rotgen/container/map.hpp>

namespace rotgen
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------

  template<typename T, typename... Args> void initialize_with(T&& m, Args... v)
  {
    using type = typename std::remove_cvref_t<T>::value_type;
    using map_t = rotgen::map<rotgen::matrix<type, -1, -1, rotgen::RowMajor>>;

    ROTGEN_ASSERT(sizeof...(v) == m.size(),
                  "Incorrect quantity of coefficients for initialization");
    type data[] = {static_cast<type>(v)...};
    m = map_t(data, rows(m), cols(m));
  }

  //----------------------------------------------------------------------------
  // Generators
  //----------------------------------------------------------------------------

  template<typename T> auto setZero(T&& t)
  {
    if constexpr (requires { std::forward<T>(t).setZero(); })
    {
      return std::forward<T>(t).setZero();
    }
    else if constexpr (requires { std::forward<T>(t)._setZero(); })
    {
      return std::forward<T>(t)._setZero();
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setZero()
  {
    if constexpr (requires { T::Zero(); }) { return T::Zero(); }
    else if constexpr (requires { T::_Zero(); }) { return T::_Zero(); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setZero(std::integral auto n)
  {
    if constexpr (requires { T::Zero(n); }) { return T::Zero(n); }
    else if constexpr (requires { T::_Zero(n); }) { return T::_Zero(n); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setZero(std::integral auto r, std::integral auto c)
  {
    if constexpr (requires { T::Zero(r, c); }) { return T::Zero(r, c); }
    else if constexpr (requires { T::_Zero(r, c); }) { return T::_Zero(r, c); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setOnes(T&& t)
  {
    if constexpr (requires { std::forward<T>(t).setOnes(); })
    {
      return std::forward<T>(t).setOnes();
    }
    else if constexpr (requires { std::forward<T>(t)._setOnes(); })
    {
      return std::forward<T>(t)._setOnes();
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setOnes()
  {
    if constexpr (requires { T::Ones(); }) { return T::Ones(); }
    else if constexpr (requires { T::_Ones(); }) { return T::_Ones(); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setOnes(std::integral auto n)
  {
    if constexpr (requires { T::Ones(n); }) { return T::Ones(n); }
    else if constexpr (requires { T::_Ones(n); }) { return T::_Ones(n); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setOnes(std::integral auto r, std::integral auto c)
  {
    if constexpr (requires { T::Ones(r, c); }) { return T::Ones(r, c); }
    else if constexpr (requires { T::_Ones(r, c); }) { return T::_Ones(r, c); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setIdentity(T&& t)
  {
    if constexpr (requires { std::forward<T>(t).setIdentity(); })
    {
      return std::forward<T>(t).setIdentity();
    }
    else if constexpr (requires { std::forward<T>(t)._setIdentity(); })
    {
      return std::forward<T>(t)._setIdentity();
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setIdentity()
  {
    if constexpr (requires { T::Identity(); }) { return T::Identity(); }
    else if constexpr (requires { T::_Identity(); }) { return T::_Identity(); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setIdentity(std::integral auto n)
  {
    if constexpr (requires { T::Identity(n); }) { return T::Identity(n); }
    else if constexpr (requires { T::_Identity(n); })
    {
      return T::_Identity(n);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T>
  auto setIdentity(std::integral auto r, std::integral auto c)
  {
    if constexpr (requires { T::Identity(r, c); }) { return T::Identity(r, c); }
    else if constexpr (requires { T::_Identity(r, c); })
    {
      return T::_Identity(r, c);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setRandom(T&& t)
  {
    if constexpr (requires { std::forward<T>(t).setRandom(); })
    {
      return std::forward<T>(t).setRandom();
    }
    else if constexpr (requires { std::forward<T>(t)._setRandom(); })
    {
      return std::forward<T>(t)._setRandom();
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setRandom()
  {
    if constexpr (requires { T::Random(); }) { return T::Random(); }
    else if constexpr (requires { T::_Random(); }) { return T::_Random(); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setRandom(std::integral auto n)
  {
    if constexpr (requires { T::Random(n); }) { return T::Random(n); }
    else if constexpr (requires { T::_Random(n); }) { return T::_Random(n); }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T>
  auto setRandom(std::integral auto r, std::integral auto c)
  {
    if constexpr (requires { T::Random(r, c); }) { return T::Random(r, c); }
    else if constexpr (requires { T::_Random(r, c); })
    {
      return T::_Random(r, c);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setConstant(T&& t, auto v)
  {
    if constexpr (requires { std::forward<T>(t).setConstant(v); })
    {
      return std::forward<T>(t).setConstant(v);
    }
    else if constexpr (requires { std::forward<T>(t)._setConstant(v); })
    {
      return std::forward<T>(t)._setConstant(v);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setConstant(auto v)
  {
    if constexpr (requires { T::Constant(v); }) { return T::Constant(v); }
    else if constexpr (requires { T::_Constant(v); })
    {
      return T::_Constant(v);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T> auto setConstant(std::integral auto n, auto v)
  {
    if constexpr (requires { T::Constant(n, v); }) { return T::Constant(n, v); }
    else if constexpr (requires { T::_Constant(n, v); })
    {
      return T::_Constant(n, v);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }

  template<typename T>
  auto setConstant(std::integral auto r, std::integral auto c, auto v)
  {
    if constexpr (requires { T::Constant(r, c, v); })
    {
      return T::Constant(r, c, v);
    }
    else if constexpr (requires { T::_Constant(r, c, v); })
    {
      return T::_Constant(r, c, v);
    }
    else
    {
      return detail::unsupported_parameters<T>();
    }
  }
}