23 Containers library [containers]

23.7 Views [views]

23.7.3 Multidimensional access [views.multidim]

23.7.3.1 Overview [mdspan.overview]

A multidimensional index space is a Cartesian product of integer intervals.

Each interval can be represented by a half-open range

[L_{i}, U_{i})

, where

L_{i}

and

U_{i}

are the lower and upper bounds of the

i^{th}

dimension.

The rank of a multidimensional index space is the number of intervals it represents.

The size of a multidimensional index space is the product of

U_{i} - L_{i}

for each dimension i if its rank is greater than 0, and 1 otherwise.

An integer r is a rank index of an index space S if r is in the range

[0, rank of S)

A pack of integers idx is a multidimensional index in a multidimensional index space S (or representation thereof) if both of the following are true:

(3.1)
sizeof...(idx) is equal to the rank of S, and
(3.2)
for every rank index i of S, the $i^{th}$ value of idx is an integer in the interval $[L_{i}, U_{i})$ of S.

23.7.3.2 Header <mdspan> synopsis [mdspan.syn]

🔗

// all freestanding namespace std { // [mdspan.extents], class template extents template<class IndexType, size_t... Extents> class extents; // [mdspan.extents.dextents], alias template dextents template<class IndexType, size_t Rank> using dextents = see below; // [mdspan.extents.dims], alias template dims template<size_t Rank, class IndexType = size_t> using dims = see below; // [mdspan.layout], layout mapping struct layout_left; struct layout_right; struct layout_stride; template<size_t PaddingValue = dynamic_extent> struct layout_left_padded; template<size_t PaddingValue = dynamic_extent> struct layout_right_padded; // [mdspan.accessor.default], class template default_accessor template<class ElementType> class default_accessor; // [mdspan.mdspan], class template mdspan template<class ElementType, class Extents, class LayoutPolicy = layout_right, class AccessorPolicy = default_accessor<ElementType>> class mdspan; // [mdspan.sub], submdspan creation template<class OffsetType, class LengthType, class StrideType> struct strided_slice; template<class LayoutMapping> struct submdspan_mapping_result; struct full_extent_t { explicit full_extent_t() = default; }; inline constexpr full_extent_t full_extent{}; template<class IndexType, class... Extents, class... SliceSpecifiers> constexpr auto submdspan_extents(const extents<IndexType, Extents...>&, SliceSpecifiers...); // [mdspan.sub.sub], submdspan function template template<class ElementType, class Extents, class LayoutPolicy, class AccessorPolicy, class... SliceSpecifiers> constexpr auto submdspan( const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src, SliceSpecifiers... slices) -> see below; template<class T, class IndexType> concept index-pair-like = // exposition only pair-like<T> && convertible_to<tuple_element_t<0, T>, IndexType> && convertible_to<tuple_element_t<1, T>, IndexType>; }

23.7.3.3 Class template extents [mdspan.extents]

23.7.3.3.1 Overview [mdspan.extents.overview]

The class template extents represents a multidimensional index space of rank equal to sizeof...(Extents).

In ([views]), extents is used synonymously with multidimensional index space.

namespace std { template<class IndexType, size_t... Extents> class extents { public: using index_type = IndexType; using size_type = make_unsigned_t<index_type>; using rank_type = size_t; // [mdspan.extents.obs], observers of the multidimensional index space static constexpr rank_type rank() noexcept { return sizeof...(Extents); } static constexpr rank_type rank_dynamic() noexcept { return dynamic-index(rank()); } static constexpr size_t static_extent(rank_type) noexcept; constexpr index_type extent(rank_type) const noexcept; // [mdspan.extents.cons], constructors constexpr extents() noexcept = default; template<class OtherIndexType, size_t... OtherExtents> constexpr explicit(see below) extents(const extents<OtherIndexType, OtherExtents...>&) noexcept; template<class... OtherIndexTypes> constexpr explicit extents(OtherIndexTypes...) noexcept; template<class OtherIndexType, size_t N> constexpr explicit(N != rank_dynamic()) extents(span<OtherIndexType, N>) noexcept; template<class OtherIndexType, size_t N> constexpr explicit(N != rank_dynamic()) extents(const array<OtherIndexType, N>&) noexcept; // [mdspan.extents.cmp], comparison operators template<class OtherIndexType, size_t... OtherExtents> friend constexpr bool operator==(const extents&, const extents<OtherIndexType, OtherExtents...>&) noexcept; // [mdspan.extents.expo], exposition-only helpers constexpr size_t fwd-prod-of-extents(rank_type) const noexcept; // exposition only constexpr size_t rev-prod-of-extents(rank_type) const noexcept; // exposition only template<class OtherIndexType> static constexpr auto index-cast(OtherIndexType&&) noexcept; // exposition only private: static constexpr rank_type dynamic-index(rank_type) noexcept; // exposition only static constexpr rank_type dynamic-index-inv(rank_type) noexcept; // exposition only array<index_type, rank_dynamic()> dynamic-extents{}; // exposition only }; template<class... Integrals> explicit extents(Integrals...) -> see below; }

Mandates:

(1.1)
IndexType is a signed or unsigned integer type, and
(1.2)
each element of Extents is either equal to dynamic_extent, or is representable as a value of type IndexType.

Each specialization of extents models regular and is trivially copyable.

Let

E_{r}

be the

r^{th}

element of Extents.

E_{r}

is a dynamic extent if it is equal to dynamic_extent, otherwise

E_{r}

is a static extent.

Let

D_{r}

be the value of dynamic-extents[dynamic-index(r)] if

E_{r}

is a dynamic extent, otherwise

E_{r}

The

r^{th}

interval of the multidimensional index space represented by an extents object is

[0, D_{r})

23.7.3.3.2 Exposition-only helpers [mdspan.extents.expo]

🔗

static constexpr rank_type dynamic-index(rank_type i) noexcept;

Preconditions: i <= rank() is true.

Returns: The number of

E_{r}

with

r < i

for which

E_{r}

is a dynamic extent.

🔗

static constexpr rank_type dynamic-index-inv(rank_type i) noexcept;

Preconditions: i < rank_dynamic() is true.

Returns: The minimum value of r such that dynamic-index(r + 1) == i + 1 is true.

🔗

constexpr size_t fwd-prod-of-extents(rank_type i) const noexcept;

Preconditions: i <= rank() is true.

Returns: If i > 0 is true, the product of extent(k) for all k in the range [0, i), otherwise 1.

🔗

constexpr size_t rev-prod-of-extents(rank_type i) const noexcept;

Preconditions: i < rank() is true.

Returns: If i + 1 < rank() is true, the product of extent(k) for all k in the range [i + 1, rank()), otherwise 1.

🔗

template<class OtherIndexType>
  static constexpr auto index-cast(OtherIndexType&& i) noexcept;

Effects:

(9.1)
If OtherIndexType is an integral type other than bool, then equivalent to return i;,
(9.2)
otherwise, equivalent to return static_cast<index_type>(i);.

[Note 1:

This function will always return an integral type other than bool.

Since this function's call sites are constrained on convertibility of OtherIndexType to index_type, integer-class types can use the static_cast branch without loss of precision.

— end note]

23.7.3.3.3 Constructors [mdspan.extents.cons]

🔗

template<class OtherIndexType, size_t... OtherExtents>
  constexpr explicit(see below)
    extents(const extents<OtherIndexType, OtherExtents...>& other) noexcept;

Constraints:

(1.1)
sizeof...(OtherExtents) == rank() is true.
(1.2)
((OtherExtents == dynamic_extent || Extents == dynamic_extent || OtherExtents ==
Extents) && ...) is true.

Preconditions:

(2.1)
other.extent(r) equals $E_{r}$ for each r for which $E_{r}$ is a static extent, and
(2.2)
either
- (2.2.1)
  sizeof...(OtherExtents) is zero, or
- (2.2.2)
  other.extent(r) is representable as a value of type index_type for every rank index r of other.

Postconditions: *this == other is true.

Remarks: The expression inside explicit is equivalent to: (((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || ... ) || (numeric_limits<index_type>::max() < numeric_limits<OtherIndexType>::max())

🔗

template<class... OtherIndexTypes>
  constexpr explicit extents(OtherIndexTypes... exts) noexcept;

Let N be sizeof...(OtherIndexTypes), and let exts_arr be array<index_type, N>{static_cast<
index_type>(std::move(exts))...}.

Constraints:

(6.1)
(is_convertible_v<OtherIndexTypes, index_type> && ...) is true,
(6.2)
(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...) is true, and
(6.3)
N == rank_dynamic() || N == rank() is true.
[Note 1:
One can construct extents from just dynamic extents, which are all the values getting stored, or from all the extents with a precondition.
— end note]

Preconditions:

(7.1)
If N != rank_dynamic() is true, exts_arr[r] equals $E_{r}$ for each r for which $E_{r}$ is a static extent, and
(7.2)
either
- (7.2.1)
  sizeof...(exts) == 0 is true, or
- (7.2.2)
  each element of exts is representable as a nonnegative value of type index_type.

Postconditions: *this == extents(exts_arr) is true.

🔗

template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic())
    extents(span<OtherIndexType, N> exts) noexcept;
template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic())
    extents(const array<OtherIndexType, N>& exts) noexcept;

Constraints:

(9.1)
is_convertible_v<const OtherIndexType&, index_type> is true,
(9.2)
is_nothrow_constructible_v<index_type, const OtherIndexType&> is true, and
(9.3)
N == rank_dynamic() || N == rank() is true.

Preconditions:

(10.1)
If N != rank_dynamic() is true, exts[r] equals $E_{r}$ for each r for which $E_{r}$ is a static extent, and
(10.2)
either
- (10.2.1)
  N is zero, or
- (10.2.2)
  exts[r] is representable as a nonnegative value of type index_type for every rank index r.

Effects:

(11.1)
If N equals rank_dynamic(), for all d in the range [0, rank_dynamic()), direct-non-list-initializes dynamic-extents[d] with as_const(exts[d]).
(11.2)
Otherwise, for all d in the range [0, rank_dynamic()), direct-non-list-initializes dynamic-extents[d] with as_const(exts[dynamic-index-inv(d)]).

🔗

template<class... Integrals>
  explicit extents(Integrals...) -> see below;

Constraints: (is_convertible_v<Integrals, size_t> && ...) is true.

Remarks: The deduced type is extents<size_t, maybe-static-ext<Integrals>...>.

23.7.3.3.4 Observers of the multidimensional index space [mdspan.extents.obs]

🔗

static constexpr size_t static_extent(rank_type i) noexcept;

Preconditions: i < rank() is true.

Returns:

E_{i}

🔗

constexpr index_type extent(rank_type i) const noexcept;

Preconditions: i < rank() is true.

Returns:

D_{i}

23.7.3.3.5 Comparison operators [mdspan.extents.cmp]

🔗

template<class OtherIndexType, size_t... OtherExtents>
  friend constexpr bool operator==(const extents& lhs,
                                   const extents<OtherIndexType, OtherExtents...>& rhs) noexcept;

Returns: true if lhs.rank() equals rhs.rank() and if lhs.extent(r) equals rhs.extent(r) for every rank index r of rhs, otherwise false.

23.7.3.3.6 Alias template dextents [mdspan.extents.dextents]

🔗

template<class IndexType, size_t Rank>
  using dextents = see below;

Result: A type E that is a specialization of extents such that E::rank() == Rank && E::rank() == E::rank_dynamic() is true, and E::index_type denotes IndexType.

23.7.3.3.7 Alias template dims [mdspan.extents.dims]

🔗

template<size_t Rank, class IndexType = size_t>
  using dims = see below;

Result: A type E that is a specialization of extents such that E::rank() == Rank && E::rank() == E::rank_dynamic() is true, and E::index_type denotes IndexType.

23.7.3.4 Layout mapping [mdspan.layout]

23.7.3.4.1 General [mdspan.layout.general]

In [mdspan.layout.reqmts] and [mdspan.layout.policy.reqmts]:

(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)
$d_{r}$ is a pack of (possibly const) integers for which sizeof...( $d_{r}$ ) == M::extents_type::rank() is true, the $r^{th}$ element is equal to 1, and all other elements are equal to 0.

In [mdspan.layout.reqmts] through [mdspan.layout.stride]:

(2.1)
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>;
(2.2)
Let is-layout-left-padded-mapping-of be the exposition-only variable template defined as follows: template<class Mapping> constexpr bool is-layout-left-padded-mapping-of = see below; // exposition only where is-layout-left-padded-mapping-of<Mapping> is true if and only if Mapping denotes a specialization of layout_left_padded<S>::mapping for some value S of type size_t.
(2.3)
Let is-layout-right-padded-mapping-of be the exposition-only variable template defined as follows: template<class Mapping> constexpr bool is-layout-right-padded-mapping-of = see below; // exposition only where is-layout-right-padded-mapping-of<Mapping> is true if and only if Mapping denotes a specialization of layout_right_padded<S>::mapping for some value S of type size_t.
(2.4)
For nonnegative integers x and y, let $LEAST-MULTIPLE-AT-LEAST (x, y)$ denote
- (2.4.1)
  y if x is zero,
- (2.4.2)
  otherwise, the least multiple of x that is greater than or equal to y.

23.7.3.4.2 Requirements [mdspan.layout.reqmts]

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

Result: A type that is a specialization of extents.

🔗

typename M::index_type

Result: typename M::extents_type::index_type.

🔗

typename M::rank_type

Result: typename M::extents_type::rank_type.

🔗

typename M::layout_type

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()

Result: const typename M::extents_type&

🔗

m(i...)

Result: typename M::index_type

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)...)

Result: bool

Returns: true

🔗

m.required_span_size()

Result: typename M::index_type

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()

Result: bool

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()

Result: bool

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()

Result: bool

Returns: true only if for every rank index r of m.extents() there exists an integer

s_{r}

such that, for all i where

(i + d_{r})

is a multidimensional index in m.extents() ([mdspan.overview]), m((i +

d_{r}

)...) - m(i...) equals

s_{r}

[Note 3:

This implies that for a strided layout

m (i_{0}, \dots, i_{k}) = m (0, \dots, 0) + i_{0} \times s_{0} + \dots + i_{k} \times s_{k}

— 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)

Preconditions: m.is_strided() is true.

Result: typename M::index_type

Returns:

s_{r}

as defined in m.is_strided() above.

🔗

M::is_always_unique()

Result: A constant expression ([expr.const]) of type bool.

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()

Result: A constant expression ([expr.const]) of type bool.

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()

Result: A constant expression ([expr.const]) of type bool.

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]

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

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.

23.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; }; template<size_t PaddingValue> struct layout_left_padded { template<class Extents> class mapping; }; template<size_t PaddingValue> struct layout_right_padded { template<class Extents> class mapping; }; }

Each of layout_left, layout_right, and layout_stride meets the layout mapping policy requirements and is a trivial type.

Each specialization of layout_left_padded and layout_right_padded meets the layout mapping policy requirements and is a trivial type.

23.7.3.4.5 Class template layout_left::mapping [mdspan.layout.left]

23.7.3.4.5.1 Overview [mdspan.layout.left.overview]

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 LayoutLeftPaddedMapping> constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type, extents_type>) mapping(const LayoutLeftPaddedMapping&) 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.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_left::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.5.2 Constructors [mdspan.layout.left.cons]

🔗

constexpr mapping(const extents_type& e) noexcept;

Preconditions: The size of the multidimensional index space e is representable as a value of type index_type ([basic.fundamental]).

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;

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

🔗

template<class OtherExtents>
  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
    mapping(const layout_right::mapping<OtherExtents>& other) noexcept;

Constraints:

(6.1)
extents_type::rank() <= 1 is true, and
(6.2)
is_constructible_v<extents_type, OtherExtents> is true.

Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

🔗

template<class LayoutLeftPaddedMapping>
  constexpr explicit(!is_convertible_v<typename LayoutLeftPaddedMapping::extents_type,
                                       extents_type>)
    mapping(const LayoutLeftPaddedMapping&) noexcept;

Constraints:

(9.1)
is-layout-left-padded-mapping-of<LayoutLeftPaddedMapping> is true.
(9.2)
is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>
is true.

Mandates: If

(10.1)
Extents::rank() is greater than one,
(10.2)
Extents::static_extent(0) does not equal dynamic_extent, and
(10.3)
LayoutLeftPaddedMapping::static-padding-stride does not equal dynamic_extent,

then Extents::static_extent(0) equals LayoutLeftPaddedMapping::static-padding-stride.

Preconditions:

(11.1)
If extents_type::rank() > 1 is true, then other.stride(1) equals other.extents(0).
(11.2)
other.required_span_size() is representable as a value of type index_type.

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);

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions:

(14.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
(14.2)
other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

23.7.3.4.5.3 Observers [mdspan.layout.left.obs]

🔗

constexpr index_type required_span_size() const noexcept;

Returns: extents().fwd-prod-of-extents(extents_type::rank()).

🔗

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

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.

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);

🔗

constexpr index_type stride(rank_type i) const;

Constraints: extents_type::rank() > 0 is true.

Preconditions: i < extents_type::rank() is true.

Returns: extents().fwd-prod-of-extents(i).

🔗

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

Constraints: extents_type::rank() == OtherExtents::rank() is true.

Effects: Equivalent to: return x.extents() == y.extents();

23.7.3.4.6 Class template layout_right::mapping [mdspan.layout.right]

23.7.3.4.6.1 Overview [mdspan.layout.right.overview]

layout_right provides a layout mapping where the rightmost extent is stride 1, and strides increase right-to-left as the product of extents.

namespace std { template<class Extents> class layout_right::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_right; // [mdspan.layout.right.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_left::mapping<OtherExtents>&) noexcept; template<class LayoutRightPaddedMapping> constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type, extents_type>) mapping(const LayoutRightPaddedMapping&) noexcept; template<class OtherExtents> constexpr explicit(extents_type::rank() > 0) mapping(const layout_stride::mapping<OtherExtents>&) noexcept; constexpr mapping& operator=(const mapping&) noexcept = default; // [mdspan.layout.right.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.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_right::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.6.2 Constructors [mdspan.layout.right.cons]

🔗

constexpr mapping(const extents_type& e) noexcept;

Preconditions: The size of the multidimensional index space e is representable as a value of type index_type ([basic.fundamental]).

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;

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

🔗

template<class OtherExtents>
  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
    mapping(const layout_left::mapping<OtherExtents>& other) noexcept;

Constraints:

(6.1)
extents_type::rank() <= 1 is true, and
(6.2)
is_constructible_v<extents_type, OtherExtents> is true.

Preconditions: other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

🔗

template<class LayoutRightPaddedMapping>
  constexpr explicit(!is_convertible_v<typename LayoutRightPaddedMapping::extents_type,
                                       extents_type>)
    mapping(const LayoutRightPaddedMapping&) noexcept;

Constraints:

(9.1)
is-layout-right-padded-mapping-of<LayoutRightPaddedMapping> is true.
(9.2)
is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_-
type> is true.

Mandates: If

(10.1)
Extents::rank() is greater than one,
(10.2)
Extents::static_extent(Extents::rank() - 1) does not equal dynamic_extent, and
(10.3)
LayoutRightPaddedMapping::static-padding-stride does not equal dynamic_extent,

then Extents::static_extent(Extents::rank() - 1) equals LayoutRightPaddedMapping::static-padding-stride.

Preconditions:

(11.1)
If extents_type::rank() > 1 is true, then other.stride(extents_type::rank() - 2)
equals other.extents().extent(extents_type::rank() - 1).
(11.2)
other.required_span_size() is representable as a value of type index_type.

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) noexcept;

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions:

(14.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().rev-prod-of-extents(r).
(14.2)
other.required_span_size() is representable as a value of type index_type ([basic.fundamental]).

Effects: Direct-non-list-initializes extents_ with other.extents().

23.7.3.4.6.3 Observers [mdspan.layout.right.obs]

🔗

index_type required_span_size() const noexcept;

Returns: extents().fwd-prod-of-extents(extents_type::rank()).

🔗

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

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.

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);

🔗

constexpr index_type stride(rank_type i) const noexcept;

Constraints: extents_type::rank() > 0 is true.

Preconditions: i < extents_type::rank() is true.

Returns: extents().rev-prod-of-extents(i).

🔗

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

Constraints: extents_type::rank() == OtherExtents::rank() is true.

Effects: Equivalent to: return x.extents() == y.extents();

23.7.3.4.7 Class template layout_stride::mapping [mdspan.layout.stride]

23.7.3.4.7.1 Overview [mdspan.layout.stride.overview]

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.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;

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.

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.

[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;

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.

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;

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.

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);

🔗

constexpr bool is_exhaustive() const noexcept;

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( $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.
(5.3)
Otherwise, false.

🔗

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

Constraints:

(6.1)
layout-mapping-alike<OtherMapping> is satisfied.
(6.2)
rank_ == OtherMapping::extents_type::rank() is true.
(6.3)
OtherMapping::is_always_strided() is true.

Preconditions: OtherMapping meets the layout mapping requirements ([mdspan.layout.policy.reqmts]).

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.

23.7.3.4.8 Class template layout_left_padded::mapping [mdspan.layout.leftpad]

23.7.3.4.8.1 Overview [mdspan.layout.leftpad.overview]

layout_left_padded provides a layout mapping that behaves like layout_left::mapping, except that the padding stride stride(1) can be greater than or equal to extent(0).

namespace std { template<size_t PaddingValue> template<class Extents> class layout_left_padded<PaddingValue>::mapping { public: static constexpr size_t padding_value = PaddingValue; 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_padded<PaddingValue>; private: static constexpr size_t rank_ = extents_type::rank(); // exposition only static constexpr size_t first-static-extent = // exposition only extents_type::static_extent(0); // [mdspan.layout.leftpad.expo], exposition-only members static constexpr size_t static-padding-stride = see below; // exposition only public: // [mdspan.layout.leftpad.cons], constructors constexpr mapping() noexcept : mapping(extents_type{}) {} constexpr mapping(const mapping&) noexcept = default; constexpr mapping(const extents_type&); template<class OtherIndexType> constexpr mapping(const extents_type&, OtherIndexType); template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const layout_left::mapping<OtherExtents>&); template<class OtherExtents> constexpr explicit(extents_type::rank() > 0) mapping(const layout_stride::mapping<OtherExtents>&); template<class LayoutLeftPaddedMapping> constexpr explicit(see below) mapping(const LayoutLeftPaddedMapping&); template<class LayoutRightPaddedMapping> constexpr explicit(see below) mapping(const LayoutRightPaddedMapping&) noexcept; constexpr mapping& operator=(const mapping&) noexcept = default; // [mdspan.layout.leftpad.obs], observers constexpr const extents_type& extents() const noexcept { return extents_; } constexpr array<index_type, rank_> strides() const noexcept; 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) const noexcept; template<class LayoutLeftPaddedMapping> friend constexpr bool operator==(const mapping&, const LayoutLeftPaddedMapping&) noexcept; private: // [mdspan.layout.leftpad.expo], exposition-only members index_type stride-1 = static-padding-stride; // exposition only extents_type extents_{}; // 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_left_padded::mapping<E> is a trivially copyable type that models regular for each E.

Throughout [mdspan.layout.leftpad], let P_rank be the following size rank_ parameter pack of size_t values:

(4.1)
the empty parameter pack, if rank_ equals zero;
(4.2)
otherwise, 0zu, if rank_ equals one;
(4.3)
otherwise, the parameter pack 0zu, 1zu, …, rank_- 1.

Mandates:

(5.1)
If rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() is representable as a value of type index_type.
(5.2)
padding_value is representable as a value of type index_type.
(5.3)
If
- (5.3.1)
  rank_ is greater than one,
- (5.3.2)
  padding_value does not equal dynamic_extent, and
- (5.3.3)
  first-static-extent does not equal dynamic_extent,
then LEAST-MULTIPLE-AT-LEAST(padding_value, first-static-extent) is representable as a value of type size_t, and is representable as a value of type index_type.
(5.4)
If
- (5.4.1)
  rank_ is greater than one,
- (5.4.2)
  padding_value does not equal dynamic_extent, and
- (5.4.3)
  extents_type::static_extent(k) does not equal dynamic_extent for all k in the range [0, extents_type::rank()),
then the product of LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(0)) and all values ext.static_extent(k) with k in the range of [1, rank_) is representable as a value of type size_t, and is representable as a value of type index_type.

23.7.3.4.8.2 Exposition-only members [mdspan.layout.leftpad.expo]

🔗

static constexpr size_t static-padding-stride = see below;

The value is

(1.1)
0, if rank_ equals zero or one;
(1.2)
otherwise, dynamic_extent, if padding_value or first-static-extent equals dynamic_extent;
(1.3)
otherwise, the size_t value which is LEAST-MULTIPLE-AT-LEAST(padding_value, first-static-extent).

🔗

index_type stride-1 = static-padding-stride;

Recommended practice: Implementations should not store this value if static-padding-stride is not dynamic_extent.

[Note 1:

Using extents<index_type, static-padding-stride> instead of index_type as the type of stride-1 would achieve this.

— end note]

23.7.3.4.8.3 Constructors [mdspan.layout.leftpad.cons]

🔗

constexpr mapping(const extents_type& ext);

Preconditions:

(1.1)
The size of the multidimensional index space ext is representable as a value of type index_type.
(1.2)
If rank_ is greater than one and padding_value does not equal dynamic_extent, then LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(0)) is representable as a value of type index_type.
(1.3)
If rank_ is greater than one and padding_value does not equal dynamic_extent, then the product of LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(0)) and all values ext.extent(k) with k in the range of [1, rank_) is representable as a value of type index_type.

Effects:

(2.1)
Direct-non-list-initializes extents_ with ext; and
(2.2)
if rank_ is greater than one, direct-non-list-initializes stride-1
- (2.2.1)
  with ext.extent(0) if padding_value is dynamic_extent,
- (2.2.2)
  otherwise with LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(0)).

🔗

template<class OtherIndexType>
constexpr mapping(const extents_type& ext, OtherIndexType pad);

Constraints:

(3.1)
is_convertible_v<OtherIndexType, index_type> is true.
(3.2)
is_nothrow_constructible_v<index_type, OtherIndexType> is true.

Preconditions:

(4.1)
pad is representable as a value of type index_type.
(4.2)
extents_type::index-cast(pad) is greater than zero.
(4.3)
If rank_ is greater than one, then LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(0)) is representable as a value of type index_type.
(4.4)
If rank_ is greater than one, then the product of LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(0)) and all values ext.extent(k) with k in the range of [1, rank_) is representable as a value of type index_type.
(4.5)
If padding_value is not equal to dynamic_extent, padding_value equals extents_type::index-cast(pad).

Effects: Direct-non-list-initializes extents_ with ext, and if rank_ is greater than one, direct-non-list-initializes stride-1 with LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(0)).

🔗

template<class OtherExtents>
  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
    mapping(const layout_left::mapping<OtherExtents>& other);

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Mandates: If OtherExtents::rank() is greater than 1, then (static-padding-stride == dynamic_extent) || (OtherExtents::static_extent(0) == dynamic_extent) || (static-padding-stride == OtherExtents::static_extent(0)) is true.

Preconditions:

(8.1)
If extents_type::rank() > 1 is true and padding_value == dynamic_extent is false, then other.stride(1) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extents().extent(0))) and
(8.2)
other.required_span_size() is representable as a value of type index_type.

Effects: Equivalent to mapping(other.extents()).

🔗

template<class OtherExtents>
  constexpr explicit(rank_ > 0)
    mapping(const layout_stride::mapping<OtherExtents>& other);

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions:

(11.1)
If rank_ is greater than 1 and padding_value does not equal dynamic_extent, then other.stride(1) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extents().extent(0)))
(11.2)
If rank_ is greater than 0, then other.stride(0) equals 1.
(11.3)
If rank_ is greater than 2, then for all r in the range [2, rank_), other.stride(r) equals (other.extents().fwd-prod-of-extents(r) / other.extents().extent(0)) * other.stride(1)
(11.4)
other.required_span_size() is representable as a value of type index_type.

Effects:

(12.1)
Direct-non-list-initializes extents_ with other.extents() and
(12.2)
if rank_ is greater than one, direct-non-list-initializes stride-1 with other.stride(1).

🔗

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

Constraints:

(13.1)
is-layout-left-padded-mapping-of<LayoutLeftPaddedMapping> is true.
(13.2)
is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>
is true.

Mandates: If rank_ is greater than 1, then padding_value == dynamic_extent || LayoutLeftPaddedMapping::padding_value == dynamic_extent || padding_value == LayoutLeftPaddedMapping::padding_value is true.

(15.1)
If rank_ is greater than 1 and padding_value does not equal dynamic_extent, then other.stride(1) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extent(0)))
(15.2)
other.required_span_size() is representable as a value of type index_type.

Effects:

(16.1)
Direct-non-list-initializes extents_ with other.extents() and
(16.2)
if rank_ is greater than one, direct-non-list-initializes stride-1 with other.stride(1).

Remarks: The expression inside explicit is equivalent to: rank_> 1 && (padding_value != dynamic_extent || LayoutLeftPaddedMapping::padding_value == dynamic_extent)

🔗

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

Constraints:

(18.1)
is-layout-right-padded-mapping-of<LayoutRightPaddedMapping> is true or
is-mapping-of<layout_right, LayoutRightPaddedMapping> is true.
(18.2)
rank_ equals zero or one.
(18.3)
is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_-
type> is true.

Preconditions: other.required_span_size() is representable as a value of type index_type.

Effects: Direct-non-list-initializes extents_ with other.extents().

Remarks: The expression inside explicit is equivalent to: !is_convertible_v<typename LayoutRightPaddedMapping::extents_type, extents_type>

[Note 1:

Neither the input mapping nor the mapping to be constructed uses the padding stride in the rank-0 or rank-1 case, so the padding stride does not affect either the constraints or the preconditions.

— end note]

23.7.3.4.8.4 Observers [mdspan.layout.leftpad.obs]

🔗

constexpr array<index_type, rank_> strides() const noexcept;

Returns: array<index_type, rank_>({stride(P_rank)...}).

🔗

constexpr index_type required_span_size() const noexcept;

Returns:

(2.1)
0 if the multidimensional index space extents_ is empty,
(2.2)
otherwise, *this(((extents_(P_rank) - index_type(1))...)) + 1.

🔗

template<class... Indices>
constexpr size_t operator()(Indices... idxs) const noexcept;

Constraints:

(3.1)
sizeof...(Indices) == rank_ is true.
(3.2)
(is_convertible_v<Indices, index_type> && ...) is true.
(3.3)
(is_nothrow_constructible_v<index_type, Indices> && ...) is true.

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

Returns: ((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0).

🔗

static constexpr bool is_always_exhaustive() noexcept;

Returns:

(6.1)
If rank_ equals zero or one, then true;
(6.2)
otherwise, if neither static-padding-stride nor first-static-extent equal dynamic_extent, then static-padding-stride == first-static-extent;
(6.3)
otherwise, false.

🔗

constexpr bool is_exhaustive() const noexcept;

Returns: true if rank_ equals zero or one; otherwise, extents_.extent(0) == stride(1).

🔗

constexpr index_type stride(rank_type r) const noexcept;

Preconditions: r is smaller than rank_.

Returns:

(9.1)
If r equals zero: 1;
(9.2)
otherwise, if r equals one: stride-1;
(9.3)
otherwise, the product of stride-1 and all values extents_.extent(k) with k in the range [1, r).

🔗

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

Constraints:

(10.1)
is-layout-left-padded-mapping-of<LayoutLeftPaddedMapping> is true.
(10.2)
LayoutLeftPaddedMapping::extents_type::rank() == rank_ is true.

Returns: true if x.extents() == y.extents() is true and rank_ < 2 || x.stride(1) == y.
stride(1) is true.

Otherwise, false.

23.7.3.4.9 Class template layout_right_padded::mapping [mdspan.layout.rightpad]

23.7.3.4.9.1 Overview [mdspan.layout.rightpad.overview]

layout_right_padded provides a layout mapping that behaves like layout_right::mapping, except that the padding stride stride(extents_type::rank() - 2) can be greater than or equal to extents_type::extent(extents_type::rank() - 1).

namespace std { template<size_t PaddingValue> template<class Extents> class layout_right_padded<PaddingValue>::mapping { public: static constexpr size_t padding_value = PaddingValue; 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_right_padded<PaddingValue>; private: static constexpr size_t rank_ = extents_type::rank(); // exposition only static constexpr size_t last-static-extent = // exposition only extents_type::static_extent(rank_ - 1); // [mdspan.layout.rightpad.expo], exposition-only members static constexpr size_t static-padding-stride = see below; // exposition only public: // [mdspan.layout.rightpad.cons], constructors constexpr mapping() noexcept : mapping(extents_type{}) {} constexpr mapping(const mapping&) noexcept = default; constexpr mapping(const extents_type&); template<class OtherIndexType> constexpr mapping(const extents_type&, OtherIndexType); template<class OtherExtents> constexpr explicit(!is_convertible_v<OtherExtents, extents_type>) mapping(const layout_right::mapping<OtherExtents>&); template<class OtherExtents> constexpr explicit(rank_ > 0) mapping(const layout_stride::mapping<OtherExtents>&); template<class LayoutRightPaddedMapping> constexpr explicit(see below) mapping(const LayoutRightPaddedMapping&); template<class LayoutLeftPaddedMapping> constexpr explicit(see below) mapping(const LayoutLeftPaddedMapping&) noexcept; constexpr mapping& operator=(const mapping&) noexcept = default; // [mdspan.layout.rightpad.obs], observers constexpr const extents_type& extents() const noexcept { return extents_; } constexpr array<index_type, rank_> strides() const noexcept; 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) const noexcept; template<class LayoutRightPaddedMapping> friend constexpr bool operator==(const mapping&, const LayoutRightPaddedMapping&) noexcept; private: // [mdspan.layout.rightpad.expo], exposition-only members index_type stride-rm2 = static-padding-stride; // exposition only extents_type extents_{}; // 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_right_padded::mapping<E> is a trivially copyable type that models regular for each E.

Throughout [mdspan.layout.rightpad], let P_rank be the following size rank_ parameter pack of size_t values:

(4.1)
the empty parameter pack, if rank_ equals zero;
(4.2)
otherwise, 0zu, if rank_ equals one;
(4.3)
otherwise, the parameter pack 0zu, 1zu, …, rank_- 1.

Mandates:

(5.1)
If rank_dynamic() == 0 is true, then the size of the multidimensional index space Extents() is representable as a value of type index_type.
(5.2)
padding_value is representable as a value of type index_type.
(5.3)
If
- (5.3.1)
  rank_ is greater than one,
- (5.3.2)
  padding_value does not equal dynamic_extent, and
- (5.3.3)
  last-static-extent does not equal dynamic_extent,
then LEAST-MULTIPLE-AT-LEAST(padding_value, last-static-extent) is representable as a value of type size_t, and is representable as a value of type index_type.
(5.4)
If
- (5.4.1)
  rank_ is greater than one,
- (5.4.2)
  padding_value does not equal dynamic_extent, and
- (5.4.3)
  extents_type::static_extent(k) does not equal dynamic_extent for all k in the range [0, rank_),
then the product of LEAST-MULTIPLE-AT-LEAST(padding_value, ext.static_extent(rank_ - 1)) and all values ext.static_extent(k) with k in the range of [0, rank_ - 1) is representable as a value of type size_t, and is representable as a value of type index_type.

23.7.3.4.9.2 Exposition-only members [mdspan.layout.rightpad.expo]

🔗

static constexpr size_t static-padding-stride = see below;

The value is

(1.1)
0, if rank_ equals zero or one;
(1.2)
otherwise, dynamic_extent, if padding_value or last-static-extent equals dynamic_extent;
(1.3)
otherwise, the size_t value which is LEAST-MULTIPLE-AT-LEAST(padding_value, last-static-extent).

🔗

index_type stride-rm2 = static-padding-stride;

Recommended practice: Implementations should not store this value if static-padding-stride is not dynamic_extent.

[Note 1:

Using extents<index_type, static-padding-stride> instead of index_type as the type of stride-rm2 would achieve this.

— end note]

23.7.3.4.9.3 Constructors [mdspan.layout.rightpad.cons]

🔗

constexpr mapping(const extents_type& ext);

Preconditions:

(1.1)
The size of the multidimensional index space ext is representable as a value of type index_type.
(1.2)
If rank_ is greater than one and padding_value does not equal dynamic_extent, then LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(rank_ - 1)) is representable as a value of type index_type.
(1.3)
If rank_ is greater than one and padding_value does not equal dynamic_extent, then the product of LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(rank_ - 1)) and all values ext.extent(k) with k in the range of [0, rank_ - 1) is representable as a value of type index_type.

Effects:

(2.1)
Direct-non-list-initializes extents_ with ext; and
(2.2)
if rank_ is greater than one, direct-non-list-initializes stride-rm2
- (2.2.1)
  with ext.extent(rank_ - 1) if padding_value is dynamic_extent,
- (2.2.2)
  otherwise with LEAST-MULTIPLE-AT-LEAST(padding_value, ext.extent(rank_ - 1)).

🔗

template<class OtherIndexType>
constexpr mapping(const extents_type& ext, OtherIndexType pad);

Constraints:

(3.1)
is_convertible_v<OtherIndexType, index_type> is true.
(3.2)
is_nothrow_constructible_v<index_type, OtherIndexType> is true.

Preconditions:

(4.1)
pad is representable as a value of type index_type.
(4.2)
extents_type::index-cast(pad) is greater than zero.
(4.3)
If rank_ is greater than one, then LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(rank_ - 1)) is representable as a value of type index_type.
(4.4)
If rank_ is greater than one, then the product of LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(rank_ - 1)) and all values ext.extent(k) with k in the range of [0, rank_ - 1) is representable as a value of type index_type.
(4.5)
If padding_value is not equal to dynamic_extent, padding_value equals extents_type::index-cast(pad).

Effects: Direct-non-list-initializes extents_ with ext, and if rank_ is greater than one, direct-non-list-initializes stride-rm2 with LEAST-MULTIPLE-AT-LEAST(pad, ext.extent(rank_ - 1)).

🔗

template<class OtherExtents>
  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
    mapping(const layout_right::mapping<OtherExtents>& other);

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Mandates: If OtherExtents::rank() is greater than 1, then (static-padding-stride == dynamic_extent) || (OtherExtents::static_extent(rank_ - 1) == dynamic_extent) || (static-padding-stride == OtherExtents::static_extent(rank_ - 1)) is true.

Preconditions:

(8.1)
If rank_ > 1 is true and padding_value == dynamic_extent is false, then other.stride(
rank_ - 2) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extents().extent(rank_ - 1))) and
(8.2)
other.required_span_size() is representable as a value of type index_type.

Effects: Equivalent to mapping(other.extents()).

🔗

template<class OtherExtents>
  constexpr explicit(rank_ > 0)
    mapping(const layout_stride::mapping<OtherExtents>& other);

Constraints: is_constructible_v<extents_type, OtherExtents> is true.

Preconditions:

(11.1)
If rank_ is greater than 1 and padding_value does not equal dynamic_extent, then other.stride(rank_ - 2) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extents().extent(rank_ - 1)))
(11.2)
If rank_ is greater than 0, then other.stride(rank_ - 1) equals 1.
(11.3)
If rank_ is greater than 2, then for all r in the range [0, rank_ - 2), other.stride(r) equals (other.extents().rev-prod-of-extents(r) / other.extents().extent(rank_ - 1)) * other.stride(rank_ - 2)
(11.4)
other.required_span_size() is representable as a value of type index_type.

Effects:

(12.1)
Direct-non-list-initializes extents_ with other.extents(); and
(12.2)
if rank_ is greater than one, direct-non-list-initializes stride-rm2 with other.stride(rank_ - 2).

🔗

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

Constraints:

(13.1)
is-layout-right-padded-mapping-of<LayoutRightPaddedMapping> is true.
(13.2)
is_constructible_v<extents_type, typename LayoutRightPaddedMapping::extents_-
type> is true.

Mandates: If rank_ is greater than 1, then padding_value == dynamic_extent || LayoutRightPaddedMapping::padding_value == dynamic_extent || padding_value == LayoutRightPaddedMapping::padding_value is true.

Preconditions:

(15.1)
If rank_ is greater than 1 and padding_value does not equal dynamic_extent, then other.stride(rank_ - 2) equals LEAST-MULTIPLE-AT-LEAST(padding_value, extents_type::index-cast(other.extent(rank_ - 1)))
(15.2)
other.required_span_size() is representable as a value of type index_type.

Effects:

(16.1)
Direct-non-list-initializes extents_ with other.extents(); and
(16.2)
if rank_ is greater than one, direct-non-list-initializes stride-rm2 with other.stride(rank_ - 2).

Remarks: The expression inside explicit is equivalent to: rank_ > 1 && (padding_value != dynamic_extent || LayoutRightPaddedMapping::padding_value == dynamic_extent)

🔗

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

Constraints:

(18.1)
is-layout-left-padded-mapping-of<LayoutLeftPaddedMapping> is true or
is-mapping-of<layout_left, LayoutLeftPaddedMapping> is true.
(18.2)
rank_ equals zero or one.
(18.3)
is_constructible_v<extents_type, typename LayoutLeftPaddedMapping::extents_type>
is true.

Preconditions: other.required_span_size() is representable as a value of type index_type.

Effects: Direct-non-list-initializes extents_ with other.extents().

Remarks: The expression inside explicit is equivalent to: !is_convertible_v<typename LayoutLeftPaddedMapping::extents_type, extents_type>

[Note 1:

Neither the input mapping nor the mapping to be constructed uses the padding stride in the rank-0 or rank-1 case, so the padding stride affects neither the constraints nor the preconditions.

— end note]

23.7.3.4.9.4 Observers [mdspan.layout.rightpad.obs]

🔗

constexpr array<index_type, rank_> strides() const noexcept;

Returns: array<index_type, rank_>(stride(P_rank)...).

🔗

constexpr index_type required_span_size() const noexcept;

Returns: 0 if the multidimensional index space extents_ is empty, otherwise *this(((extents_(P_rank) - index_type(1))...)) + 1.

🔗

template<class... Indices>
constexpr size_t operator()(Indices... idxs) const noexcept;

Constraints:

(3.1)
sizeof...(Indices) == rank_ is true.
(3.2)
(is_convertible_v<Indices, index_type> && ...) is true.
(3.3)
(is_nothrow_constructible_v<index_type, Indices> && ...) is true.

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

Returns: ((static_cast<index_type>(idxs) * stride(P_rank)) + ... + 0).

🔗

static constexpr bool is_always_exhaustive() noexcept;

Returns:

(6.1)
If rank_ equals zero or one, then true;
(6.2)
otherwise, if neither static-padding-stride nor last-static-extent equal dynamic_extent, then static-padding-stride == last-static-extent;
(6.3)
otherwise, false.

🔗

constexpr bool is_exhaustive() const noexcept;

Returns: true if rank_ equals zero or one; otherwise, extents_.extent(rank_ - 1) == stride(rank_ - 2)

🔗

constexpr index_type stride(rank_type r) const noexcept;

Preconditions: r is smaller than rank_.

Returns:

(9.1)
If r equals rank_ - 1: 1;
(9.2)
otherwise, if r equals rank_ - 2: stride-rm2;
(9.3)
otherwise, the product of stride-rm2 and all values extents_.extent(k) with k in the range of [r + 1, rank_ - 1).

🔗

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

Constraints:

(10.1)
is-layout-right-padded-mapping-of<LayoutRightPaddedMapping> is true.
(10.2)
LayoutRightPaddedMapping::extents_type::rank() == rank_ is true.

Returns: true if x.extents() == y.extents() is true and rank_ < 2 || x.stride(rank_ - 2) == y.stride(rank_ - 2) is true.

Otherwise, false.

23.7.3.5 Accessor policy [mdspan.accessor]

23.7.3.5.1 General [mdspan.accessor.general]

An accessor policy defines types and operations by which a reference to a single object is created from an abstract data handle to a number of such objects and an index.

A range of indices

[0, N)

is an accessible range of a given data handle and an accessor if, for each i in the range, the accessor policy's access function produces a valid reference to an object.

In [mdspan.accessor.reqmts],

(3.1)
A denotes an accessor policy.
(3.2)
a denotes a value of type A or const A.
(3.3)
p denotes a value of type A::data_handle_type or const A::data_handle_type.

[Note 1:
The type A::data_handle_type need not be dereferenceable.
— end note]
(3.4)
n, i, and j each denote values of type size_t.

23.7.3.5.2 Requirements [mdspan.accessor.reqmts]

A type A meets the accessor policy requirements if

(1.1)
A models copyable,
(1.2)
is_nothrow_move_constructible_v<A> is true,
(1.3)
is_nothrow_move_assignable_v<A> is true,
(1.4)
is_nothrow_swappable_v<A> is true, and
(1.5)
the following types and expressions are well-formed and have the specified semantics.

🔗

typename A::element_type

Result: A complete object type that is not an abstract class type.

🔗

typename A::data_handle_type

Result: A type that models copyable, and for which is_nothrow_move_constructible_v<A::data_handle_type> is true, is_nothrow_move_assignable_v<A::data_handle_type> is true, and is_nothrow_swappable_v<A::data_handle_type> is true.

[Note 1:

The type of data_handle_type need not be element_type*.

— end note]

🔗

typename A::reference

Result: A type that models common_reference_with<A::reference&&, A::element_type&>.

[Note 2:

The type of reference need not be element_type&.

— end note]

🔗

typename A::offset_policy

Result: A type OP such that:

(5.1)
OP meets the accessor policy requirements,
(5.2)
constructible_from<OP, const A&> is modeled, and
(5.3)
is_same_v<typename OP::element_type, typename A::element_type> is true.

🔗

a.access(p, i)

Result: A::reference

Remarks: The expression is equality preserving.

[Note 3:

Concrete accessor policies can impose preconditions for their access function.

However, they might not.

For example, an accessor where p is span<A::element_type, dynamic_extent> and access(p, i) returns p[i % p.size()] does not need to impose a precondition on i.

— end note]

🔗

a.offset(p, i)

Result: A::offset_policy::data_handle_type

Returns: q such that for b being A::offset_policy(a), and any integer n for which [0, n) is an accessible range of p and a:

(10.1)
$[0, n - i)$ is an accessible range of q and b; and
(10.2)
b.access(q, j) provides access to the same element as a.access(p, i + j), for every j in the range $[0, n - i)$ .

Remarks: The expression is equality-preserving.

23.7.3.5.3 Class template default_accessor [mdspan.accessor.default]

23.7.3.5.3.1 Overview [mdspan.accessor.default.overview]

namespace std { 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> constexpr default_accessor(default_accessor<OtherElementType>) noexcept; constexpr reference access(data_handle_type p, size_t i) const noexcept; constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept; }; }

default_accessor meets the accessor policy requirements.

ElementType is required to be a complete object type that is neither an abstract class type nor an array type.

Each specialization of default_accessor is a trivially copyable type that models semiregular .

[0, n)

is an accessible range for an object p of type data_handle_type and an object of type default_accessor if and only if [p, p + n) is a valid range.

23.7.3.5.3.2 Members [mdspan.accessor.default.members]

🔗

template<class OtherElementType>
  constexpr default_accessor(default_accessor<OtherElementType>) noexcept {}

Constraints: is_convertible_v<OtherElementType(*)[], element_type(*)[]> is true.

🔗

constexpr reference access(data_handle_type p, size_t i) const noexcept;

Effects: Equivalent to: return p[i];

🔗

constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;

Effects: Equivalent to: return p + i;

23.7.3.6 Class template mdspan [mdspan.mdspan]

23.7.3.6.1 Overview [mdspan.mdspan.overview]

mdspan is a view of a multidimensional array of elements.

namespace std { template<class ElementType, class Extents, class LayoutPolicy = layout_right, class AccessorPolicy = default_accessor<ElementType>> 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 = ElementType; using value_type = remove_cv_t<element_type>; 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 data_handle_type = typename accessor_type::data_handle_type; using reference = typename accessor_type::reference; static constexpr rank_type rank() noexcept { return extents_type::rank(); } static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); } static constexpr size_t static_extent(rank_type r) noexcept { return extents_type::static_extent(r); } constexpr index_type extent(rank_type r) const noexcept { return extents().extent(r); } // [mdspan.mdspan.cons], constructors constexpr mdspan(); constexpr mdspan(const mdspan& rhs) = default; constexpr mdspan(mdspan&& rhs) = default; template<class... OtherIndexTypes> constexpr explicit mdspan(data_handle_type ptr, OtherIndexTypes... exts); template<class OtherIndexType, size_t N> constexpr explicit(N != rank_dynamic()) mdspan(data_handle_type p, span<OtherIndexType, N> exts); template<class OtherIndexType, size_t N> constexpr explicit(N != rank_dynamic()) mdspan(data_handle_type p, const array<OtherIndexType, N>& exts); constexpr mdspan(data_handle_type p, const extents_type& ext); constexpr mdspan(data_handle_type p, const mapping_type& m); constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a); template<class OtherElementType, class OtherExtents, class OtherLayoutPolicy, class OtherAccessorPolicy> constexpr explicit(see below) mdspan(const mdspan<OtherElementType, OtherExtents, OtherLayoutPolicy, OtherAccessorPolicy>& other); constexpr mdspan& operator=(const mdspan& rhs) = default; constexpr mdspan& operator=(mdspan&& rhs) = default; // [mdspan.mdspan.members], members template<class... OtherIndexTypes> constexpr reference operator[](OtherIndexTypes... indices) const; template<class OtherIndexType> constexpr reference operator[](span<OtherIndexType, rank()> indices) const; template<class OtherIndexType> constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const; constexpr size_type size() const noexcept; constexpr bool empty() const noexcept; friend constexpr void swap(mdspan& x, mdspan& y) noexcept; constexpr const extents_type& extents() const noexcept { return map_.extents(); } constexpr const data_handle_type& data_handle() const noexcept { return ptr_; } constexpr const mapping_type& mapping() const noexcept { return map_; } constexpr const accessor_type& accessor() const noexcept { return acc_; } static constexpr bool is_always_unique() { return mapping_type::is_always_unique(); } static constexpr bool is_always_exhaustive() { return mapping_type::is_always_exhaustive(); } static constexpr bool is_always_strided() { return mapping_type::is_always_strided(); } constexpr bool is_unique() const { return map_.is_unique(); } constexpr bool is_exhaustive() const { return map_.is_exhaustive(); } constexpr bool is_strided() const { return map_.is_strided(); } constexpr index_type stride(rank_type r) const { return map_.stride(r); } private: accessor_type acc_; // exposition only mapping_type map_; // exposition only data_handle_type ptr_; // exposition only }; template<class CArray> requires (is_array_v<CArray> && rank_v<CArray> == 1) mdspan(CArray&) -> mdspan<remove_all_extents_t<CArray>, extents<size_t, extent_v<CArray, 0>>>; template<class Pointer> requires (is_pointer_v<remove_reference_t<Pointer>>) mdspan(Pointer&&) -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>; template<class ElementType, class... Integrals> requires ((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0) explicit mdspan(ElementType*, Integrals...) -> mdspan<ElementType, extents<size_t, maybe-static-ext<Integrals>...>>; template<class ElementType, class OtherIndexType, size_t N> mdspan(ElementType*, span<OtherIndexType, N>) -> mdspan<ElementType, dextents<size_t, N>>; template<class ElementType, class OtherIndexType, size_t N> mdspan(ElementType*, const array<OtherIndexType, N>&) -> mdspan<ElementType, dextents<size_t, N>>; template<class ElementType, class IndexType, size_t... ExtentsPack> mdspan(ElementType*, const extents<IndexType, ExtentsPack...>&) -> mdspan<ElementType, extents<IndexType, ExtentsPack...>>; template<class ElementType, class MappingType> mdspan(ElementType*, const MappingType&) -> mdspan<ElementType, typename MappingType::extents_type, typename MappingType::layout_type>; template<class MappingType, class AccessorType> mdspan(const typename AccessorType::data_handle_type&, const MappingType&, const AccessorType&) -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type, typename MappingType::layout_type, AccessorType>; }

Mandates:

(2.1)
ElementType is a complete object type that is neither an abstract class type nor an array type,
(2.2)
Extents is a specialization of extents, and
(2.3)
is_same_v<ElementType, typename AccessorPolicy::element_type> is true.

LayoutPolicy shall meet the layout mapping policy requirements ([mdspan.layout.policy.reqmts]), and AccessorPolicy shall meet the accessor policy requirements ([mdspan.accessor.reqmts]).

Each specialization MDS of mdspan models copyable and

(4.1)
is_nothrow_move_constructible_v<MDS> is true,
(4.2)
is_nothrow_move_assignable_v<MDS> is true, and
(4.3)
is_nothrow_swappable_v<MDS> is true.

A specialization of mdspan is a trivially copyable type if its accessor_type, mapping_type, and data_handle_type are trivially copyable types.

23.7.3.6.2 Constructors [mdspan.mdspan.cons]

🔗

constexpr mdspan();

Constraints:

(1.1)
rank_dynamic() > 0 is true.
(1.2)
is_default_constructible_v<data_handle_type> is true.
(1.3)
is_default_constructible_v<mapping_type> is true.
(1.4)
is_default_constructible_v<accessor_type> is true.

Preconditions: [0, map_.required_span_size()) is an accessible range of ptr_ and acc_ for the values of map_ and acc_ after the invocation of this constructor.

Effects: Value-initializes ptr_, map_, and acc_.

🔗

template<class... OtherIndexTypes>
  constexpr explicit mdspan(data_handle_type p, OtherIndexTypes... exts);

Let N be sizeof...(OtherIndexTypes).

Constraints:

(5.1)
(is_convertible_v<OtherIndexTypes, index_type> && ...) is true,
(5.2)
(is_nothrow_constructible<index_type, OtherIndexTypes> && ...) is true,
(5.3)
N == rank() || N == rank_dynamic() is true,
(5.4)
is_constructible_v<mapping_type, extents_type> is true, and
(5.5)
is_default_constructible_v<accessor_type> is true.

Preconditions: [0, map_.required_span_size()) is an accessible range of p and acc_ for the values of map_ and acc_ after the invocation of this constructor.

Effects:

(7.1)
Direct-non-list-initializes ptr_ with std::move(p),
(7.2)
direct-non-list-initializes map_ with extents_type(static_cast<index_type>(std::move(exts))...), and
(7.3)
value-initializes acc_.

🔗

template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic())
    mdspan(data_handle_type p, span<OtherIndexType, N> exts);
template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic())
    mdspan(data_handle_type p, const array<OtherIndexType, N>& exts);

Constraints:

(8.1)
is_convertible_v<const OtherIndexType&, index_type> is true,
(8.2)
is_nothrow_constructible_v<index_type, const OtherIndexType&> is true,
(8.3)
N == rank() || N == rank_dynamic() is true,
(8.4)
is_constructible_v<mapping_type, extents_type> is true, and
(8.5)
is_default_constructible_v<accessor_type> is true.

Preconditions: [0, map_.required_span_size()) is an accessible range of p and acc_ for the values of map_ and acc_ after the invocation of this constructor.

Effects:

(10.1)
Direct-non-list-initializes ptr_ with std::move(p),
(10.2)
direct-non-list-initializes map_ with extents_type(exts), and
(10.3)
value-initializes acc_.

🔗

constexpr mdspan(data_handle_type p, const extents_type& ext);

Constraints:

(11.1)
is_constructible_v<mapping_type, const extents_type&> is true, and
(11.2)
is_default_constructible_v<accessor_type> is true.

Preconditions: [0, map_.required_span_size()) is an accessible range of p and acc_ for the values of map_ and acc_ after the invocation of this constructor.

Effects:

(13.1)
Direct-non-list-initializes ptr_ with std::move(p),
(13.2)
direct-non-list-initializes map_ with ext, and
(13.3)
value-initializes acc_.

🔗

constexpr mdspan(data_handle_type p, const mapping_type& m);

Constraints: is_default_constructible_v<accessor_type> is true.

Preconditions: [0, m.required_span_size()) is an accessible range of p and acc_ for the value of acc_ after the invocation of this constructor.

Effects:

(16.1)
Direct-non-list-initializes ptr_ with std::move(p),
(16.2)
direct-non-list-initializes map_ with m, and
(16.3)
value-initializes acc_.

🔗

constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);

Preconditions: [0, m.required_span_size()) is an accessible range of p and a.

Effects:

(18.1)
Direct-non-list-initializes ptr_ with std::move(p),
(18.2)
direct-non-list-initializes map_ with m, and
(18.3)
direct-non-list-initializes acc_ with a.

🔗

template<class OtherElementType, class OtherExtents,
         class OtherLayoutPolicy, class OtherAccessor>
  constexpr explicit(see below)
    mdspan(const mdspan<OtherElementType, OtherExtents,
                        OtherLayoutPolicy, OtherAccessor>& other);

Constraints:

(19.1)
is_constructible_v<mapping_type, const OtherLayoutPolicy::template mapping<Oth-
erExtents>&> is true, and
(19.2)
is_constructible_v<accessor_type, const OtherAccessor&> is true.

Mandates:

(20.1)
is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&> is
true, and
(20.2)
is_constructible_v<extents_type, OtherExtents> is true.

Preconditions:

(21.1)
For each rank index r of extents_type, static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r) is true.
(21.2)
[0, map_.required_span_size()) is an accessible range of ptr_ and acc_ for values of ptr_, map_, and acc_ after the invocation of this constructor.

Effects:

(22.1)
Direct-non-list-initializes ptr_ with other.ptr_,
(22.2)
direct-non-list-initializes map_ with other.map_, and
(22.3)
direct-non-list-initializes acc_ with other.acc_.

Remarks: The expression inside explicit is equivalent to: !is_convertible_v<const OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type> || !is_convertible_v<const OtherAccessor&, accessor_type>

23.7.3.6.3 Members [mdspan.mdspan.members]

🔗

template<class... OtherIndexTypes>
  constexpr reference operator[](OtherIndexTypes... indices) const;

Constraints:

(1.1)
(is_convertible_v<OtherIndexTypes, index_type> && ...) is true,
(1.2)
(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...) is true, and
(1.3)
sizeof...(OtherIndexTypes) == rank() is true.

Let I be extents_type::index-cast(std::move(indices)).

Preconditions: I is a multidimensional index in extents().

[Note 1:

This implies that map_(I) < map_.required_span_size() is true.

— end note]

Effects: Equivalent to: return acc_.access(ptr_, map_(static_cast<index_type>(std::move(indices))...));

🔗

template<class OtherIndexType>
  constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
template<class OtherIndexType>
  constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;

Constraints:

(5.1)
is_convertible_v<const OtherIndexType&, index_type> is true, and
(5.2)
is_nothrow_constructible_v<index_type, const OtherIndexType&> is true.

Effects: Let P be a parameter pack such that is_same_v<make_index_sequence<rank()>, index_sequence<P...>> is true.

Equivalent to: return operator[](extents_type::index-cast(as_const(indices[P]))...);

🔗

constexpr size_type size() const noexcept;

Preconditions: The size of the multidimensional index space extents() is representable as a value of type size_type ([basic.fundamental]).

Returns: extents().fwd-prod-of-extents(rank()).

🔗

constexpr bool empty() const noexcept;

Returns: true if the size of the multidimensional index space extents() is 0, otherwise false.

🔗

friend constexpr void swap(mdspan& x, mdspan& y) noexcept;

Effects: Equivalent to: swap(x.ptr_, y.ptr_); swap(x.map_, y.map_); swap(x.acc_, y.acc_);

23.7.3.7 submdspan [mdspan.sub]

23.7.3.7.1 Overview [mdspan.sub.overview]

The submdspan facilities create a new mdspan viewing a subset of elements of an existing input mdspan.

The subset viewed by the created mdspan is determined by the SliceSpecifier arguments.

For each function defined in [mdspan.sub] that takes a parameter pack named slices as an argument:

(2.1)
let index_type be
- (2.1.1)
  M::index_type if the function is a member of a class M,
- (2.1.2)
  otherwise, remove_reference_t<decltype(src)>::index_type if the function has a parameter named src,
- (2.1.3)
  otherwise, the same type as the function's template argument IndexType;
(2.2)
let rank be the number of elements in slices;
(2.3)
let $s_{k}$ be the $k^{th}$ element of slices;
(2.4)
let $S_{k}$ be the type of $s_{k}$ ; and
(2.5)
let map-rank be an array<size_t, rank> such that for each k in the range [0, rank), map-rank[k] equals:
- (2.5.1)
  dynamic_extent if $S_{k}$ models convertible_to<index_type>,
- (2.5.2)
  otherwise, the number of types $S_{j}$ with $j < k$ that do not model convertible_to<index_type>.

23.7.3.7.2 strided_slice [mdspan.sub.strided.slice]

strided_slice represents a set of extent regularly spaced integer indices.

The indices start at offset, and increase by increments of stride.

🔗

namespace std { template<class OffsetType, class ExtentType, class StrideType> struct strided_slice { using offset_type = OffsetType; using extent_type = ExtentType; using stride_type = StrideType; [[no_unique_address]] offset_type offset{}; [[no_unique_address]] extent_type extent{}; [[no_unique_address]] stride_type stride{}; }; }

strided_slice has the data members and special members specified above.

It has no base classes or members other than those specified.

Mandates: OffsetType, ExtentType, and StrideType are signed or unsigned integer types, or model integral-constant-like.

[Note 1:

strided_slice{.offset = 1, .extent = 10, .stride = 3} indicates the indices 1, 4, 7, and 10.

Indices are selected from the half-open interval [1, 1 + 10).

— end note]

23.7.3.7.3 submdspan_mapping_result [mdspan.sub.map.result]

Specializations of submdspan_mapping_result are returned by overloads of submdspan_mapping.

🔗

namespace std { template<class LayoutMapping> struct submdspan_mapping_result { [[no_unique_address]] LayoutMapping mapping = LayoutMapping(); size_t offset{}; }; }

submdspan_mapping_result has the data members and special members specified above.

It has no base classes or members other than those specified.

LayoutMapping shall meet the layout mapping requirements ([mdspan.layout.policy.reqmts]).

23.7.3.7.4 Exposition-only helpers [mdspan.sub.helpers]

🔗

template<class T>
  constexpr T de-ice(T val) { return val; }
template<integral-constant-like T>
  constexpr auto de-ice(T) { return T::value; }

template<class IndexType, size_t k, class... SliceSpecifiers>
  constexpr IndexType first_(SliceSpecifiers... slices);

Mandates: IndexType is a signed or unsigned integer type.

Let

ϕ_{k}

denote the following value:

(2.1)
$s_{k}$ if $S_{k}$ models convertible_to<IndexType>;
(2.2)
otherwise, get<0>( $s_{k}$ ) if $S_{k}$ models index-pair-like<IndexType>;
(2.3)
otherwise, de-ice( $s_{k}$ .offset) if $S_{k}$ is a specialization of strided_slice;
(2.4)
otherwise, 0.

Preconditions:

ϕ_{k}

is representable as a value of type IndexType.

Returns: extents<IndexType>::index-cast(

ϕ_{k}

🔗

template<size_t k, class Extents, class... SliceSpecifiers>
  constexpr auto last_(const Extents& src, SliceSpecifiers... slices);

Mandates: Extents is a specialization of extents.

Let index_type be typename Extents::index_type.

Let

λ_{k}

denote the following value:

(7.1)
de-ice( $s_{k}$ ) + 1 if $S_{k}$ models convertible_to<index_type>; otherwise
(7.2)
get<1>( $s_{k}$ ) if $S_{k}$ models index-pair-like<index_type>; otherwise
(7.3)
de-ice( $s_{k}$ .offset) + de-ice( $s_{k}$ .extent) if $S_{k}$ is a specialization of strided_slice; otherwise
(7.4)
src.extent(k).

Preconditions:

λ_{k}

is representable as a value of type index_type.

Returns: Extents::index-cast(

λ_{k}

🔗

template<class IndexType, size_t N, class... SliceSpecifiers>
  constexpr array<IndexType, sizeof...(SliceSpecifiers)>
    src-indices(const array<IndexType, N>& indices, SliceSpecifiers... slices);

Mandates: IndexType is a signed or unsigned integer type.

Returns: An array<IndexType, sizeof...(SliceSpecifiers)> src_idx such that for each k in the range [0, sizeof...(SliceSpecifiers)), src_idx[k] equals

(11.1)
first_<IndexType, k>(slices...) for each k where map-rank[k] equals dynamic_extent,
(11.2)
otherwise, first_<IndexType, k>(slices...) + indices[map-rank[k]].

23.7.3.7.5 submdspan_extents function [mdspan.sub.extents]

🔗

template<class IndexType, class... Extents, class... SliceSpecifiers>
  constexpr auto submdspan_extents(const extents<IndexType, Extents...>& src,
                                   SliceSpecifiers... slices);

Constraints: sizeof...(slices) equals Extents::rank().

Mandates: For each rank index k of src.extents(), exactly one of the following is true:

(2.1)
$S_{k}$ models convertible_to<IndexType>,
(2.2)
$S_{k}$ models index-pair-like<IndexType>,
(2.3)
is_convertible_v< $S_{k}$ , full_extent_t> is true, or
(2.4)
$S_{k}$ is a specialization of strided_slice.

Preconditions: For each rank index k of src.extents(), all of the following are true:

(3.1)
if $S_{k}$ is a specialization of strided_slice
- (3.1.1)
  $s_{k} .extent = 0$ , or
- (3.1.2)
  $s_{k} .stride > 0$
(3.2)
0 ≤ first_<IndexType, k>(slices...) ≤ last_<k>(src, slices...) ≤ src.extent(k)

Let SubExtents be a specialization of extents such that:

(4.1)
SubExtents::rank() equals the number of k such that $S_{k}$ does not model convertible_to<IndexType>; and
(4.2)
for each rank index k of Extents such that map-rank[k] != dynamic_extent is true, SubExtents::static_extent(map-rank[k]) equals:
- (4.2.1)
  Extents::static_extent(k) if is_convertible_v< $S_{k}$ , full_extent_t> is true; otherwise
- (4.2.2)
  de-ice(tuple_element_t<1, $S_{k}$ >()) - de-ice(tuple_element_t<0, $S_{k}$ >()) if $S_{k}$ models index-pair-like<IndexType>, and both tuple_element_t<0, $S_{k}$ > and tuple_element_t<1, $S_{k}$ > model integral-constant-like; otherwise
- (4.2.3)
  0, if $S_{k}$ is a specialization of strided_slice, whose extent_type models integral-constant-like, for which extent_type() equals zero; otherwise
- (4.2.4)
  1 + (de-ice( $S_{k}$ ::extent_type()) - 1) / de-ice( $S_{k}$ ::stride_type()), if $S_{k}$ is a specialization of strided_slice whose extent_type and stride_type model integral-constant-like;
- (4.2.5)
  otherwise, dynamic_extent.

Returns: A value ext of type SubExtents such that for each k for which map-rank[k] != dynamic_extent is true, ext.extent(map-rank[k]) equals:

(5.1)
$s_{k}$ .extent == 0 ? 0 : 1 + (de-ice( $s_{k}$ .extent) - 1) / de-ice( $s_{k}$ .stride) if $S_{k}$ is a specialization of strided_slice,
(5.2)
otherwise, last_<k>(src, slices...) - first_<IndexType, k>(slices...).

23.7.3.7.6 Specializations of submdspan_mapping [mdspan.sub.map]

23.7.3.7.6.1 Common [mdspan.sub.map.common]

The following elements apply to all functions in [mdspan.sub.map].

Constraints: sizeof...(slices) equals extents_type::rank().

Mandates: For each rank index k of extents(), exactly one of the following is true:

(3.1)
$S_{k}$ models convertible_to<index_type>,
(3.2)
$S_{k}$ models index-pair-like<index_type>,
(3.3)
is_convertible_v< $S_{k}$ , full_extent_t> is true, or
(3.4)
$S_{k}$ is a specialization of strided_slice.

Preconditions: For each rank index k of extents(), all of the following are true:

(4.1)
if $S_{k}$ is a specialization of strided_slice, $s_{k}$ .extent is equal to zero or $s_{k}$ .stride is greater than zero; and
(4.2)
0 ≤ first_<index_type, k>(slices...)
0 ≤ last_<k>(extents(), slices...)
0 ≤ extents().extent(k)

Let sub_ext be the result of submdspan_extents(extents(), slices...) and let SubExtents be decltype(sub_ext).

Let sub_strides be an array<SubExtents::index_type, SubExtents::rank()> such that for each rank index k of extents() for which map-rank[k] is not dynamic_extent, sub_strides[map-rank[k]] equals:

(6.1)
stride(k) * de-ice( $s_{k}$ .stride) if $S_{k}$ is a specialization of strided_slice and $s_{k}$ .stride < $s_{k}$ .extent is true;
(6.2)
otherwise, stride(k).

Let P be a parameter pack such that is_same_v<make_index_sequence<rank()>, index_sequence<P...>> is true.

If first_<index_type, k>(slices...) equals extents().extent(k) for any rank index k of extents(), then let offset be a value of type size_t equal to (*this).required_span_size().

Otherwise, let offset be a value of type size_t equal to (*this)(first_<index_type, P>(slices...)...).

23.7.3.7.6.2 layout_left specialization of submdspan_mapping [mdspan.sub.map.left]

🔗

template<class Extents>
template<class... SliceSpecifiers>
constexpr auto layout_left::mapping<Extents>::submdspan-mapping-impl(
      SliceSpecifiers... slices) const -> see below;

Returns:

(1.1)
submdspan_mapping_result{*this, 0}, if Extents::rank() == 0 is true;
(1.2)
otherwise, submdspan_mapping_result{layout_left::mapping(sub_ext), offset}, if SubExtents::rank() == 0 is true;
(1.3)
otherwise, submdspan_mapping_result{layout_left::mapping(sub_ext), offset}, if
- (1.3.1)
  for each k in the range [0, SubExtents::rank() - 1)), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.3.2)
  for k equal to SubExtents::rank() - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
[Note 1:
If the above conditions are true, all $S_{k}$ with k larger than SubExtents::rank() - 1 are convertible to index_type.
— end note]
(1.4)
otherwise, submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)), offset} if for a value u for which $u + 1$ is the smallest value p larger than zero for which $S_{p}$ models index-pair-like<index_type> or is_convertible_v< $S_{p}$ , full_extent_t> is true, the following conditions are met:
- (1.4.1)
  $S_{0}$ models index-pair-like<index_type> or is_convertible_v< $S_{0}$ , full_extent_t> is true; and
- (1.4.2)
  for each k in the range [u + 1, u + SubExtents::rank() - 1), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.3)
  for k equal to u + SubExtents::rank() - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
and where S_static is:
- (1.4.4)
  dynamic_extent, if static_extent(k) is dynamic_extent for any k in the range [0, u + 1),
- (1.4.5)
  otherwise, the product of all values static_extent(k) for k in the range [0, u + 1);
(1.5)
otherwise, submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}

23.7.3.7.6.3 layout_right specialization of submdspan_mapping [mdspan.sub.map.right]

🔗

template<class Extents>
template<class... SliceSpecifiers>
constexpr auto layout_right::mapping<Extents>::submdspan-mapping-impl(
      SliceSpecifiers... slices) const -> see below;

Returns:

(1.1)
submdspan_mapping_result{*this, 0}, if Extents::rank() == 0 is true;
(1.2)
otherwise, submdspan_mapping_result{layout_right::mapping(sub_ext), offset}, if SubExtents::rank() == 0 is true;
(1.3)
otherwise, submdspan_mapping_result{layout_left::mapping(sub_ext), offset}, if
- (1.3.1)
  for each k in the range [rank_ - SubExtents::rank() + 1, rank_), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.3.2)
  for k equal to _rank - SubExtents::rank(), $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
[Note 1:
If the above conditions are true, all $S_{k}$ with $k<\class{textit}{\texttt{_rank}} - SubExtents::rank()$ are convertible to index_type.
— end note]
(1.4)
otherwise, submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext, stride(rank_ - u - 2)), offset} if for a value u for which $rank_- u - 2$ is the largest value p smaller than rank_ - 1 for which $S_{p}$ models index-pair-like<index_type> or is_convertible_v< $S_{p}$ , full_extent_t> is true, the following conditions are met:
- (1.4.1)
  for k equal to rank_ - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.2)
  for each k in the range [rank_ - SubExtents::rank() - u + 1, rank_ - u - 1), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.3)
  for k equal to rank_ - SubExtents::rank() - u, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
and where S_static is:
- (1.4.4)
  dynamic_extent, if static_extent(k) is dynamic_extent for any k in the range [rank_ - u - 1, rank_),
- (1.4.5)
  otherwise, the product of all values static_extent(k) for k in the range [rank_ - u - 1, rank_);
(1.5)
otherwise, submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}

23.7.3.7.6.4 layout_stride specialization of submdspan_mapping [mdspan.sub.map.stride]

🔗

template<class Extents>
template<class... SliceSpecifiers>
constexpr auto layout_stride::mapping<Extents>::submdspan-mapping-impl(
      SliceSpecifiers... slices) const -> see below;

Returns:

(1.1)
submdspan_mapping_result{*this, 0}, if Extents::rank() == 0 is true;
(1.2)
otherwise, submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}

23.7.3.7.6.5 layout_left_padded specialization of submdspan_mapping [mdspan.sub.map.leftpad]

🔗

template<class Extents>
template<class... SliceSpecifiers>
constexpr auto layout_left_padded::mapping<Extents>::submdspan-mapping-impl(
    SliceSpecifiers... slices) const -> see below;

Returns:

(1.1)
submdspan_mapping_result{*this, 0}, if Extents::rank() == 0 is true;
(1.2)
otherwise, submdspan_mapping_result{layout_left::mapping(sub_ext), offset}, if rank_ == 1 is true or SubExtents::rank() == 0 is true;
(1.3)
otherwise, submdspan_mapping_result{layout_left::mapping(sub_ext), offset}, if
- (1.3.1)
  SubExtents::rank() == 1 is true and
- (1.3.2)
  $S_{0}$ models index-pair-like<index_type> or is_convertible_v< $S_{0}$ , full_extent_t> is true;
(1.4)
otherwise, submdspan_mapping_result{layout_left_padded<S_static>::mapping(sub_ext, stride(u + 1)), offset} if for a value u for which u + 1 is the smallest value p larger than zero for which $S_{p}$ models index-pair-like<index_type> or is_convertible_v< $S_{p}$ , full_extent_t> is true, the following conditions are met:
- (1.4.1)
  $S_{0}$ models index-pair-like<index_type> or is_convertible_v< $S_{0}$ , full_extent_t> is true; and
- (1.4.2)
  for each k in the range [u + 1, u + SubExtents::rank() - 1), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.3)
  for k equal to u + SubExtents::rank() - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v<Sk, full_extent_t> is true;
where S_static is:
- (1.4.4)
  dynamic_extent, if static-padding-stride is dynamic_extent or static_extent(k) is dynamic_extent for any k in the range [1, u + 1),
- (1.4.5)
  otherwise, the product of static-padding-stride and all values static_extent(k) for k in the range [1, u + 1);
(1.5)
otherwise, submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}

23.7.3.7.6.6 layout_right_padded specialization of submdspan_mapping [mdspan.sub.map.rightpad]

🔗

template<class Extents>
template<class... SliceSpecifiers>
constexpr auto layout_right_padded::mapping<Extents>::submdspan-mapping-impl(
    SliceSpecifiers... slices) const -> see below;

Returns:

(1.1)
submdspan_mapping_result{*this, 0}, if rank_ == 0 is true;
(1.2)
otherwise, submdspan_mapping_result{layout_right::mapping(sub_ext), offset},
if rank_ == 1 is true or SubExtents::rank() == 0 is true;
(1.3)
otherwise, submdspan_mapping_result{layout_right::mapping(sub_ext), offset}, if
- (1.3.1)
  SubExtents::rank() == 1 is true and
- (1.3.2)
  for k equal to rank_ - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
(1.4)
otherwise, submdspan_mapping_result{layout_right_padded<S_static>::mapping(sub_ext, stride(rank_ - u - 2)), offset} if for a value u for which rank_ - u - 2 is the largest value p smaller than rank_ - 1 for which $S_{p}$ models index-pair-like<index_type> or is_convertible_v< $S_{p}$ , full_extent_t> is true, the following conditions are met:
- (1.4.1)
  for k equal to rank_ - 1, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.2)
  for each k in the range [rank_ - SubExtents::rank() - u + 1, rank_ - u - 1)), is_convertible_v< $S_{k}$ , full_extent_t> is true; and
- (1.4.3)
  for k equal to rank_ - SubExtents::rank() - u, $S_{k}$ models index-pair-like<index_type> or is_convertible_v< $S_{k}$ , full_extent_t> is true;
and where S_static is:
- (1.4.4)
  dynamic_extent if static-padding-stride is dynamic_extent or for any k in the range [rank_ - u - 1, rank_ - 1) static_extent(k) is dynamic_extent,
- (1.4.5)
  otherwise, the product of static-padding-stride and all values static_extent(k) with k in the range [rank_ - u - 1, rank_ - 1);
(1.5)
otherwise, submdspan_mapping_result{layout_stride::mapping(sub_ext, sub_strides), offset}

23.7.3.7.7 submdspan function template [mdspan.sub.sub]

🔗

template<class ElementType, class Extents, class LayoutPolicy,
         class AccessorPolicy, class... SliceSpecifiers>
  constexpr auto submdspan(
    const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
    SliceSpecifiers... slices) -> see below;

Let index_type be typename Extents::index_type.

Let sub_map_offset be the result of submdspan_mapping(src.mapping(), slices...).

[Note 1:

This invocation of submdspan_mapping selects a function call via overload resolution on a candidate set that includes the lookup set found by argument-dependent lookup ([basic.lookup.argdep]).

— end note]

Constraints:

(3.1)
sizeof...(slices) equals Extents::rank(), and
(3.2)
the expression submdspan_mapping(src.mapping(), slices...) is well-formed when treated as an unevaluated operand.

Mandates:

(4.1)
decltype(submdspan_mapping(src.mapping(), slices...)) is a specialization of submdspan_mapping_result.
(4.2)
is_same_v<remove_cvref_t<decltype(sub_map_offset.mapping.extents())>, decltype(submdspan_extents(src.mapping(), slices...))> is true.
(4.3)
For each rank index k of src.extents(), exactly one of the following is true:
- (4.3.1)
  $S_{k}$ models convertible_to<index_type>,
- (4.3.2)
  $S_{k}$ models index-pair-like<index_type>,
- (4.3.3)
  is_convertible_v< $S_{k}$ , full_extent_t> is true, or
- (4.3.4)
  $S_{k}$ is a specialization of strided_slice.

Preconditions:

(5.1)
For each rank index k of src.extents(), all of the following are true:
- (5.1.1)
  if $S_{k}$ is a specialization of strided_slice
  - (5.1.1.1)
    $s_{k} .extent = 0$ , or
  - (5.1.1.2)
    $s_{k} .stride > 0$
- (5.1.2)
  0 ≤ first_<index_type, k>(slices...) ≤ last_<k>(src.extents(), slices...) ≤ src.extent(k)
(5.2)
sub_map_offset.mapping.extents() == submdspan_extents(src.mapping(), slices...) is true; and
(5.3)
for each integer pack I which is a multidimensional index in sub_map_offset.mapping.extents(), sub_map_offset.mapping(I...) + sub_map_offset.offset == src.mapping()(src-indices(array{I...}, slices...)) is true.

[Note 2:

These conditions ensure that the mapping returned by submdspan_mapping matches the algorithmically expected index-mapping given the slice specifiers.

— end note]

Effects: Equivalent to: auto sub_map_result = submdspan_mapping(src.mapping(), slices...); return mdspan(src.accessor().offset(src.data(), sub_map_result.offset), sub_map_result.mapping, AccessorPolicy::offset_policy(src.accessor()));

[Example 1:

Given a rank-3 mdspan grid3d representing a three-dimensional grid of regularly spaced points in a rectangular prism, the function zero_surface sets all elements on the surface of the 3-dimensional shape to zero.

It does so by reusing a function zero_2d that takes a rank-2 mdspan.

// zero out all elements in an mdspan template<class T, class E, class L, class A> void zero_2d(mdspan<T, E, L, A> a) { static_assert(a.rank() == 2); for (int i = 0; i < a.extent(0); i++) for (int j = 0; j < a.extent(1); j++) a[i, j] = 0; } // zero out just the surface template<class T, class E, class L, class A> void zero_surface(mdspan<T, E, L, A> grid3d) { static_assert(grid3d.rank() == 3); zero_2d(submdspan(grid3d, 0, full_extent, full_extent)); zero_2d(submdspan(grid3d, full_extent, 0, full_extent)); zero_2d(submdspan(grid3d, full_extent, full_extent, 0)); zero_2d(submdspan(grid3d, grid3d.extent(0) - 1, full_extent, full_extent)); zero_2d(submdspan(grid3d, full_extent, grid3d.extent(1) - 1, full_extent)); zero_2d(submdspan(grid3d, full_extent, full_extent, grid3d.extent(2) - 1)); } — end example]

23 Containers library [containers]

23.7 Views [views]

23.7.3 Multidimensional access [views.multidim]

23.7.3.1 Overview [mdspan.overview]

23.7.3.2 Header <mdspan> synopsis [mdspan.syn]

23.7.3.3 Class template extents [mdspan.extents]

23.7.3.3.1 Overview [mdspan.extents.overview]

23.7.3.3.2 Exposition-only helpers [mdspan.extents.expo]

23.7.3.3.3 Constructors [mdspan.extents.cons]

23.7.3.3.4 Observers of the multidimensional index space [mdspan.extents.obs]

23.7.3.3.5 Comparison operators [mdspan.extents.cmp]

23.7.3.3.6 Alias template dextents [mdspan.extents.dextents]

23.7.3.3.7 Alias template dims [mdspan.extents.dims]

23.7.3.4 Layout mapping [mdspan.layout]

23.7.3.4.1 General [mdspan.layout.general]

23.7.3.4.2 Requirements [mdspan.layout.reqmts]

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

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

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

23.7.3.4.5.1 Overview [mdspan.layout.left.overview]

23.7.3.4.5.2 Constructors [mdspan.layout.left.cons]

23.7.3.4.5.3 Observers [mdspan.layout.left.obs]

23.7.3.4.6 Class template layout_right​::​mapping [mdspan.layout.right]

23.7.3.4.6.1 Overview [mdspan.layout.right.overview]

23.7.3.4.6.2 Constructors [mdspan.layout.right.cons]

23.7.3.4.6.3 Observers [mdspan.layout.right.obs]

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

23.7.3.4.7.1 Overview [mdspan.layout.stride.overview]

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

23.7.3.4.7.3 Constructors [mdspan.layout.stride.cons]

23.7.3.4.7.4 Observers [mdspan.layout.stride.obs]

23.7.3.4.8 Class template layout_left_padded​::​mapping [mdspan.layout.leftpad]

23.7.3.4.8.1 Overview [mdspan.layout.leftpad.overview]

23.7.3.4.8.2 Exposition-only members [mdspan.layout.leftpad.expo]

23.7.3.4.8.3 Constructors [mdspan.layout.leftpad.cons]

23.7.3.4.8.4 Observers [mdspan.layout.leftpad.obs]

23.7.3.4.9 Class template layout_right_padded​::​mapping [mdspan.layout.rightpad]

23.7.3.4.9.1 Overview [mdspan.layout.rightpad.overview]

23.7.3.4.9.2 Exposition-only members [mdspan.layout.rightpad.expo]

23.7.3.4.9.3 Constructors [mdspan.layout.rightpad.cons]

23.7.3.4.9.4 Observers [mdspan.layout.rightpad.obs]

23.7.3.5 Accessor policy [mdspan.accessor]

23.7.3.5.1 General [mdspan.accessor.general]

23.7.3.5.2 Requirements [mdspan.accessor.reqmts]

23.7.3.5.3 Class template default_accessor [mdspan.accessor.default]

23.7.3.5.3.1 Overview [mdspan.accessor.default.overview]

23.7.3.5.3.2 Members [mdspan.accessor.default.members]

23.7.3.6 Class template mdspan [mdspan.mdspan]

23.7.3.6.1 Overview [mdspan.mdspan.overview]

23.7.3.6.2 Constructors [mdspan.mdspan.cons]

23.7.3.6.3 Members [mdspan.mdspan.members]

23.7.3.7 submdspan [mdspan.sub]

23.7.3.7.1 Overview [mdspan.sub.overview]

23.7.3.7.2 strided_slice [mdspan.sub.strided.slice]

23.7.3.7.3 submdspan_mapping_result [mdspan.sub.map.result]

23.7.3.7.4 Exposition-only helpers [mdspan.sub.helpers]

23.7.3.7.5 submdspan_extents function [mdspan.sub.extents]

23.7.3.7.6 Specializations of submdspan_mapping [mdspan.sub.map]

23.7.3.7.6.1 Common [mdspan.sub.map.common]

23.7.3.7.6.2 layout_left specialization of submdspan_mapping [mdspan.sub.map.left]

23.7.3.7.6.3 layout_right specialization of submdspan_mapping [mdspan.sub.map.right]

23.7.3.7.6.4 layout_stride specialization of submdspan_mapping [mdspan.sub.map.stride]

23.7.3.7.6.5 layout_left_padded specialization of submdspan_mapping [mdspan.sub.map.leftpad]

23.7.3.7.6.6 layout_right_padded specialization of submdspan_mapping [mdspan.sub.map.rightpad]

23.7.3.7.7 submdspan function template [mdspan.sub.sub]

23.7.3.4.5 Class template layout_left::mapping [mdspan.layout.left]

23.7.3.4.6 Class template layout_right::mapping [mdspan.layout.right]

23.7.3.4.7 Class template layout_stride::mapping [mdspan.layout.stride]

23.7.3.4.8 Class template layout_left_padded::mapping [mdspan.layout.leftpad]

23.7.3.4.9 Class template layout_right_padded::mapping [mdspan.layout.rightpad]