dual_space.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/symmetry/block_sector.hpp>
#include <uni20/symmetry/qnum.hpp>
#include <uni20/symmetry/space.hpp>
 
#include <concepts>
#include <cstddef>
#include <iterator>
#include <ranges>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
namespace uni20
{
 
template <class SpaceType> class Dual;
 
namespace detail
{
 
template <class T> struct IsDualSpace : std::false_type
{};
 
template <class SpaceType> struct IsDualSpace<Dual<SpaceType>> : std::true_type
{};
 
template <class T> struct PrimalSpaceType
{
    using type = std::remove_cvref_t<T>;
};
 
template <class SpaceType> struct PrimalSpaceType<Dual<SpaceType>>
{
    using type = SpaceType;
};
 
inline auto dual_space_entry(QNum const& q) -> QNum { return dual(q); }
 
inline auto dual_space_entry(BlockSector const& sector) -> BlockSector
{
  return BlockSector{dual(sector.q), sector.dim};
}
 
template <std::input_iterator Iterator> class DualSpaceIterator {
  public:
    using iterator_concept = std::input_iterator_tag;
    using iterator_category = std::input_iterator_tag;
    using difference_type = std::iter_difference_t<Iterator>;
    using value_type = std::remove_cvref_t<decltype(dual_space_entry(*std::declval<Iterator const&>()))>;
 
    DualSpaceIterator()
      requires std::default_initializable<Iterator>
    = default;
 
    explicit DualSpaceIterator(Iterator iterator) : iterator_(std::move(iterator)) {}
 
    auto operator*() const -> value_type { return dual_space_entry(*iterator_); }
 
    auto operator++() -> DualSpaceIterator&
    {
      ++iterator_;
      return *this;
    }
 
    void operator++(int) { ++iterator_; }
 
    auto operator==(DualSpaceIterator const&) const -> bool = default;
 
  private:
    Iterator iterator_;
};
 
} // namespace detail
 
template <class SpaceType> class Dual {
    static_assert(Space<SpaceType>, "Dual requires a tensor-space value");
    static_assert(!detail::IsDualSpace<std::remove_cvref_t<SpaceType>>::value,
                  "use dual(Dual<S>) to recover S instead of nesting Dual adaptors");
 
  public:
    using base_space_type = SpaceType;
 
    explicit Dual(base_space_type space) : space_(std::move(space)) {}
 
    auto base() const& noexcept -> base_space_type const& { return space_; }
 
    auto symmetry() const -> Symmetry
      requires SymmetrySpace<base_space_type>
    {
      return space_.symmetry();
    }
 
    auto label() const -> std::string const& { return space_.label(); }
 
    void set_label(std::string label) { space_.set_label(std::move(label)); }
 
    auto size() const -> std::size_t
      requires requires(base_space_type const& space) {
        { space.size() } -> std::same_as<std::size_t>;
      }
    {
      return space_.size();
    }
 
    auto empty() const -> bool
      requires requires(base_space_type const& space) {
        { space.empty() } -> std::convertible_to<bool>;
      }
    {
      return space_.empty();
    }
 
    auto total_dim() const -> std::size_t
      requires requires(base_space_type const& space) {
        { space.total_dim() } -> std::same_as<std::size_t>;
      }
    {
      return space_.total_dim();
    }
 
    auto extent() const -> std::size_t
      requires requires(base_space_type const& space) {
        { space.extent() } -> std::same_as<std::size_t>;
      }
    {
      return space_.extent();
    }
 
    auto qnum() const -> QNum
      requires requires(base_space_type const& space) {
        { space.qnum() } -> std::convertible_to<QNum>;
      }
    {
      return dual(space_.qnum());
    }
 
    auto operator[](std::size_t index) const
      requires requires(base_space_type const& space) { space[index]; }
    {
      using entry_type = std::remove_cvref_t<decltype(space_[index])>;
      static_assert(std::same_as<entry_type, QNum> || std::same_as<entry_type, BlockSector>,
                    "indexed Dual-space access currently supports QNum and BlockSector entries");
      return detail::dual_space_entry(space_[index]);
    }
 
    auto begin() const
      requires requires(base_space_type const& space) { space.begin(); }
    {
      return detail::DualSpaceIterator(space_.begin());
    }
 
    auto end() const
      requires requires(base_space_type const& space) { space.end(); }
    {
      return detail::DualSpaceIterator(space_.end());
    }
 
    auto qnums() const
      requires requires(base_space_type const& space) { space.qnums(); }
    {
      return space_.qnums() | std::views::transform([](QNum const& q) { return dual(q); });
    }
 
    auto sectors() const
      requires requires(base_space_type const& space) { space.sectors(); }
    {
      return space_.sectors() |
             std::views::transform([](BlockSector const& sector) { return BlockSector{dual(sector.q), sector.dim}; });
    }
 
    auto contains(QNum q) const -> bool
      requires SymmetrySpace<base_space_type> && requires(base_space_type const& space, QNum value) {
        { space.contains(value) } -> std::convertible_to<bool>;
      }
    {
      if (!q.valid() || q.symmetry() != this->symmetry())
      {
        throw std::invalid_argument("Dual-space query has the wrong symmetry");
      }
      return space_.contains(dual(q));
    }
 
    auto operator==(Dual const& other) const -> bool = default;
 
    auto release_base() && -> base_space_type { return std::move(space_); }
 
  private:
    base_space_type space_;
};
 
template <class SpaceType> Dual(SpaceType&&) -> Dual<std::remove_cvref_t<SpaceType>>;
 
template <class T>
concept DualSpace = Space<T> && detail::IsDualSpace<std::remove_cvref_t<T>>::value;
 
template <class T> using primal_space_t = typename detail::PrimalSpaceType<std::remove_cvref_t<T>>::type;
 
template <Space SpaceType>
  requires(!DualSpace<SpaceType>)
auto dual(SpaceType const& space) -> Dual<std::remove_cvref_t<SpaceType>>
{
  return Dual<std::remove_cvref_t<SpaceType>>(space);
}
 
template <Space SpaceType>
  requires(!DualSpace<SpaceType>)
auto dual(SpaceType&& space) -> Dual<std::remove_cvref_t<SpaceType>>
{
  return Dual<std::remove_cvref_t<SpaceType>>(std::forward<SpaceType>(space));
}
 
template <class SpaceType> auto dual(Dual<SpaceType> const& space) -> SpaceType { return space.base(); }
 
template <class SpaceType> auto dual(Dual<SpaceType>&& space) -> SpaceType { return std::move(space).release_base(); }
 
} // namespace uni20