block_tensor_concepts.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/symmetry/symmetry.hpp>
#include <uni20/tensor/concepts.hpp>
 
#include <concepts>
#include <cstddef>
#include <span>
#include <type_traits>
#include <utility>
 
namespace uni20
{
 
template <class Tensor> using block_tensor_type_t = std::remove_cvref_t<Tensor>;
 
template <class Tensor> using block_tensor_value_t = typename block_tensor_type_t<Tensor>::value_type;
 
template <class Tensor> using block_tensor_key_t = typename block_tensor_type_t<Tensor>::key_type;
 
template <class Tensor> using block_tensor_domain_t = typename block_tensor_type_t<Tensor>::domain_type;
 
template <class Tensor> using block_tensor_codomain_t = typename block_tensor_type_t<Tensor>::codomain_type;
 
template <class Tensor>
using block_tensor_const_block_t =
    decltype(std::declval<block_tensor_type_t<Tensor> const&>().block_by_ordinal(std::size_t{}));
 
template <class Tensor>
using block_tensor_mutable_block_t =
    decltype(std::declval<std::remove_reference_t<Tensor>&>().block_by_ordinal(std::size_t{}));
 
template <class Tensor>
concept BlockTensorView = requires(block_tensor_type_t<Tensor> const& tensor, std::size_t ordinal) {
  typename block_tensor_type_t<Tensor>::element_type;
  typename block_tensor_type_t<Tensor>::value_type;
  typename block_tensor_type_t<Tensor>::key_type;
  typename block_tensor_type_t<Tensor>::domain_type;
  typename block_tensor_type_t<Tensor>::codomain_type;
  typename block_tensor_type_t<Tensor>::storage_policy;
  typename block_tensor_type_t<Tensor>::backend_selector_type;
  { tensor.symmetry() } -> std::same_as<Symmetry>;
  { tensor.domain() } -> std::same_as<block_tensor_domain_t<Tensor> const&>;
  { tensor.codomain() } -> std::same_as<block_tensor_codomain_t<Tensor> const&>;
  { block_tensor_type_t<Tensor>::order() } -> std::same_as<std::size_t>;
  { block_tensor_type_t<Tensor>::key_coordinate_count() } -> std::same_as<std::size_t>;
  { block_tensor_type_t<Tensor>::dense_block_order() } -> std::same_as<std::size_t>;
  { tensor.stored_block_count() } -> std::same_as<std::size_t>;
  { tensor.stored_keys() } -> std::same_as<std::span<block_tensor_key_t<Tensor> const>>;
  { tensor.block_by_ordinal(ordinal) } -> TensorView;
};
 
template <class Tensor>
concept MutableBlockTensorView =
    BlockTensorView<Tensor> && requires(std::remove_reference_t<Tensor>& tensor, std::size_t ordinal) {
      { tensor.block_by_ordinal(ordinal) } -> MutableTensorView;
    };
 
template <class Tensor>
concept ImmediateBlockTensorView = BlockTensorView<Tensor> && ImmediateTensorView<block_tensor_const_block_t<Tensor>>;
 
template <class Tensor>
concept MutableImmediateBlockTensorView =
    MutableBlockTensorView<Tensor> && MutableImmediateTensorView<block_tensor_mutable_block_t<Tensor>>;
 
template <class Tensor>
concept DiagonalBlockTensorView =
    BlockTensorView<Tensor> && DiagonalMdspecLike<tensor_mdspec_t<block_tensor_const_block_t<Tensor>>>;
 
template <class Tensor>
concept BorrowedBlockTensorView = BlockTensorView<Tensor> && requires {
  typename block_tensor_type_t<Tensor>::borrowed_block_tensor_view_tag;
};
 
template <class Tensor>
concept AsyncBlockTensorView =
    BlockTensorView<Tensor> && requires(block_tensor_type_t<Tensor> const& tensor, std::size_t ordinal) {
      tensor.async_block_by_ordinal(ordinal).read();
    };
 
template <class Tensor>
concept MutableAsyncBlockTensorView =
    AsyncBlockTensorView<Tensor> && MutableBlockTensorView<Tensor> &&
    requires(std::remove_reference_t<Tensor>& tensor, std::size_t ordinal) {
      tensor.async_block_by_ordinal(ordinal).write();
    };
 
} // namespace uni20