tensor/concepts.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/mdspan/concepts.hpp>
 
#include <concepts>
#include <cstddef>
#include <type_traits>
#include <utility>
 
namespace uni20
{
 
namespace detail
{
template <class T> using tensor_type_t = std::remove_reference_t<T>;
 
template <class Tensor, class = void> struct TensorStoragePolicy
{
    using type = void;
};
 
template <class Tensor> struct TensorStoragePolicy<Tensor, std::void_t<typename Tensor::storage_policy>>
{
    using type = typename Tensor::storage_policy;
};
 
template <class T> using tensor_const_mdspan_t = decltype(std::declval<tensor_type_t<T> const&>().mdspan());
 
template <class T> using tensor_mutable_mdspan_t = decltype(std::declval<tensor_type_t<T>&>().mdspan());
} // namespace detail
 
template <class Tensor>
using tensor_storage_policy_t = typename detail::TensorStoragePolicy<std::remove_cvref_t<Tensor>>::type;
 
template <class Tensor>
  requires requires(Tensor& tensor) { tensor.mdspec(); }
[[nodiscard]] constexpr decltype(auto) mdspec_of(Tensor& tensor) noexcept(noexcept(tensor.mdspec()))
{
  return tensor.mdspec();
}
 
template <class Tensor>
  requires(
      !requires(Tensor& tensor) { tensor.mdspec(); } && requires(Tensor& tensor) { tensor.mdspan(); })
[[nodiscard]] constexpr decltype(auto) mdspec_of(Tensor& tensor) noexcept(noexcept(tensor.mdspan()))
{
  return tensor.mdspan();
}
 
namespace detail
{
template <class T> using normalized_const_mdspec_t = decltype(mdspec_of(std::declval<tensor_type_t<T> const&>()));
 
template <class T> using normalized_mutable_mdspec_t = decltype(mdspec_of(std::declval<tensor_type_t<T>&>()));
} // namespace detail
 
template <class T>
concept TensorView = (!MdspecLike<T>) && requires(std::remove_reference_t<T> const& tensor) {
  typename std::remove_cvref_t<detail::normalized_const_mdspec_t<T>>::extents_type;
  tensor.backend_selector();
  mdspec_of(tensor);
  {
    tensor.extents()
  } -> std::convertible_to<typename std::remove_cvref_t<detail::normalized_const_mdspec_t<T>>::extents_type>;
  {
    tensor.extent(std::size_t{})
  } -> std::convertible_to<typename std::remove_cvref_t<detail::normalized_const_mdspec_t<T>>::index_type>;
} && MdspecLike<detail::normalized_const_mdspec_t<T>>;
 
template <class T>
concept ImmediateTensorView = TensorView<T> && requires(std::remove_reference_t<T> const& tensor) {
  tensor.mdspan();
} && MdspanLike<detail::tensor_const_mdspan_t<T>> && MdspanLike<detail::normalized_const_mdspec_t<T>>;
 
template <class T> inline constexpr bool enable_owning_tensor = false;
 
template <class T>
concept OwningTensor = TensorView<T> && enable_owning_tensor<std::remove_cvref_t<T>>;
 
template <ImmediateTensorView T>
using immediate_tensor_mdspan_t = std::remove_cvref_t<detail::tensor_const_mdspan_t<T>>;
 
template <TensorView T> using tensor_mdspec_t = std::remove_cvref_t<detail::normalized_const_mdspec_t<T>>;
 
template <TensorView T> using tensor_element_t = std::remove_cv_t<typename tensor_mdspec_t<T>::element_type>;
 
template <TensorView T> using tensor_extents_t = typename tensor_mdspec_t<T>::extents_type;
 
template <class T>
concept MutableTensorView = TensorView<T> && requires(std::remove_reference_t<T>& tensor) { mdspec_of(tensor); } &&
                            MutableMdspecLike<detail::normalized_mutable_mdspec_t<T>>;
 
template <class T>
concept MutableImmediateTensorView =
    MutableTensorView<T> && ImmediateTensorView<T> &&
    requires(std::remove_reference_t<T>& tensor) { tensor.mdspan(); } &&
    MutableMdspanLike<detail::tensor_mutable_mdspan_t<T>> && MutableMdspanLike<detail::normalized_mutable_mdspec_t<T>>;
 
template <MutableTensorView T>
using mutable_tensor_mdspec_t = std::remove_cvref_t<detail::normalized_mutable_mdspec_t<T>>;
 
template <class T, std::size_t Rank>
concept RankedTensorView = TensorView<T> && RankedMdspecLike<tensor_mdspec_t<T>, Rank>;
 
template <class T>
concept StridedTensorView = TensorView<T> && StridedMdspecLike<tensor_mdspec_t<T>>;
 
template <class T>
concept MutableStridedTensorView =
    MutableTensorView<T> && StridedTensorView<T> && MutableStridedMdspecLike<mutable_tensor_mdspec_t<T>>;
 
template <class T, std::size_t Rank>
concept RankedStridedTensorView = RankedTensorView<T, Rank> && StridedTensorView<T>;
 
template <class T, std::size_t Rank>
concept MutableRankedTensorView =
    RankedTensorView<T, Rank> && MutableTensorView<T> && MutableRankedMdspecLike<mutable_tensor_mdspec_t<T>, Rank>;
 
template <class T>
concept ScalarTensorView = RankedTensorView<T, 0>;
 
template <class T>
concept MutableScalarTensorView = MutableRankedTensorView<T, 0>;
 
template <class T, std::size_t Rank>
concept MutableRankedStridedTensorView = MutableRankedTensorView<T, Rank> && MutableStridedTensorView<T>;
 
template <MutableImmediateTensorView T>
using mutable_immediate_tensor_mdspan_t = std::remove_cvref_t<detail::tensor_mutable_mdspan_t<T>>;
 
template <class T>
concept StridedImmediateTensorView =
    ImmediateTensorView<T> && StridedTensorView<T> &&
    StridedMdspanLike<decltype(std::declval<std::remove_reference_t<T> const&>().mdspan())>;
 
template <class T>
concept MutableStridedImmediateTensorView =
    MutableImmediateTensorView<T> && MutableStridedTensorView<T> && StridedImmediateTensorView<T> &&
    MutableStridedMdspanLike<decltype(std::declval<std::remove_reference_t<T>&>().mdspan())>;
 
template <class T, std::size_t Rank>
concept RankedImmediateTensorView =
    ImmediateTensorView<T> && RankedTensorView<T, Rank> &&
    RankedMdspanLike<decltype(std::declval<std::remove_reference_t<T> const&>().mdspan()), Rank>;
 
template <class T, std::size_t Rank>
concept MutableRankedImmediateTensorView =
    RankedImmediateTensorView<T, Rank> && MutableRankedTensorView<T, Rank> && MutableImmediateTensorView<T> &&
    MutableRankedMdspanLike<detail::tensor_mutable_mdspan_t<T>, Rank>;
 
template <class T>
concept ScalarImmediateTensorView = RankedImmediateTensorView<T, 0>;
 
template <class T>
concept MutableScalarImmediateTensorView = MutableRankedImmediateTensorView<T, 0>;
 
template <class T, std::size_t Rank>
concept RankedStridedImmediateTensorView =
    RankedImmediateTensorView<T, Rank> && RankedStridedTensorView<T, Rank> && StridedImmediateTensorView<T>;
 
template <class T, std::size_t Rank>
concept MutableRankedStridedImmediateTensorView =
    MutableRankedImmediateTensorView<T, Rank> && MutableRankedStridedTensorView<T, Rank> &&
    MutableStridedImmediateTensorView<T>;
 
template <StridedTensorView T> [[nodiscard]] auto strides(T const& tensor) { return strides(mdspec_of(tensor)); }
 
template <MutableTensorView Output, TensorView Input>
  requires(tensor_mdspec_t<Output>::rank() == tensor_mdspec_t<Input>::rank())
void assign_through(Output& output, Input const& input);
 
} // namespace uni20