basic_tensor.hpp

Go to the documentation of this file.

#pragma once
 
#include "concepts.hpp"
#include "layout.hpp"
 
#include <uni20/common/initialization.hpp>
#include <uni20/common/trace.hpp>
#include <uni20/mdspan/mdspan.hpp>
#include <uni20/mdspan/mdspec.hpp>
#include <uni20/storage/host_storage.hpp>
#include <uni20/tensor/copy_into.hpp>
 
#include <array>
#include <concepts>
#include <cstddef>
#include <ranges>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace uni20
{
namespace detail
{
 
template <class RequestedLayout, class InputMdspan>
using materialized_layout_t =
    std::conditional_t<std::is_void_v<RequestedLayout>,
                       std::conditional_t<std::same_as<typename InputMdspan::layout_type, stdex::layout_left> ||
                                              std::same_as<typename InputMdspan::layout_type, stdex::layout_right>,
                                          typename InputMdspan::layout_type, stdex::layout_left>,
                       RequestedLayout>;
 
template <class Storage>
concept DefaultTensorStorage =
    (std::default_initializable<Storage> && requires(Storage& storage) { storage.resize(std::size_t{}); }) ||
    std::constructible_from<Storage, std::size_t> || std::constructible_from<Storage, size_type>;
 
template <typename Tuple, std::size_t... I> constexpr bool integral_prefix(std::index_sequence<I...>)
{
  return (std::integral<std::tuple_element_t<I, Tuple>> && ...);
}
 
} // namespace detail
 
struct DefaultAccessorFactory
{
    template <typename ElementType> using accessor_t = stdex::default_accessor<ElementType>;
 
    template <typename ElementType, typename Storage>
    [[nodiscard]] constexpr auto make_accessor(Storage const&) const noexcept -> accessor_t<ElementType>
    {
      return accessor_t<ElementType>{};
    }
};
 
namespace detail
{
 
template <class StoragePolicy, class = void> struct TensorAccessorFactory
{
    using type = DefaultAccessorFactory;
};
 
template <class StoragePolicy>
struct TensorAccessorFactory<StoragePolicy, std::void_t<typename StoragePolicy::accessor_factory_type>>
{
    using type = typename StoragePolicy::accessor_factory_type;
};
 
template <class StoragePolicy> using tensor_accessor_factory_t = typename TensorAccessorFactory<StoragePolicy>::type;
 
template <class AccessorFactory, class ElementType, class = void> struct TensorDeviceAccessor
{
    using type = typename AccessorFactory::template accessor_t<ElementType>;
};
 
template <class AccessorFactory, class ElementType>
struct TensorDeviceAccessor<AccessorFactory, ElementType,
                            std::void_t<typename AccessorFactory::template device_accessor_t<ElementType>>>
{
    using type = typename AccessorFactory::template device_accessor_t<ElementType>;
};
 
template <class AccessorFactory, class ElementType>
using tensor_device_accessor_t = typename TensorDeviceAccessor<AccessorFactory, ElementType>::type;
 
} // namespace detail
 
template <typename ElementType, std::size_t Rank, typename StoragePolicy = HostStorage,
          typename LayoutPolicy = stdex::layout_left,
          typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>,
          typename Extents = stdex::dextents<index_type, Rank>>
class Tensor {
  public:
    static_assert(Rank == Extents::rank());
 
    using element_type = ElementType;
    using value_type = std::remove_cv_t<element_type>;
    using storage_policy = StoragePolicy;
    using layout_policy = LayoutPolicy;
    using layout_type = layout_policy;
    using accessor_factory_type = AccessorFactory;
    using accessor_type = typename accessor_factory_type::template accessor_t<element_type>;
    using const_accessor_type = typename accessor_factory_type::template accessor_t<element_type const>;
    using device_accessor_type = detail::tensor_device_accessor_t<accessor_factory_type, element_type>;
    using const_device_accessor_type = detail::tensor_device_accessor_t<accessor_factory_type, element_type const>;
    using extents_type = Extents;
    using handle_type = typename const_accessor_type::data_handle_type;
    using mutable_handle_type = typename accessor_type::data_handle_type;
    using index_type = typename extents_type::index_type;
    using mapping_type = typename layout_policy::template mapping<extents_type>;
    using size_type = uni20::size_type;
    using backend_selector_type = typename storage_policy::backend_selector_type;
    using mdspan_type = stdex::mdspan<element_type, extents_type, layout_policy, accessor_type>;
    using const_mdspan_type = stdex::mdspan<element_type const, extents_type, layout_policy, const_accessor_type>;
 
    using storage_type = typename storage_policy::template storage_t<element_type>;
 
    static constexpr bool immediately_readable = requires(storage_type const& storage) {
      { storage_policy::make_handle(storage) } -> std::convertible_to<handle_type>;
    };
 
    static constexpr bool immediately_writable = requires(storage_type& storage) {
      { storage_policy::make_handle(storage) } -> std::convertible_to<mutable_handle_type>;
    };
 
    static constexpr bool deferred_readable =
        requires(storage_type const& storage) { storage_policy::make_data_descriptor(storage); };
 
    static constexpr bool deferred_writable =
        requires(storage_type& storage) { storage_policy::make_data_descriptor(storage); };
 
    template <typename NewLayoutPolicy>
    using rebind_layout_type =
        Tensor<element_type, Rank, storage_policy, NewLayoutPolicy, accessor_factory_type, extents_type>;
 
    template <typename NewExtents>
    using rebind_extents_type =
        Tensor<element_type, NewExtents::rank(), storage_policy, layout_policy, accessor_factory_type, NewExtents>;
 
    Tensor()
      requires(Rank > 0)
    = default;
 
    Tensor()
      requires(Rank == 0 && detail::DefaultTensorStorage<storage_type>)
        : Tensor(extents_type{})
    {}
 
    explicit Tensor(uninitialized_t)
      requires(Rank == 0 && detail::DefaultTensorStorage<storage_type>)
        : Tensor(uninitialized, extents_type{})
    {}
 
    Tensor(Tensor const& other) = default;
 
    Tensor(Tensor&& other) = default;
 
    Tensor& operator=(Tensor const& other) = default;
 
    Tensor& operator=(Tensor&& other) = default;
 
    template <TensorView InputTensor>
      requires(tensor_mdspec_t<InputTensor>::rank() == extents_type::rank() &&
               std::default_initializable<accessor_factory_type> && detail::DefaultTensorStorage<storage_type>)
    explicit Tensor(InputTensor const& input)
        : Tensor(uninitialized, convert_tensor_extents<extents_type>(input.extents()))
    {
#if UNI20_HAS_MPREAL
      if constexpr (has_runtime_precision_v<value_type> && requires { input.default_precision_if_set(); })
        if (auto p = input.default_precision_if_set()) data_.default_precision(*p);
#endif
      copy(*this, input);
    }
 
    explicit Tensor(extents_type const& exts, accessor_factory_type accessor_factory = accessor_factory_type{})
      requires detail::DefaultTensorStorage<storage_type>
        : Tensor(internal_tag{}, make_payload(make_default_mapping(exts), std::move(accessor_factory)))
    {}
 
    explicit Tensor(extents_type const& exts, Precision p)
      requires(std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); })
        : Tensor(internal_tag{}, make_precision_payload(exts, p, StorageInitialization::Zero))
    {}
 
    explicit Tensor(uninitialized_t, extents_type const& exts, Precision p)
      requires(std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); })
        : Tensor(internal_tag{}, make_precision_payload(exts, p, StorageInitialization::Uninitialized))
    {}
 
    template <class... Args>
      requires(std::same_as<storage_policy, HostStorage> &&
               requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank &&
               sizeof...(Args) == Rank + 1 &&
               std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> &&
               detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))
    explicit Tensor(Args... args)
        : Tensor(precision_extents(std::tuple{args...}, std::make_index_sequence<Rank>{}),
                 std::get<Rank>(std::tuple{args...}))
    {}
 
    template <class... Args>
      requires(std::same_as<storage_policy, HostStorage> &&
               requires(Precision p) { require_precision<value_type>(p); } && extents_type::rank_dynamic() == Rank &&
               sizeof...(Args) == Rank + 1 &&
               std::same_as<std::tuple_element_t<Rank, std::tuple<Args...>>, Precision> &&
               detail::integral_prefix<std::tuple<Args...>>(std::make_index_sequence<Rank>{}))
    explicit Tensor(uninitialized_t, Args... args)
        : Tensor(uninitialized, precision_extents(std::tuple{args...}, std::make_index_sequence<Rank>{}),
                 std::get<Rank>(std::tuple{args...}))
    {}
 
#if UNI20_HAS_MPREAL
    Precision default_precision() const
      requires has_runtime_precision_v<value_type>
    {
      return data_.default_precision();
    }
    std::optional<Precision> default_precision_if_set() const noexcept
      requires has_runtime_precision_v<value_type>
    {
      return data_.default_precision_if_set();
    }
    void default_precision(Precision p)
      requires has_runtime_precision_v<value_type>
    {
      data_.default_precision(p);
    }
#endif
 
    explicit Tensor(uninitialized_t, extents_type const& exts,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
      requires detail::DefaultTensorStorage<storage_type>
        : Tensor(internal_tag{}, make_payload(make_default_mapping(exts), std::move(accessor_factory),
                                              StorageInitialization::Uninitialized))
    {}
 
    template <class Policy = storage_policy>
      requires requires(typename Policy::context_type& context, std::size_t count) {
        {
          Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized)
        } -> std::same_as<storage_type>;
      }
    explicit Tensor(typename Policy::context_type& context, extents_type const& exts,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{}, make_payload(context, make_default_mapping(exts), std::move(accessor_factory)))
    {}
 
    template <class Policy = storage_policy>
      requires requires(typename Policy::context_type& context, std::size_t count) {
        {
          Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized)
        } -> std::same_as<storage_type>;
      }
    explicit Tensor(uninitialized_t, typename Policy::context_type& context, extents_type const& exts,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{}, make_payload(context, make_default_mapping(exts), std::move(accessor_factory),
                                              StorageInitialization::Uninitialized))
    {}
 
    template <class Placement>
      requires requires(Placement const& placement, std::size_t count) {
        {
          storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized)
        } -> std::same_as<storage_type>;
      }
    explicit Tensor(Placement const& placement, extents_type const& exts,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{}, make_payload(placement, make_default_mapping(exts), std::move(accessor_factory)))
    {}
 
    template <class Placement>
      requires requires(Placement const& placement, std::size_t count) {
        {
          storage_policy::template make_storage<element_type>(placement, count, StorageInitialization::Uninitialized)
        } -> std::same_as<storage_type>;
      }
    explicit Tensor(uninitialized_t, Placement const& placement, extents_type const& exts,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{}, make_payload(placement, make_default_mapping(exts), std::move(accessor_factory),
                                              StorageInitialization::Uninitialized))
    {}
 
    template <std::integral... DynamicExtents>
      requires(extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() &&
               sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)
    explicit Tensor(DynamicExtents... dynamic_extents)
        : Tensor(extents_type{static_cast<index_type>(dynamic_extents)...})
    {}
 
    template <std::integral... DynamicExtents>
      requires(extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() &&
               sizeof...(DynamicExtents) == extents_type::rank() && detail::DefaultTensorStorage<storage_type>)
    explicit Tensor(uninitialized_t, DynamicExtents... dynamic_extents)
        : Tensor(uninitialized, extents_type{static_cast<index_type>(dynamic_extents)...})
    {}
 
    template <class Policy = storage_policy, std::integral... DynamicExtents>
      requires(extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() &&
               sizeof...(DynamicExtents) == extents_type::rank() &&
               requires(typename Policy::context_type& context, std::size_t count) {
                 {
                   Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized)
                 } -> std::same_as<storage_type>;
               })
    explicit Tensor(typename Policy::context_type& context, DynamicExtents... dynamic_extents)
        : Tensor(context, extents_type{static_cast<index_type>(dynamic_extents)...})
    {}
 
    template <class Policy = storage_policy, std::integral... DynamicExtents>
      requires(extents_type::rank() > 0 && extents_type::rank_dynamic() == extents_type::rank() &&
               sizeof...(DynamicExtents) == extents_type::rank() &&
               requires(typename Policy::context_type& context, std::size_t count) {
                 {
                   Policy::template make_storage<element_type>(context, count, StorageInitialization::Uninitialized)
                 } -> std::same_as<storage_type>;
               })
    explicit Tensor(uninitialized_t, typename Policy::context_type& context, DynamicExtents... dynamic_extents)
        : Tensor(uninitialized, context, extents_type{static_cast<index_type>(dynamic_extents)...})
    {}
 
    template <typename MappingBuilder>
      requires(layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> &&
               (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) &&
               detail::DefaultTensorStorage<storage_type>)
    explicit Tensor(extents_type const& exts, MappingBuilder&& mapping_builder,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{},
                 make_payload(std::forward<MappingBuilder>(mapping_builder)(exts), std::move(accessor_factory)))
    {}
 
    template <typename MappingBuilder>
      requires(layout::mapping_builder_for<MappingBuilder, layout_policy, extents_type> &&
               (!std::same_as<std::remove_cvref_t<MappingBuilder>, accessor_factory_type>) &&
               detail::DefaultTensorStorage<storage_type>)
    explicit Tensor(uninitialized_t, extents_type const& exts, MappingBuilder&& mapping_builder,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
        : Tensor(internal_tag{}, make_payload(std::forward<MappingBuilder>(mapping_builder)(exts),
                                              std::move(accessor_factory), StorageInitialization::Uninitialized))
    {}
 
    explicit Tensor(extents_type const& exts, std::array<index_type, extents_type::rank()> const& strides,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
      requires(std::constructible_from<mapping_type, extents_type const&,
                                       std::array<index_type, extents_type::rank()> const&> &&
               detail::DefaultTensorStorage<storage_type>)
        : Tensor(internal_tag{}, make_payload(mapping_type{exts, strides}, std::move(accessor_factory)))
    {}
 
    explicit Tensor(uninitialized_t, extents_type const& exts,
                    std::array<index_type, extents_type::rank()> const& strides,
                    accessor_factory_type accessor_factory = accessor_factory_type{})
      requires(std::constructible_from<mapping_type, extents_type const&,
                                       std::array<index_type, extents_type::rank()> const&> &&
               detail::DefaultTensorStorage<storage_type>)
        : Tensor(internal_tag{}, make_payload(mapping_type{exts, strides}, std::move(accessor_factory),
                                              StorageInitialization::Uninitialized))
    {}
 
    void reset_shape(extents_type const& exts)
      requires(std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> &&
               std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type>)
    {
      auto mapping = make_default_mapping(exts);
      Tensor replacement(internal_tag{}, make_payload_like(data_, std::move(mapping), accessor_factory_));
      this->swap_state(replacement);
    }
 
    void reset_shape(uninitialized_t, extents_type const& exts)
      requires(std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> &&
               std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type>)
    {
      auto mapping = make_default_mapping(exts);
      Tensor replacement(internal_tag{}, make_payload_like(data_, std::move(mapping), accessor_factory_,
                                                           StorageInitialization::Uninitialized));
      this->swap_state(replacement);
    }
 
    template <class Placement>
      requires requires(storage_type const& storage, Placement const& placement) {
        { storage_policy::storage_is_compatible(storage, placement) } -> std::convertible_to<bool>;
      }
    [[nodiscard]] bool storage_is_compatible(Placement const& placement) const
    {
      return storage_policy::storage_is_compatible(data_, placement);
    }
 
    template <class Placement>
      requires(std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> &&
               std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> &&
               requires(Placement const& required_placement, std::size_t count) {
                 {
                   storage_policy::template make_storage<element_type>(required_placement, count,
                                                                       StorageInitialization::Uninitialized)
                 } -> std::same_as<storage_type>;
               })
    void replace(extents_type const& exts, Placement const& placement)
    {
      auto mapping = make_default_mapping(exts);
      Tensor replacement(internal_tag{}, make_payload(placement, std::move(mapping), accessor_factory_));
      this->swap_state(replacement);
    }
 
    template <class Placement>
      requires(std::copy_constructible<accessor_factory_type> && std::is_nothrow_swappable_v<mapping_type> &&
               std::is_nothrow_swappable_v<storage_type> && std::is_nothrow_swappable_v<accessor_factory_type> &&
               requires(Placement const& required_placement, std::size_t count) {
                 {
                   storage_policy::template make_storage<element_type>(required_placement, count,
                                                                       StorageInitialization::Uninitialized)
                 } -> std::same_as<storage_type>;
               })
    void replace(uninitialized_t, extents_type const& exts, Placement const& placement)
    {
      auto mapping = make_default_mapping(exts);
      Tensor replacement(internal_tag{}, make_payload(placement, std::move(mapping), accessor_factory_,
                                                      StorageInitialization::Uninitialized));
      this->swap_state(replacement);
    }
 
    [[nodiscard]] storage_type& storage() noexcept { return data_; }
 
    [[nodiscard]] storage_type const& storage() const noexcept { return data_; }
 
    [[nodiscard]] storage_type release_storage() && noexcept(std::is_nothrow_move_constructible_v<storage_type>)
    {
      return std::move(data_);
    }
 
    [[nodiscard]] accessor_factory_type
    release_accessor_factory() && noexcept(std::is_nothrow_move_constructible_v<accessor_factory_type>)
    {
      return std::move(accessor_factory_);
    }
 
    [[nodiscard]] static Tensor adopt_storage(mapping_type mapping, storage_type storage,
                                              accessor_factory_type accessor_factory = accessor_factory_type{})
      requires requires(storage_type const& value) { value.size(); }
    {
      ERROR_IF(std::cmp_less(storage.size(), mapping.required_span_size()),
               "adopted tensor storage is smaller than the mapping's required span");
      return Tensor(internal_tag{}, ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)});
    }
 
    void replace_mapping(mapping_type mapping)
      requires requires(storage_type const& value) { value.size(); }
    {
      ERROR_IF(std::cmp_less(data_.size(), mapping.required_span_size()),
               "replacement tensor mapping exceeds the owned storage");
      mapping_ = std::move(mapping);
    }
 
    [[nodiscard]] static constexpr auto backend_selector() noexcept -> backend_selector_type
    {
      return storage_policy::backend_selector();
    }
 
    [[nodiscard]] auto mdspan() noexcept -> mdspan_type
      requires immediately_writable
    {
      return mdspan_type(this->mutable_handle(), mapping_, this->accessor());
    }
 
    [[nodiscard]] auto mdspan() const noexcept -> const_mdspan_type
      requires immediately_readable
    {
      return const_mdspan_type(this->handle(), mapping_, this->accessor());
    }
 
    [[nodiscard]] auto mdspec() noexcept
      requires(immediately_writable || deferred_writable)
    {
      if constexpr (immediately_writable)
      {
        return this->mdspan();
      }
      else
      {
        using descriptor_type = decltype(storage_policy::make_data_descriptor(data_));
        using span_type =
            uni20::mdspec<element_type, extents_type, layout_policy, device_accessor_type, descriptor_type>;
        return span_type{storage_policy::make_data_descriptor(data_), mapping_, this->device_accessor()};
      }
    }
 
    [[nodiscard]] auto mdspec() const noexcept
      requires(immediately_readable || deferred_readable)
    {
      if constexpr (immediately_readable)
      {
        return this->mdspan();
      }
      else
      {
        using descriptor_type = decltype(storage_policy::make_data_descriptor(data_));
        using span_type =
            uni20::mdspec<element_type const, extents_type, layout_policy, const_device_accessor_type, descriptor_type>;
        return span_type{storage_policy::make_data_descriptor(data_), mapping_, this->device_accessor()};
      }
    }
 
    [[nodiscard]] auto handle() const noexcept -> handle_type
      requires immediately_readable
    {
      return storage_policy::make_handle(data_);
    }
 
    [[nodiscard]] auto mutable_handle() noexcept -> mutable_handle_type
      requires immediately_writable
    {
      return storage_policy::make_handle(data_);
    }
 
    [[nodiscard]] auto data() noexcept -> element_type* requires(immediately_writable &&
                                                                 (std::same_as<layout_type, stdex::layout_left> ||
                                                                  std::same_as<layout_type, stdex::layout_right>) &&
                                                                 is_default_accessor_v<accessor_type> &&
                                                                 std::same_as<mutable_handle_type, element_type*>) {
      return this->mutable_handle();
    }
 
    [[nodiscard]] auto data() const noexcept
        -> element_type const* requires(immediately_readable &&
                                        (std::same_as<layout_type, stdex::layout_left> ||
                                         std::same_as<layout_type, stdex::layout_right>) &&
                                        is_default_accessor_v<const_accessor_type> &&
                                        std::same_as<handle_type, element_type const*>) { return this->handle(); }
 
    [[nodiscard]] auto mapping() const noexcept -> mapping_type const&
    {
      return mapping_;
    }
 
    [[nodiscard]] auto extents() const noexcept -> extents_type const& { return mapping_.extents(); }
 
    [[nodiscard]] auto extent(size_type axis) const noexcept { return this->extents().extent(axis); }
 
    [[nodiscard]] auto accessor() noexcept -> accessor_type
    {
      return accessor_factory_.template make_accessor<element_type>(data_);
    }
 
    [[nodiscard]] auto accessor() const noexcept -> const_accessor_type
    {
      return accessor_factory_.template make_accessor<element_type const>(data_);
    }
 
    [[nodiscard]] auto device_accessor() noexcept -> device_accessor_type
    {
      if constexpr (requires { accessor_factory_.template make_device_accessor<element_type>(data_); })
        return accessor_factory_.template make_device_accessor<element_type>(data_);
      else
        return this->accessor();
    }
 
    [[nodiscard]] auto device_accessor() const noexcept -> const_device_accessor_type
    {
      if constexpr (requires { accessor_factory_.template make_device_accessor<element_type const>(data_); })
        return accessor_factory_.template make_device_accessor<element_type const>(data_);
      else
        return this->accessor();
    }
 
    [[nodiscard]] auto size() const noexcept -> size_type { return mapping_.required_span_size(); }
 
    static constexpr size_type rank() noexcept { return extents_type::rank(); }
 
    static constexpr size_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
 
    [[nodiscard]] auto rows() const noexcept
      requires(extents_type::rank() == 2)
    {
      return this->extent(0);
    }
 
    [[nodiscard]] auto cols() const noexcept
      requires(extents_type::rank() == 2)
    {
      return this->extent(1);
    }
 
    template <class... Index>
      requires(sizeof...(Index) == extents_type::rank() && immediately_writable)
    decltype(auto) operator[](Index... indices) noexcept
    {
      return this->mdspan()[indices...];
    }
 
    template <class... Index>
      requires(sizeof...(Index) == extents_type::rank() && immediately_readable)
    decltype(auto) operator[](Index... indices) const noexcept
    {
      return this->mdspan()[indices...];
    }
 
    decltype(auto) operator[](std::array<index_type, extents_type::rank()> const& indices) noexcept
      requires immediately_writable
    {
      auto span = this->mdspan();
      return [&]<std::size_t... I>(std::index_sequence<I...>) -> decltype(auto) {
        return span[indices[I]...];
      }(std::make_index_sequence<extents_type::rank()>{});
    }
 
    decltype(auto) operator[](std::array<index_type, extents_type::rank()> const& indices) const noexcept
      requires immediately_readable
    {
      auto span = this->mdspan();
      return [&]<std::size_t... I>(std::index_sequence<I...>) -> decltype(auto) {
        return span[indices[I]...];
      }(std::make_index_sequence<extents_type::rank()>{});
    }
 
  private:
    struct internal_tag
    {};
 
    struct ctor_payload
    {
        mapping_type mapping;
        storage_type storage;
        accessor_factory_type accessor_factory;
    };
 
    Tensor(internal_tag, ctor_payload payload)
        : mapping_(std::move(payload.mapping)), data_(std::move(payload.storage)),
          accessor_factory_(std::move(payload.accessor_factory))
    {}
 
    template <class Tuple, std::size_t... I>
    static extents_type precision_extents(Tuple const& args, std::index_sequence<I...>)
    {
      return extents_type{static_cast<index_type>(std::get<I>(args))...};
    }
    static ctor_payload make_precision_payload(extents_type const& exts, Precision p,
                                               StorageInitialization initialization)
      requires(std::same_as<storage_policy, HostStorage> && requires(Precision p) { require_precision<value_type>(p); })
    {
      require_precision<value_type>(p);
      auto mapping = make_default_mapping(exts);
      if constexpr (!has_runtime_precision_v<value_type>)
        return make_payload(std::move(mapping), accessor_factory_type{}, initialization);
      else
      {
        auto storage = storage_policy::template make_storage<element_type>(
            static_cast<std::size_t>(mapping.required_span_size()), initialization, p);
        return ctor_payload{std::move(mapping), std::move(storage), accessor_factory_type{}};
      }
    }
 
    static ctor_payload make_payload(mapping_type mapping, accessor_factory_type accessor_factory,
                                     StorageInitialization initialization = StorageInitialization::Zero)
    {
      auto storage = create_storage(static_cast<std::size_t>(mapping.required_span_size()), initialization);
      return ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)};
    }
 
    template <class Policy = storage_policy>
    static ctor_payload make_payload(typename Policy::context_type& context, mapping_type mapping,
                                     accessor_factory_type accessor_factory,
                                     StorageInitialization initialization = StorageInitialization::Zero)
      requires requires(typename Policy::context_type& storage_context, std::size_t count) {
        {
          Policy::template make_storage<element_type>(storage_context, count, initialization)
        } -> std::same_as<storage_type>;
      }
    {
      auto const count = static_cast<std::size_t>(mapping.required_span_size());
      auto storage = Policy::template make_storage<element_type>(context, count, initialization);
      return ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)};
    }
 
    template <class Placement>
    static ctor_payload make_payload(Placement const& placement, mapping_type mapping,
                                     accessor_factory_type accessor_factory,
                                     StorageInitialization initialization = StorageInitialization::Zero)
      requires requires(Placement const& required_placement, std::size_t count) {
        {
          storage_policy::template make_storage<element_type>(required_placement, count, initialization)
        } -> std::same_as<storage_type>;
      }
    {
      auto const count = static_cast<std::size_t>(mapping.required_span_size());
      auto storage = storage_policy::template make_storage<element_type>(placement, count, initialization);
      return ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)};
    }
 
    static ctor_payload make_payload_like(storage_type const& source, mapping_type mapping,
                                          accessor_factory_type accessor_factory,
                                          StorageInitialization initialization = StorageInitialization::Zero)
    {
      auto const count = static_cast<std::size_t>(mapping.required_span_size());
      if constexpr (requires {
                      storage_policy::template make_storage_like<element_type>(source, count, initialization);
                    })
      {
        auto storage = storage_policy::template make_storage_like<element_type>(source, count, initialization);
        return ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)};
      }
      else
      {
        auto storage = create_storage(count, initialization);
        return ctor_payload{std::move(mapping), std::move(storage), std::move(accessor_factory)};
      }
    }
 
    static storage_type create_storage(std::size_t count, StorageInitialization initialization)
    {
      if constexpr (requires { storage_policy::template make_storage<element_type>(count, initialization); })
      {
        return storage_policy::template make_storage<element_type>(count, initialization);
      }
      else
      {
        // Ordinary contiguous host containers can implement the policy directly.
        // Opaque/device storage must provide its own initialization-aware factory.
        static_assert(std::ranges::contiguous_range<storage_type>,
                      "Non-contiguous storage requires an initialization-aware make_storage factory");
        auto storage = [count] {
          if constexpr (requires(storage_type& value) { value.resize(count); })
          {
            storage_type result{};
            result.resize(count);
            return result;
          }
          else
          {
            return storage_type(count);
          }
        }();
        detail::initialize_host_elements(std::ranges::data(storage), count, initialization);
        return storage;
      }
    }
 
    static constexpr auto make_default_mapping(extents_type const& exts)
    {
      if constexpr (requires { typename storage_policy::default_mapping_builder; })
      {
        using builder_type = typename storage_policy::default_mapping_builder;
        if constexpr (layout::mapping_builder_for<builder_type, layout_policy, extents_type>)
        {
          return builder_type{}(exts);
        }
        else
        {
          return layout::make_mapping<layout_policy>(exts);
        }
      }
      else
      {
        return layout::make_mapping<layout_policy>(exts);
      }
    }
 
    void swap_state(Tensor& other) noexcept
      requires(std::is_nothrow_swappable_v<mapping_type> && std::is_nothrow_swappable_v<storage_type> &&
               std::is_nothrow_swappable_v<accessor_factory_type>)
    {
      using std::swap;
      swap(mapping_, other.mapping_);
      swap(data_, other.data_);
      swap(accessor_factory_, other.accessor_factory_);
    }
 
    [[no_unique_address]] mapping_type mapping_{};
    storage_type data_;
    [[no_unique_address]] accessor_factory_type accessor_factory_{};
};
 
template <typename ElementType, std::size_t Rank, typename StoragePolicy, typename LayoutPolicy,
          typename AccessorFactory, typename Extents>
inline constexpr bool
    enable_owning_tensor<Tensor<ElementType, Rank, StoragePolicy, LayoutPolicy, AccessorFactory, Extents>> = true;
 
template <TensorView InputTensor>
Tensor(InputTensor const&)
    -> Tensor<tensor_element_t<InputTensor>, tensor_mdspec_t<InputTensor>::rank(), HostStorage,
              detail::materialized_layout_t<void, tensor_mdspec_t<InputTensor>>, DefaultAccessorFactory>;
 
template <typename ElementType, typename Extents, typename StoragePolicy = HostStorage,
          typename LayoutPolicy = stdex::layout_left,
          typename AccessorFactory = detail::tensor_accessor_factory_t<StoragePolicy>>
using BasicTensor = Tensor<ElementType, Extents::rank(), StoragePolicy, LayoutPolicy, AccessorFactory, Extents>;
 
} // namespace uni20