[mdspan.layout.stride]

namespace std { template<class Extents> class layout_stride::mapping { public: using extents_type = Extents; using index_type = extents_type::index_type; using size_type = extents_type::size_type; using rank_type = extents_type::rank_type; using layout_type = layout_stride; private: static constexpr rank_type rank_ = extents_type::rank(); / exposition only public: / [mdspan.layout.stride.cons], constructors constexpr mapping() noexcept; constexpr mapping(const mapping&) noexcept = default; template<class OtherIndexType> constexpr mapping(const extents_type&, span<OtherIndexType, rank_>) noexcept; template<class OtherIndexType> constexpr mapping(const extents_type&, const array<OtherIndexType, rank_>&) noexcept; template<class StridedLayoutMapping> constexpr explicit(see below) mapping(const StridedLayoutMapping&) noexcept; constexpr mapping& operator=(const mapping&) noexcept = default; / [mdspan.layout.stride.obs], observers constexpr const extents_type& extents() const noexcept { return extents_; } constexpr array<index_type, rank_> strides() const noexcept { return strides_; } constexpr index_type required_span_size() const noexcept; template<class. Indices> constexpr index_type operator()(Indices..) const noexcept; static constexpr bool is_always_unique() noexcept { return true; } static constexpr bool is_always_exhaustive() noexcept; static constexpr bool is_always_strided() noexcept { return true; } static constexpr bool is_unique() noexcept { return true; } constexpr bool is_exhaustive() const noexcept; static constexpr bool is_strided() noexcept { return true; } constexpr index_type stride(rank_type i) const noexcept { return strides_[i]; } template<class OtherMapping> friend constexpr bool operator=(const mapping&, const OtherMapping&) noexcept; private: extents_type extents_{}; / exposition only array<index_type, rank_> strides_{}; / exposition only / [mdspan.sub.map], submdspan mapping specialization template<class. SliceSpecifiers> constexpr auto submdspan-mapping-impl(SliceSpecifiers..) const / exposition only -> see below; template<class. SliceSpecifiers> friend constexpr auto submdspan_mapping( const mapping& src, SliceSpecifiers.. slices) { return src.submdspan-mapping-impl(slices..); } }; }

If Extents is not a specialization of extents, then the program is ill-formed.

layout_stride::mapping<E> is a trivially copyable type that models regular for each E.

Mandates: If Extents::rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() is representable as a value of type typename Extents::index_type.

23.7.3.4.7.2 Exposition-only helpers [mdspan.layout.stride.expo]

Let REQUIRED-SPAN-SIZE(e, strides) be:

(1.1)
1, if e.rank() == 0 is true,
(1.2)
otherwise 0, if the size of the multidimensional index space e is 0,
(1.3)
otherwise 1 plus the sum of products of (e.extent(r) - 1) and extents_type::index-cast(strides[r]) for all r in the range [0, e.rank()).

Let OFFSET(m) be:

(2.1)
m(), if e.rank() == 0 is true,
(2.2)
otherwise 0, if the size of the multidimensional index space e is 0,
(2.3)
otherwise m(z..) for a pack of integers z that is a multidimensional index in m.extents() and each element of z equals 0.

Let is-extents be the exposition-only variable template defined as follows: template<class T> constexpr bool is-extents = false; / exposition only template<class IndexType, size_t.. Args> constexpr bool is-extents<extents<IndexType, Args..> = true; / exposition only

Let layout-mapping-alike be the exposition-only concept defined as follows: template<class M> concept layout-mapping-alike = requires { / exposition only requires is-extents<typename M::extents_type>; { M::is_always_strided() } -> same_as<bool>; { M::is_always_exhaustive() } -> same_as<bool>; { M::is_always_unique() } -> same_as<bool>; bool_constant<M::is_always_strided()>::value; bool_constant<M::is_always_exhaustive()>::value; bool_constant<M::is_always_unique()>::value; };

[Note 1:

This concept checks that the functions M::is_always_strided(), M::is_always_exhaustive(), and M::is_always_unique() exist, are constant expressions, and have a return type of bool.

— end note]

23.7.3.4.7.3 Constructors [mdspan.layout.stride.cons]

🔗

constexpr mapping() noexcept;

Preconditions: layout_right::mapping<extents_type>().required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with extents_type(), and for all d in the range [0, rank_), direct-non-list-initializes strides_[d] with layout_right::mapping<extents_type>().stride(d).

🔗

template<class OtherIndexType>
  constexpr mapping(const extents_type& e, span<OtherIndexType, rank_> s) noexcept;
template<class OtherIndexType>
  constexpr mapping(const extents_type& e, const array<OtherIndexType, rank_>& s) noexcept;

Preconditions:

(4.1)
The result of converting s[i] to index_type is greater than 0 for all i in the range [0, rank_).
(4.2)
REQUIRED-SPAN-SIZE(e, s) is representable as a value of type index_type ([basic.fundamental]).
(4.3)
If rank_ is greater than 0, then there exists a permutation P of the integers in the range [0, rank_), such that s[ ${p i] > = s [{p i - 1] * e . extent (p {i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}_{i - 1] * e . extent (p {i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}}_{i] > = s [{p i - 1] * e . extent (p {i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}_{i - 1] * e . extent (p {i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) is true for all i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}}$

[Note 1:
For layout_stride, this condition is necessary and sufficient for is_unique() to be true.
— end note]

Effects: Direct-non-list-initializes extents_ with e, and for all d in the range [0, rank_), direct-non-list-initializes strides_[d] with as_const(s[d]).

🔗

template<class StridedLayoutMapping>
  constexpr explicit(see below)
    mapping(const StridedLayoutMapping& other) noexcept;

Preconditions:

(7.1)
StridedLayoutMapping meets the layout mapping requirements ([mdspan.layout.reqmts]),
(7.2)
other.stride(r) > 0 is true for every rank index r of extents(),
(7.3)
other.required_span_size() is representable as a value of type index_type ([basic.fundamental]), and
(7.4)
OFFSET(other) == 0 is true.

Effects: Direct-non-list-initializes extents_ with other.extents(), and for all d in the range [0, rank_), direct-non-list-initializes strides_[d] with other.stride(d).

Remarks: The expression inside explicit is equivalent to: !(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> && (is-mapping-of<layout_left, StridedLayoutMapping> || is-mapping-of<layout_right, StridedLayoutMapping> || is-layout-left-padded-mapping-of<StridedLayoutMapping> || is-layout-right-padded-mapping-of<StridedLayoutMapping> || is-mapping-of<layout_stride, StridedLayoutMapping>)

23.7.3.4.7.4 Observers [mdspan.layout.stride.obs]

🔗

constexpr index_type required_span_size() const noexcept;

Returns: REQUIRED-SPAN-SIZE(extents(), strides_).

🔗

template<class. Indices>
  constexpr index_type operator()(Indices.. i) const noexcept;

Preconditions: extents_type::index-cast(i) is a multidimensional index in extents_ ([mdspan.overview]).

Effects: Let P be a parameter pack such that is_same_v<index_sequence_for<Indices..>, index_sequence<P..> is true.

Equivalent to: return ((static_cast<index_type>(i) * stride(P)) + .. + 0);

🔗

static constexpr bool is_always_exhaustive() noexcept;

Returns: true if rank_ is 0 or if there is a rank index r of extents() such that extents_type::static_extent(r) is 0, otherwise false.

🔗

constexpr bool is_exhaustive() const noexcept;

Returns:

(6.1)
true if rank_ or the size of the multidimensional index space m.extents() is 0.
(6.2)
Otherwise, true if there is a permutation P of the integers in the range [0, rank_) such that stride( ${p 0) equals 1, and stride ({p i) equals stride ({p i - 1) * extents () . extent ({p i - 1) for i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) for i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}_{i - 1) * extents () . extent ({p i - 1) for i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}_{i - 1) for i in the range [1, rank_), where {p i is the {i th element of P .}^{th element of P .}}_{i is the {i th element of P .}^{th element of P .}}}}}_{i)}}_{0)}$
(6.3)
Otherwise, false.

🔗

template<class OtherMapping>
  friend constexpr bool operator=(const mapping& x, const OtherMapping& y) noexcept;

Returns: true if x.extents() == y.extents() is true, OFFSET(y) == 0 is true, and each of x.stride(r) == y.stride(r) is true for r in the range [0, x.extents().rank()).

Otherwise, false.