24 Containers library [containers]

24.7 Views [views]

24.7.3 Multidimensional access [views.multidim]

24.7.3.4 Layout mapping [mdspan.layout]

24.7.3.4.1 General [mdspan.layout.general]

1
#
  • (1.1)
    M denotes a layout mapping class.
  • (1.2)
    m denotes a (possibly const) value of type M.
  • (1.3)
    i and j are packs of (possibly const) integers that are multidimensional indices in m.extents() ([mdspan.overview]).
    [Note 1: 
    The type of each element of the packs can be a different integer type.
    — end note]
  • (1.4)
    r is a (possibly const) rank index of typename M​::​extents_type.
  • (1.5)
    is a pack of (possibly const) integers for which sizeof...() == M​::​extents_type​::​rank() is true, the element is equal to 1, and all other elements are equal to 0.
2
#
In subclauses [mdspan.layout.reqmts] through [mdspan.layout.stride], let is-mapping-of be the exposition-only variable template defined as follows: template<class Layout, class Mapping> constexpr bool is-mapping-of = // exposition only is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;

24.7.3.4.2 Requirements [mdspan.layout.reqmts]

1
#
A type M meets the layout mapping requirements if
  • (1.1)
    M models copyable and equality_comparable,
  • (1.2)
    is_nothrow_move_constructible_v<M> is true,
  • (1.3)
    is_nothrow_move_assignable_v<M> is true,
  • (1.4)
    is_nothrow_swappable_v<M> is true, and
  • (1.5)
    the following types and expressions are well-formed and have the specified semantics.
🔗
typename M::extents_type
2
#
Result: A type that is a specialization of extents.
🔗
typename M::index_type
3
#
Result: typename M​::​extents_type​::​index_type.
🔗
typename M::rank_type
4
#
Result: typename M​::​extents_type​::​rank_type.
🔗
typename M::layout_type
5
#
Result: A type MP that meets the layout mapping policy requirements ([mdspan.layout.policy.reqmts]) and for which is-mapping-of<MP, M> is true.
🔗
m.extents()
6
#
Result: const typename M​::​extents_type&
🔗
m(i...)
7
#
Result: typename M​::​index_type
8
#
Returns: A nonnegative integer less than numeric_limits<typename M​::​index_type>​::​max() and less than or equal to numeric_limits<size_t>​::​max().
🔗
m(i...) == m(static_cast<typename M::index_type>(i)...)
9
#
Result: bool
10
#
Returns: true
🔗
m.required_span_size()
11
#
Result: typename M​::​index_type
12
#
Returns: If the size of the multidimensional index space m.extents() is 0, then 0, else 1 plus the maximum value of m(i...) for all i.
🔗
m.is_unique()
13
#
Result: bool
14
#
Returns: true only if for every i and j where (i != j || ...) is true, m(i...) != m(j...) is true.
[Note 1: 
A mapping can return false even if the condition is met.
For certain layouts, it is possibly not feasible to determine efficiently whether the layout is unique.
— end note]
🔗
m.is_exhaustive()
15
#
Result: bool
16
#
Returns: true only if for all k in the range [0, m.required_span_size()) there exists an i such that m(i...) equals k.
[Note 2: 
A mapping can return false even if the condition is met.
For certain layouts, it is possibly not feasible to determine efficiently whether the layout is exhaustive.
— end note]
🔗
m.is_strided()
17
#
Result: bool
18
#
Returns: true only if for every rank index r of m.extents() there exists an integer such that, for all i where is a multidimensional index in m.extents() ([mdspan.overview]), m((i + )...) - m(i...) equals .
[Note 3: 
This implies that for a strided layout .
— end note]
[Note 4: 
A mapping can return false even if the condition is met.
For certain layouts, it is possibly not feasible to determine efficiently whether the layout is strided.
— end note]
🔗
m.stride(r)
19
#
Preconditions: m.is_strided() is true.
20
#
Result: typename M​::​index_type
21
#
Returns: as defined in m.is_strided() above.
🔗
M::is_always_unique()
22
#
Result: A constant expression ([expr.const]) of type bool.
23
#
Returns: true only if m.is_unique() is true for all possible objects m of type M.
[Note 5: 
A mapping can return false even if the above condition is met.
For certain layout mappings, it is possibly not feasible to determine whether every instance is unique.
— end note]
🔗
M::is_always_exhaustive()
24
#
Result: A constant expression ([expr.const]) of type bool.
25
#
Returns: true only if m.is_exhaustive() is true for all possible objects m of type M.
[Note 6: 
A mapping can return false even if the above condition is met.
For certain layout mappings, it is possibly not feasible to determine whether every instance is exhaustive.
— end note]
🔗
M::is_always_strided()
26
#
Result: A constant expression ([expr.const]) of type bool.
27
#
Returns: true only if m.is_strided() is true for all possible objects m of type M.
[Note 7: 
A mapping can return false even if the above condition is met.
For certain layout mappings, it is possibly not feasible to determine whether every instance is strided.
— end note]

24.7.3.4.3 Layout mapping policy requirements [mdspan.layout.policy.reqmts]

1
#
A type MP meets the layout mapping policy requirements if for a type E that is a specialization of extents, MP​::​mapping<E> is valid and denotes a type X that meets the layout mapping requirements ([mdspan.layout.reqmts]), and for which the qualified-id X​::​layout_type is valid and denotes the type MP and the qualified-id X​::​extents_type denotes E.

24.7.3.4.4 Layout mapping policies [mdspan.layout.policy.overview]

namespace std { struct layout_left { template<class Extents> class mapping; }; struct layout_right { template<class Extents> class mapping; }; struct layout_stride { template<class Extents> class mapping; }; }
1
#
Each of layout_left, layout_right, and layout_stride meets the layout mapping policy requirements and is a trivial type.

24.7.3.4.5 Class template layout_left​::​mapping [mdspan.layout.left]

24.7.3.4.5.1 Overview [mdspan.layout.left.overview]

1
#
layout_left provides a layout mapping where the leftmost extent has stride 1, and strides increase left-to-right as the product of extents.
namespace std { template<class Extents> class layout_left::mapping { public: using extents_type = Extents; using index_type = typename extents_type::index_type; using size_type = typename extents_type::size_type; using rank_type = typename extents_type::rank_type; using layout_type = layout_left; // [mdspan.layout.left.cons], constructors constexpr mapping() noexcept = default; constexpr mapping(const mapping&) noexcept = default; constexpr mapping(const extents_type&) noexcept; template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const mapping<OtherExtents>&) noexcept; template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const layout_right::mapping<OtherExtents>&) noexcept; template<class OtherExtents> constexpr explicit(extents_type::rank() > 0) mapping(const layout_stride::mapping<OtherExtents>&); constexpr mapping& operator=(const mapping&) noexcept = default; // [mdspan.layout.left.obs], observers constexpr const extents_type& extents() const noexcept { return extents_; } 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 { return true; } static constexpr bool is_always_strided() noexcept { return true; } static constexpr bool is_unique() noexcept { return true; } static constexpr bool is_exhaustive() noexcept { return true; } static constexpr bool is_strided() noexcept { return true; } constexpr index_type stride(rank_type) const noexcept; template<class OtherExtents> friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept; private: extents_type extents_{}; // exposition only // [mdspan.submdspan.mapping], submdspan mapping specialization template<class... SliceSpecifiers> constexpr auto submdspan-mapping-impl( // exposition only SliceSpecifiers... slices) const -> see below; template<class... SliceSpecifiers> friend constexpr auto submdspan_mapping( const mapping& src, SliceSpecifiers... slices) { return src.submdspan-mapping-impl(slices...); } }; }
2
#
If Extents is not a specialization of extents, then the program is ill-formed.
3
#
layout_left​::​mapping<E> is a trivially copyable type that models regular for each E.
4
#
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.

24.7.3.4.5.2 Constructors [mdspan.layout.left.cons]

🔗
constexpr mapping(const extents_type& e) noexcept;
1
#
Preconditions: The size of the multidimensional index space e is representable as a value of type index_type ([basic.fundamental]).
2
#
Effects: Direct-non-list-initializes extents_ with e.
🔗
template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const mapping<OtherExtents>& other) noexcept;
3
#
Constraints: is_constructible_v<extents_type, OtherExtents> is true.
4
#
Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).
5
#
Effects: Direct-non-list-initializes extents_ with other.extents().
🔗
template<class OtherExents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
6
#
Constraints:
  • (6.1)
    extents_type​::​rank() <= 1 is true, and
  • (6.2)
    is_constructible_v<extents_type, OtherExtents> is true.
7
#
Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).
8
#
Effects: Direct-non-list-initializes extents_ with other.extents().
🔗
template<class OtherExtents> constexpr explicit(extents_type::rank() > 0) mapping(const layout_stride::mapping<OtherExtents>& other);
9
#
Constraints: is_constructible_v<extents_type, OtherExtents> is true.
10
#
Preconditions:
  • (10.1)
    If extents_type​::​rank() > 0 is true, then for all r in the range [0, extents_type​::​rank()), other.stride(r) equals other.extents().fwd-prod-of-extents(r), and
  • (10.2)
    other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).
11
#
Effects: Direct-non-list-initializes extents_ with other.extents().

24.7.3.4.5.3 Observers [mdspan.layout.left.obs]

🔗
constexpr index_type required_span_size() const noexcept;
1
#
Returns: extents().fwd-prod-of-extents(extents_type​::​rank()).
🔗
template<class... Indices> constexpr index_type operator()(Indices... i) const noexcept;
2
#
Constraints:
  • (2.1)
    sizeof...(Indices) == extents_type​::​rank() is true,
  • (2.2)
    (is_convertible_v<Indices, index_type> && ...) is true, and
  • (2.3)
    (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
3
#
Preconditions: extents_type​::​index-cast(i) is a multidimensional index in extents_ ([mdspan.overview]).
4
#
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);
🔗
constexpr index_type stride(rank_type i) const;
5
#
Constraints: extents_type​::​rank() > 0 is true.
6
#
Preconditions: i < extents_type​::​rank() is true.
7
#
Returns: extents().fwd-prod-of-extents(i).
🔗
template<class OtherExtents> friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
8
#
Constraints: extents_type​::​rank() == OtherExtents​::​rank() is true.
9
#
Effects: Equivalent to: return x.extents() == y.extents();

24.7.3.4.7 Class template layout_stride​::​mapping [mdspan.layout.stride]

24.7.3.4.7.1 Overview [mdspan.layout.stride.overview]

1
#
layout_stride provides a layout mapping where the strides are user-defined.
namespace std { template<class Extents> class layout_stride::mapping { public: using extents_type = Extents; using index_type = typename extents_type::index_type; using size_type = typename extents_type::size_type; using rank_type = typename 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 { return false; } 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.submdspan.mapping], submdspan mapping specialization template<class... SliceSpecifiers> constexpr auto submdspan-mapping-impl( // exposition only SliceSpecifiers... slices) const -> see below; template<class... SliceSpecifiers> friend constexpr auto submdspan_mapping( const mapping& src, SliceSpecifiers... slices) { return src.submdspan-mapping-impl(slices...); } }; }
2
#
If Extents is not a specialization of extents, then the program is ill-formed.
3
#
layout_stride​::​mapping<E> is a trivially copyable type that models regular for each E.
4
#
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.

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

1
#
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()).
2
#
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.
3
#
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
4
#
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]

24.7.3.4.7.3 Constructors [mdspan.layout.stride.cons]

🔗
constexpr mapping() noexcept;
1
#
Preconditions: layout_right​::​mapping<extents_type>().required_span_size() is representable as a value of type index_type ([basic.fundamental]).
2
#
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;
3
#
Constraints:
  • (3.1)
    is_convertible_v<const OtherIndexType&, index_type> is true, and
  • (3.2)
    is_nothrow_constructible_v<index_type, const OtherIndexType&> is true.
4
#
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[] >= s[] * e.extent(p) is true for all i in the range [1, rank_), where is the element of P.
    [Note 1: 
    For layout_stride, this condition is necessary and sufficient for is_unique() to be true.
    — end note]
5
#
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;
6
#
Constraints:
  • (6.1)
    layout-mapping-alike<StridedLayoutMapping> is satisfied.
  • (6.2)
    is_constructible_v<extents_type, typename StridedLayoutMapping​::​extents_type> is
    true.
  • (6.3)
    StridedLayoutMapping​::​is_always_unique() is true.
  • (6.4)
    StridedLayoutMapping​::​is_always_strided() is true.
7
#
Preconditions:
8
#
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).
9
#
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-mapping-of<layout_stride, StridedLayoutMapping>))

24.7.3.4.7.4 Observers [mdspan.layout.stride.obs]

🔗
constexpr index_type required_span_size() const noexcept;
1
#
Returns: REQUIRED-SPAN-SIZE(extents(), strides_).
🔗
template<class... Indices> constexpr index_type operator()(Indices... i) const noexcept;
2
#
Constraints:
  • (2.1)
    sizeof...(Indices) == rank_ is true,
  • (2.2)
    (is_convertible_v<Indices, index_type> && ...) is true, and
  • (2.3)
    (is_nothrow_constructible_v<index_type, Indices> && ...) is true.
3
#
Preconditions: extents_type​::​index-cast(i) is a multidimensional index in extents_ ([mdspan.overview]).
4
#
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);
🔗
constexpr bool is_exhaustive() const noexcept;
5
#
Returns:
  • (5.1)
    true if rank_ is 0.
  • (5.2)
    Otherwise, true if there is a permutation P of the integers in the range [0, rank_) such that stride() equals 1, and stride() equals stride() * extents().extent() for i in the range [1, rank_), where is the element of P.
  • (5.3)
    Otherwise, false.
🔗
template<class OtherMapping> friend constexpr bool operator==(const mapping& x, const OtherMapping& y) noexcept;
6
#
Constraints:
7
#
Preconditions: OtherMapping meets the layout mapping requirements ([mdspan.layout.policy.reqmts]).
8
#
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.