ah-mdspan.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
#ifndef AH_MDSPAN_H
#define AH_MDSPAN_H
 
#include <array>
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include <ah-cpp-compat.H>
#include <ah-errors.H>
 
#if ALEPH_HAS_STD_MDSPAN
#  include <mdspan>
#endif
 
namespace Aleph
{
 
#if ALEPH_HAS_STD_MDSPAN
 
inline constexpr size_t dynamic_extent = std::dynamic_extent;
 
template <class IndexType, size_t... Exts>
using extents = std::extents<IndexType, Exts...>;
 
template <class IndexType, size_t Rank>
using dextents = std::dextents<IndexType, Rank>;
 
using layout_right = std::layout_right;
using layout_left = std::layout_left;
 
template <class ElementType>
using default_accessor = std::default_accessor<ElementType>;
 
template <class T, class Extents, class LayoutPolicy = std::layout_right,
          class AccessorPolicy = std::default_accessor<T>>
class mdspan
{
  using impl_type = std::mdspan<T, Extents, LayoutPolicy, AccessorPolicy>;
 
  impl_type impl_{};
 
  template <class, class, class, class>
  friend class mdspan;
 
public:
  using extents_type = typename impl_type::extents_type;
  using layout_type = typename impl_type::layout_type;
  using accessor_type = typename impl_type::accessor_type;
  using mapping_type = typename impl_type::mapping_type;
  using element_type = typename impl_type::element_type;
  using value_type = typename impl_type::value_type;
  using index_type = typename impl_type::index_type;
  using rank_type = typename impl_type::rank_type;
  using data_handle_type = typename impl_type::data_handle_type;
  using reference = typename impl_type::reference;
 
  constexpr mdspan() noexcept = default;
  constexpr mdspan(const mdspan &) noexcept = default;
  constexpr mdspan(mdspan &&) noexcept = default;
  constexpr mdspan &operator=(const mdspan &) noexcept = default;
  constexpr mdspan &operator=(mdspan &&) noexcept = default;
 
  constexpr mdspan(data_handle_type p, const extents_type &e) noexcept
    : impl_(p, e)
  {}
 
  constexpr mdspan(data_handle_type p, const mapping_type &m) noexcept
    : impl_(p, m)
  {}
 
  constexpr mdspan(data_handle_type p, const mapping_type &m, const accessor_type &a) noexcept
    : impl_(p, m, a)
  {}
 
  template <class... IndexTypes>
    requires(sizeof...(IndexTypes) >= 1 and
             (std::is_convertible_v<IndexTypes, index_type> and ...))
  constexpr explicit mdspan(data_handle_type p, IndexTypes... exts) noexcept
    : impl_(p, static_cast<index_type>(exts)...)
  {}
 
  template <class OtherIndexType>
    requires std::is_convertible_v<const OtherIndexType &, index_type>
  constexpr mdspan(data_handle_type p,
                    const std::array<OtherIndexType, extents_type::rank_dynamic()> &dyn) noexcept
    : impl_(p, dyn)
  {}
 
  template <class OtherT, class OtherAccessor>
    requires(not std::is_same_v<OtherT, T> and std::is_convertible_v<OtherT (*)[], T (*)[]>)
  constexpr mdspan(const mdspan<OtherT, Extents, LayoutPolicy, OtherAccessor> &other) noexcept
    : impl_(other.impl_)
  {}
 
  [[nodiscard]] static constexpr rank_type rank() noexcept { return impl_type::rank(); }
  [[nodiscard]] constexpr index_type extent(rank_type r) const noexcept { return impl_.extent(r); }
  [[nodiscard]] constexpr const extents_type &extents() const noexcept { return impl_.extents(); }
  [[nodiscard]] constexpr const mapping_type &mapping() const noexcept { return impl_.mapping(); }
  [[nodiscard]] constexpr const accessor_type &accessor() const noexcept { return impl_.accessor(); }
  [[nodiscard]] constexpr data_handle_type data_handle() const noexcept { return impl_.data_handle(); }
  [[nodiscard]] constexpr data_handle_type data() const noexcept { return impl_.data_handle(); }
  [[nodiscard]] constexpr index_type size() const noexcept { return impl_.size(); }
  [[nodiscard]] constexpr bool empty() const noexcept { return impl_.empty(); }
 
  template <class... Indices>
    requires(sizeof...(Indices) == extents_type::rank())
  [[nodiscard]] constexpr reference operator()(Indices... idxs) const
  {
    return impl_[static_cast<index_type>(idxs)...];
  }
 
  template <class... Indices>
    requires(sizeof...(Indices) == extents_type::rank())
  [[nodiscard]] constexpr reference at(Indices... idxs) const
  {
    const index_type idx[]{static_cast<index_type>(idxs)...};
    for (rank_type r = 0; r < rank(); ++r)
      ah_out_of_range_error_if(std::cmp_less(idx[r], 0) or idx[r] >= extent(r))
        << "Aleph::mdspan::at(): index[" << r << "]=" << idx[r] << " out of [0, "
        << extent(r) << ")";
    return impl_[static_cast<index_type>(idxs)...];
  }
};
 
#else  // !ALEPH_HAS_STD_MDSPAN: native C++20 polyfill
 
inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);
 
namespace mdspan_detail
{
template <size_t... Exts>
inline constexpr size_t count_dynamic = (size_t{0} + ... + (Exts == dynamic_extent ? 1 : 0));
}  // namespace mdspan_detail
 
template <class IndexType, size_t... Exts>
class extents
{
  static_assert(std::is_integral_v<IndexType>,
                "Aleph::extents: IndexType must be an integral type");
 
  static constexpr std::array<size_t, sizeof...(Exts)> Static{Exts...};
 
  std::array<IndexType, sizeof...(Exts)> values_{};
 
public:
  using index_type = IndexType;
  using size_type = std::make_unsigned_t<IndexType>;
  using rank_type = size_t;
 
  static constexpr rank_type rank() noexcept { return sizeof...(Exts); }
 
  static constexpr rank_type rank_dynamic() noexcept
  {
    return mdspan_detail::count_dynamic<Exts...>;
  }
 
  static constexpr size_t static_extent(rank_type r) noexcept { return Static[r]; }
 
  constexpr extents() noexcept
  {
    for (rank_type r = 0; r < rank(); ++r)
      values_[r] = Static[r] == dynamic_extent ? IndexType{0} : static_cast<IndexType>(Static[r]);
  }
 
  template <class... IndexTypes>
    requires(sizeof...(IndexTypes) == mdspan_detail::count_dynamic<Exts...> and
             (std::is_convertible_v<IndexTypes, IndexType> and ...))
  constexpr explicit extents(IndexTypes... dyn) noexcept
  {
    const std::array<IndexType, sizeof...(IndexTypes)> given{static_cast<IndexType>(dyn)...};
    rank_type k = 0;
    for (rank_type r = 0; r < rank(); ++r)
      values_[r] = Static[r] == dynamic_extent ? given[k++] : static_cast<IndexType>(Static[r]);
  }
 
  template <class OtherIndexType>
    requires std::is_convertible_v<const OtherIndexType &, IndexType>
  constexpr explicit extents(
    const std::array<OtherIndexType, mdspan_detail::count_dynamic<Exts...>> &dyn) noexcept
  {
    rank_type k = 0;
    for (rank_type r = 0; r < rank(); ++r)
      values_[r] = Static[r] == dynamic_extent ? static_cast<IndexType>(dyn[k++])
                                                : static_cast<IndexType>(Static[r]);
  }
 
  [[nodiscard]] constexpr index_type extent(rank_type r) const noexcept { return values_[r]; }
 
  [[nodiscard]] friend constexpr bool operator==(const extents &a, const extents &b) noexcept
  {
    return a.values_ == b.values_;
  }
};
 
namespace mdspan_detail
{
template <class IndexType, size_t... Is>
struct dextents_helper
{
  using type = extents<IndexType, ((void) Is, dynamic_extent)...>;
};
 
template <class IndexType, size_t... Is>
dextents_helper<IndexType, Is...> dextents_of(std::index_sequence<Is...>);
}  // namespace mdspan_detail
 
template <class IndexType, size_t Rank>
using dextents =
  typename decltype(mdspan_detail::dextents_of<IndexType>(
    std::make_index_sequence<Rank>{}))::type;
 
struct layout_right
{
  template <class Extents>
  class mapping
  {
    Extents exts_{};
 
  public:
    using extents_type = Extents;
    using index_type = typename Extents::index_type;
    using rank_type = typename Extents::rank_type;
    using layout_type = layout_right;
 
    constexpr mapping() noexcept = default;
    constexpr explicit mapping(const Extents &e) noexcept : exts_(e) {}
 
    [[nodiscard]] constexpr const extents_type &extents() const noexcept { return exts_; }
 
    template <class... Indices>
      requires(sizeof...(Indices) == Extents::rank())
    [[nodiscard]] constexpr index_type operator()(Indices... idxs) const noexcept
    {
      const index_type idx[]{static_cast<index_type>(idxs)...};
      index_type offset = 0;
      for (rank_type r = 0; r < Extents::rank(); ++r)
        offset = offset * exts_.extent(r) + idx[r];
      return offset;
    }
 
    [[nodiscard]] constexpr index_type required_span_size() const noexcept
    {
      index_type total = 1;
      for (rank_type r = 0; r < Extents::rank(); ++r)
        total *= exts_.extent(r);
      return total;
    }
 
    static constexpr bool is_always_unique() noexcept { return true; }
    static constexpr bool is_always_exhaustive() noexcept { return true; }
    static constexpr bool is_always_strided() noexcept { return true; }
  };
};
 
struct layout_left
{
  template <class Extents>
  class mapping
  {
    Extents exts_{};
 
  public:
    using extents_type = Extents;
    using index_type = typename Extents::index_type;
    using rank_type = typename Extents::rank_type;
    using layout_type = layout_left;
 
    constexpr mapping() noexcept = default;
    constexpr explicit mapping(const Extents &e) noexcept : exts_(e) {}
 
    [[nodiscard]] constexpr const extents_type &extents() const noexcept { return exts_; }
 
    template <class... Indices>
      requires(sizeof...(Indices) == Extents::rank())
    [[nodiscard]] constexpr index_type operator()(Indices... idxs) const noexcept
    {
      const index_type idx[]{static_cast<index_type>(idxs)...};
      index_type offset = 0;
      for (rank_type ri = 0; ri < Extents::rank(); ++ri)
        {
          const rank_type r = Extents::rank() - 1 - ri;
          offset = offset * exts_.extent(r) + idx[r];
        }
      return offset;
    }
 
    [[nodiscard]] constexpr index_type required_span_size() const noexcept
    {
      index_type total = 1;
      for (rank_type r = 0; r < Extents::rank(); ++r)
        total *= exts_.extent(r);
      return total;
    }
 
    static constexpr bool is_always_unique() noexcept { return true; }
    static constexpr bool is_always_exhaustive() noexcept { return true; }
    static constexpr bool is_always_strided() noexcept { return true; }
  };
};
 
template <class ElementType>
struct default_accessor
{
  using offset_policy = default_accessor;
  using element_type = ElementType;
  using reference = ElementType &;
  using data_handle_type = ElementType *;
 
  constexpr default_accessor() noexcept = default;
 
  template <class OtherElementType>
    requires std::is_convertible_v<OtherElementType (*)[], element_type (*)[]>
  constexpr default_accessor(default_accessor<OtherElementType>) noexcept
  {}
 
  [[nodiscard]] constexpr reference access(data_handle_type p, size_t i) const noexcept
  {
    return p[i];
  }
 
  [[nodiscard]] constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept
  {
    return p + i;
  }
};
 
template <class T, class Extents, class LayoutPolicy = layout_right,
          class AccessorPolicy = default_accessor<T>>
class mdspan
{
public:
  using extents_type = Extents;
  using layout_type = LayoutPolicy;
  using accessor_type = AccessorPolicy;
  using mapping_type = typename layout_type::template mapping<extents_type>;
  using element_type = T;
  using value_type = std::remove_cv_t<T>;
  using index_type = typename extents_type::index_type;
  using rank_type = typename extents_type::rank_type;
  using data_handle_type = typename accessor_type::data_handle_type;
  using reference = typename accessor_type::reference;
 
private:
  data_handle_type ptr_{};
  mapping_type map_{};
  accessor_type acc_{};
 
public:
  constexpr mdspan() noexcept = default;
 
  constexpr mdspan(const mdspan &) noexcept = default;
  constexpr mdspan(mdspan &&) noexcept = default;
  constexpr mdspan &operator=(const mdspan &) noexcept = default;
  constexpr mdspan &operator=(mdspan &&) noexcept = default;
 
  template <class OtherT, class OtherAccessor>
    requires(not std::is_same_v<OtherT, T> and std::is_convertible_v<OtherT (*)[], T (*)[]>)
  constexpr mdspan(const mdspan<OtherT, Extents, LayoutPolicy, OtherAccessor> &other) noexcept
    : ptr_(other.data_handle()), map_(other.mapping()), acc_(other.accessor())
  {}
 
  constexpr mdspan(data_handle_type p, const extents_type &e) noexcept
    : ptr_(p), map_(e)
  {}
 
  constexpr mdspan(data_handle_type p, const mapping_type &m) noexcept
    : ptr_(p), map_(m)
  {}
 
  constexpr mdspan(data_handle_type p, const mapping_type &m, const accessor_type &a) noexcept
    : ptr_(p), map_(m), acc_(a)
  {}
 
  template <class... IndexTypes>
    requires(sizeof...(IndexTypes) >= 1 and
             (std::is_convertible_v<IndexTypes, index_type> and ...))
  constexpr explicit mdspan(data_handle_type p, IndexTypes... exts) noexcept
    : ptr_(p), map_(extents_type(static_cast<index_type>(exts)...))
  {}
 
  template <class OtherIndexType>
    requires std::is_convertible_v<const OtherIndexType &, index_type>
  constexpr mdspan(data_handle_type p,
                    const std::array<OtherIndexType, extents_type::rank_dynamic()> &dyn) noexcept
    : ptr_(p), map_(extents_type(dyn))
  {}
 
  [[nodiscard]] static constexpr rank_type rank() noexcept { return extents_type::rank(); }
 
  [[nodiscard]] constexpr index_type extent(rank_type r) const noexcept
  {
    return map_.extents().extent(r);
  }
 
  [[nodiscard]] constexpr const extents_type &extents() const noexcept { return map_.extents(); }
 
  [[nodiscard]] constexpr const mapping_type &mapping() const noexcept { return map_; }
 
  [[nodiscard]] constexpr const accessor_type &accessor() const noexcept { return acc_; }
 
  [[nodiscard]] constexpr data_handle_type data_handle() const noexcept { return ptr_; }
 
  [[nodiscard]] constexpr data_handle_type data() const noexcept { return ptr_; }
 
  [[nodiscard]] constexpr index_type size() const noexcept
  {
    index_type total = 1;
    for (rank_type r = 0; r < rank(); ++r)
      total *= extent(r);
    return total;
  }
 
  [[nodiscard]] constexpr bool empty() const noexcept
  {
    for (rank_type r = 0; r < rank(); ++r)
      if (extent(r) == 0)
        return true;
    return false;
  }
 
  template <class... Indices>
    requires(sizeof...(Indices) == extents_type::rank())
  [[nodiscard]] constexpr reference operator()(Indices... idxs) const
  {
    return acc_.access(ptr_, map_(static_cast<index_type>(idxs)...));
  }
 
  template <class... Indices>
    requires(sizeof...(Indices) == extents_type::rank())
  [[nodiscard]] constexpr reference at(Indices... idxs) const
  {
    const index_type idx[]{static_cast<index_type>(idxs)...};
    for (rank_type r = 0; r < rank(); ++r)
      ah_out_of_range_error_if(std::cmp_less(idx[r], 0) or idx[r] >= extent(r))
        << "Aleph::mdspan::at(): index[" << r << "]=" << idx[r] << " out of [0, "
        << extent(r) << ")";
    return acc_.access(ptr_, map_(static_cast<index_type>(idxs)...));
  }
};
 
#endif  // ALEPH_HAS_STD_MDSPAN
 
}  // namespace Aleph
 
#endif  // AH_MDSPAN_H