conjugate_accessor.hpp

Go to the documentation of this file.

#pragma once
 
#include <uni20/core/compiler_attributes.hpp>
#include <uni20/core/math.hpp>
#include <uni20/mdspan/concepts.hpp>
#include <uni20/mdspan/mdspec.hpp>
 
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace uni20
{
namespace detail
{
 
struct conjugate_function
{
    template <uni20::Complex C>
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto operator()(C const& value) const -> C
    {
      return uni20::conj(value);
    }
 
    template <class Value>
      requires(!uni20::Complex<std::remove_cvref_t<Value>>)
    [[nodiscard]] UNI20_HOST_DEVICE constexpr decltype(auto) operator()(Value&& value) const
    {
      return conj(static_cast<Value&&>(value));
    }
};
 
} // namespace detail
 
template <class Accessor> struct accessor_applies_conjugation : std::false_type
{};
 
template <class Accessor>
inline constexpr bool accessor_applies_conjugation_v =
    accessor_applies_conjugation<std::remove_cvref_t<Accessor>>::value;
 
template <class Mdspan>
inline constexpr bool mdspan_needs_conjugation_v =
    accessor_applies_conjugation_v<typename std::remove_cvref_t<Mdspan>::accessor_type>;
 
template <AccessorPolicy Accessor>
  requires uni20::Complex<std::remove_cv_t<typename Accessor::element_type>>
class conjugated_accessor {
  public:
    using wrapped_accessor_type = Accessor;
    using value_type = std::remove_cv_t<typename Accessor::element_type>;
    using element_type = value_type const;
    using reference = std::invoke_result_t<detail::conjugate_function, typename Accessor::reference>;
    using data_handle_type = typename Accessor::data_handle_type;
    using offset_policy = conjugated_accessor;
    using offset_type = span_offset_t<Accessor>;
 
    UNI20_HOST_DEVICE constexpr conjugated_accessor()
      requires std::default_initializable<Accessor>
        : accessor_{}
    {}
 
    UNI20_HOST_DEVICE constexpr explicit conjugated_accessor(Accessor accessor)
        : accessor_(static_cast<Accessor&&>(accessor))
    {}
 
    [[nodiscard]] UNI20_HOST_DEVICE constexpr reference access(data_handle_type ptr, offset_type offset) const
    {
      return detail::conjugate_function{}(accessor_.access(ptr, offset));
    }
 
    [[nodiscard]] UNI20_HOST_DEVICE constexpr data_handle_type offset(data_handle_type ptr, offset_type offset) const
    {
      return accessor_.offset(ptr, offset);
    }
 
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto wrapped_accessor() const& -> Accessor const& { return accessor_; }
 
    [[nodiscard]] UNI20_HOST_DEVICE constexpr auto wrapped_accessor() && -> Accessor
    {
      return static_cast<Accessor&&>(accessor_);
    }
 
  private:
    [[no_unique_address]] Accessor accessor_{};
};
 
template <AccessorPolicy Accessor> struct accessor_applies_conjugation<conjugated_accessor<Accessor>> : std::true_type
{};
 
template <AccessorPolicy Accessor, class Domain>
inline constexpr bool enable_accessor_in_domain<conjugated_accessor<Accessor>, Domain> =
    enable_accessor_in_domain<Accessor, Domain>;
 
template <MdspanLike Span>
  requires(uni20::Complex<std::remove_cv_t<typename Span::element_type>> &&
           !accessor_applies_conjugation_v<typename std::remove_cvref_t<Span>::accessor_type>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = conjugated_accessor{const_accessor(span.accessor())};
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
 
  return stdex::mdspan<element_type, extents_type, layout_type, accessor_type>{span.data_handle(), span.mapping(),
                                                                               std::move(accessor)};
}
 
template <MdspecLike Span>
  requires(!MdspanLike<Span> && uni20::Complex<std::remove_cv_t<typename Span::element_type>> &&
           !accessor_applies_conjugation_v<typename std::remove_cvref_t<Span>::accessor_type>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = conjugated_accessor{const_accessor(span.accessor())};
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
  using descriptor_type = typename Span::data_descriptor_type;
 
  return mdspec<element_type, extents_type, layout_type, accessor_type, descriptor_type>{
      span.data_descriptor(), span.mapping(), std::move(accessor)};
}
 
template <MdspanLike Span>
  requires(uni20::Complex<std::remove_cv_t<typename Span::element_type>> &&
           accessor_applies_conjugation_v<typename std::remove_cvref_t<Span>::accessor_type>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = span.accessor().wrapped_accessor();
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
 
  return stdex::mdspan<element_type, extents_type, layout_type, accessor_type>{span.data_handle(), span.mapping(),
                                                                               std::move(accessor)};
}
 
template <MdspecLike Span>
  requires(!MdspanLike<Span> && uni20::Complex<std::remove_cv_t<typename Span::element_type>> &&
           accessor_applies_conjugation_v<typename std::remove_cvref_t<Span>::accessor_type>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = span.accessor().wrapped_accessor();
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
  using descriptor_type = typename Span::data_descriptor_type;
 
  return mdspec<element_type, extents_type, layout_type, accessor_type, descriptor_type>{
      span.data_descriptor(), span.mapping(), std::move(accessor)};
}
 
template <MdspanLike Span>
  requires(!uni20::Complex<std::remove_cv_t<typename Span::element_type>>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = const_accessor(span.accessor());
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
 
  return stdex::mdspan<element_type, extents_type, layout_type, accessor_type>{span.data_handle(), span.mapping(),
                                                                               std::move(accessor)};
}
 
template <MdspecLike Span>
  requires(!MdspanLike<Span> && !uni20::Complex<std::remove_cv_t<typename Span::element_type>>)
[[nodiscard]] constexpr auto conj(Span const& span)
{
  auto accessor = const_accessor(span.accessor());
  using accessor_type = decltype(accessor);
  using extents_type = typename Span::extents_type;
  using layout_type = typename Span::layout_type;
  using element_type = typename accessor_type::element_type;
  using descriptor_type = typename Span::data_descriptor_type;
 
  return mdspec<element_type, extents_type, layout_type, accessor_type, descriptor_type>{
      span.data_descriptor(), span.mapping(), std::move(accessor)};
}
 
} // namespace uni20