[mdspan.layout] - C++20 → C++23

Files changed (1) hide show

tmp/tmpfgbub1f9/{from.md → to.md} +871 -0

tmp/tmpfgbub1f9/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,871 @@

+#### Layout mapping <a id="mdspan.layout">[[mdspan.layout]]</a>
+##### General <a id="mdspan.layout.general">[[mdspan.layout.general]]</a>
+In subclauses [[mdspan.layout.reqmts]] and
+[[mdspan.layout.policy.reqmts]]:
+- `M` denotes a layout mapping class.
+- `m` denotes a (possibly const) value of type `M`.
+- `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*]
+- `r` is a (possibly const) rank index of `typename M::extents_type`.
+- `dᵣ` is a pack of (possibly const) integers for which
+  `sizeof...(dᵣ) == M::extents_type::rank()` is `true`, the rᵗʰ element
+  is equal to 1, and all other elements are equal to 0.
+In subclauses [[mdspan.layout.reqmts]] through [[mdspan.layout.stride]],
+let *`is-mapping-of`* be the exposition-only variable template defined
+as follows:
+``` cpp
+template<class Layout, class Mapping>
+constexpr bool is-mapping-of =  // exposition only
+  is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;
+```
+##### Requirements <a id="mdspan.layout.reqmts">[[mdspan.layout.reqmts]]</a>
+A type `M` meets the *layout mapping* requirements if
+- `M` models `copyable` and `equality_comparable`,
+- `is_nothrow_move_constructible_v<M>` is `true`,
+- `is_nothrow_move_assignable_v<M>` is `true`,
+- `is_nothrow_swappable_v<M>` is `true`, and
+- the following types and expressions are well-formed and have the
+  specified semantics.
+``` cpp
+typename M::extents_type
+```
+*Result:* A type that is a specialization of `extents`.
+``` cpp
+typename M::index_type
+```
+*Result:* `typename M::extents_type::index_type`.
+``` cpp
+typename M::rank_type
+```
+*Result:* `typename M::extents_type::rank_type`.
+``` cpp
+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`.
+``` cpp
+m.extents()
+```
+*Result:* `const typename M::extents_type&`
+``` cpp
+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()`.
+``` cpp
+m(i...) == m(static_cast<typename M::index_type>(i)...)
+```
+*Result:* `bool`
+*Returns:* `true`
+``` cpp
+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`.
+``` cpp
+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*]
+``` cpp
+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*]
+``` cpp
+m.is_strided()
+```
+*Result:* `bool`
+*Returns:* `true` only if for every rank index r of `m.extents()` there
+exists an integer sᵣ such that, for all `i` where (`i`+dᵣ) is a
+multidimensional index in `m.extents()` [[mdspan.overview]],
+`m((i + `dᵣ`)...) - m(i...)` equals sᵣ.
+[*Note 3*: This implies that for a strided layout
+m(i₀, …, iₖ) = m(0, …, 0) + i₀ × s₀ + … + iₖ × sₖ. — *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*]
+``` cpp
+m.stride(r)
+```
+*Preconditions:* `m.is_strided()` is `true`.
+*Result:* `typename M::index_type`
+*Returns:* sᵣ as defined in `m.is_strided()` above.
+``` cpp
+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*]
+``` cpp
+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*]
+``` cpp
+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*]
+##### Layout mapping policy requirements <a id="mdspan.layout.policy.reqmts">[[mdspan.layout.policy.reqmts]]</a>
+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`.
+##### Layout mapping policies <a id="mdspan.layout.policy.overview">[[mdspan.layout.policy.overview]]</a>
+``` cpp
+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;
+  };
+}
+```
+Each of `layout_left`, `layout_right`, and `layout_stride` meets the
+layout mapping policy requirements and is a trivial type.
+##### Class template `layout_left::mapping` <a id="mdspan.layout.left">[[mdspan.layout.left]]</a>
+###### Overview <a id="mdspan.layout.left.overview">[[mdspan.layout.left.overview]]</a>
+`layout_left` provides a layout mapping where the leftmost extent has
+stride 1, and strides increase left-to-right as the product of extents.
+``` cpp
+namespace std {
+  template<class Extents>
+  class layout_left::mapping {
+  public:
+    using extents_type = Extents;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using layout_type = layout_left;
+    // [mdspan.layout.left.cons], constructors
+    constexpr mapping() noexcept = default;
+    constexpr mapping(const mapping&) noexcept = default;
+    constexpr mapping(const extents_type&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+        mapping(const layout_right::mapping<OtherExtents>&) noexcept;
+    template<class OtherExtents>
+      constexpr explicit(extents_type::rank() > 0)
+        mapping(const layout_stride::mapping<OtherExtents>&);
+    constexpr mapping& operator=(const mapping&) noexcept = default;
+    // [mdspan.layout.left.obs], observers
+    constexpr const extents_type& extents() const noexcept { return extents_; }
+    constexpr index_type required_span_size() const noexcept;
+    template<class... Indices>
+      constexpr index_type operator()(Indices...) const noexcept;
+    static constexpr bool is_always_unique() noexcept { return true; }
+    static constexpr bool is_always_exhaustive() noexcept { return true; }
+    static constexpr bool is_always_strided() noexcept { return true; }
+    static constexpr bool is_unique() noexcept { return true; }
+    static constexpr bool is_exhaustive() noexcept { return true; }
+    static constexpr bool is_strided() noexcept { return true; }
+    constexpr index_type stride(rank_type) const noexcept;
+    template<class OtherExtents>
+      friend constexpr bool operator==(const mapping&, const mapping<OtherExtents>&) noexcept;
+  private:
+    extents_type extents_{};    // exposition only
+  };
+}
+```
+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`.
+###### Constructors <a id="mdspan.layout.left.cons">[[mdspan.layout.left.cons]]</a>
+``` cpp
+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`.
+``` cpp
+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()`.
+``` cpp
+template<class OtherExents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:*
+- `extents_type::rank() <= 1` is `true`, and
+- `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()`.
+``` cpp
+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:*
+- 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
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+###### Observers <a id="mdspan.layout.left.obs">[[mdspan.layout.left.obs]]</a>
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == extents_type::rank()` is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(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
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+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)`.
+``` cpp
+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();`
+##### Class template `layout_right::mapping` <a id="mdspan.layout.right">[[mdspan.layout.right]]</a>
+###### Overview <a id="mdspan.layout.right.overview">[[mdspan.layout.right.overview]]</a>
+`layout_right` provides a layout mapping where the rightmost extent is
+stride 1, and strides increase right-to-left as the product of extents.
+``` cpp
+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 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
+  };
+}
+```
+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`.
+###### Constructors <a id="mdspan.layout.right.cons">[[mdspan.layout.right.cons]]</a>
+``` cpp
+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`.
+``` cpp
+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()`.
+``` cpp
+template<class OtherExtents>
+  constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
+    mapping(const layout_left::mapping<OtherExtents>& other) noexcept;
+```
+*Constraints:*
+- `extents_type::rank() <= 1` is `true`, and
+- `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()`.
+``` cpp
+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:*
+- 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`)`.
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+*Effects:* Direct-non-list-initializes *extents\_* with
+`other.extents()`.
+###### Observers <a id="mdspan.layout.right.obs">[[mdspan.layout.right.obs]]</a>
+``` cpp
+index_type required_span_size() const noexcept;
+```
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(extents_type::rank())`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == extents_type::rank()` is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(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
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+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)`.
+``` cpp
+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();`
+##### Class template `layout_stride::mapping` <a id="mdspan.layout.stride">[[mdspan.layout.stride]]</a>
+###### Overview <a id="mdspan.layout.stride.overview">[[mdspan.layout.stride.overview]]</a>
+`layout_stride` provides a layout mapping where the strides are
+user-defined.
+``` cpp
+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
+  };
+}
+```
+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`.
+###### Exposition-only helpers <a id="mdspan.layout.stride.expo">[[mdspan.layout.stride.expo]]</a>
+Let `REQUIRED-SPAN-SIZE(e, strides)` be:
+- `1`, if `e.rank() == 0` is `true`,
+- otherwise `0`, if the size of the multidimensional index space `e` is
+  0,
+- otherwise `1` plus the sum of products of `(e.extent(r) - 1)` and
+  `strides[r]` for all r in the range [0, `e.rank()`).
+Let `OFFSET(m)` be:
+- `m()`, if `e.rank() == 0` is `true`,
+- otherwise `0`, if the size of the multidimensional index space `e` is
+  0,
+- 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:
+``` cpp
+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:
+``` cpp
+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 2*: 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*]
+###### Constructors <a id="mdspan.layout.stride.cons">[[mdspan.layout.stride.cons]]</a>
+``` cpp
+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`)`.
+``` cpp
+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:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`, and
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`.
+*Preconditions:*
+- `s[`i`] > 0` is `true` for all i in the range [0, rank_).
+- *`REQUIRED-SPAN-SIZE`*`(e, s)` is representable as a value of type
+  `index_type` [[basic.fundamental]].
+- If *rank\_* is greater than 0, then there exists a permutation P of
+  the integers in the range [0, rank_), such that
+  `s[`pᵢ`] >= s[`pᵢ₋₁`] * e.extent(p`ᵢ₋₁`)` is `true` for all i in the
+  range [1, rank_), where pᵢ is the iᵗʰ element of P. \[*Note 3*: 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`])`.
+``` cpp
+template<class StridedLayoutMapping>
+  constexpr explicit(see below)
+    mapping(const StridedLayoutMapping& other) noexcept;
+```
+*Constraints:*
+- `layout-mapping-alike<StridedLayoutMapping>` is satisfied.
+- `is_constructible_v<extents_type, typename StridedLayoutMapping::extents_type>`
+  is
+  `true`.
+- `StridedLayoutMapping::is_always_unique()` is `true`.
+- `StridedLayoutMapping::is_always_strided()` is `true`.
+*Preconditions:*
+- `StridedLayoutMapping` meets the layout mapping
+  requirements [[mdspan.layout.policy.reqmts]],
+- `other.stride(`r`) > 0` is `true` for every rank index r of
+  `extents()`,
+- `other.required_span_size()` is representable as a value of type
+  `index_type` [[basic.fundamental]], and
+- *`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:
+``` cpp
+!(is_convertible_v<typename StridedLayoutMapping::extents_type, extents_type> &&
+  (is-mapping-of<layout_left, LayoutStrideMapping> ||
+   is-mapping-of<layout_right, LayoutStrideMapping> ||
+   is-mapping-of<layout_stride, LayoutStrideMapping>))
+```
+###### Observers <a id="mdspan.layout.stride.obs">[[mdspan.layout.stride.obs]]</a>
+``` cpp
+constexpr index_type required_span_size() const noexcept;
+```
+*Returns:* *`REQUIRED-SPAN-SIZE`*`(extents(), `*`strides_`*`)`.
+``` cpp
+template<class... Indices>
+  constexpr index_type operator()(Indices... i) const noexcept;
+```
+*Constraints:*
+- `sizeof...(Indices) == `*`rank_`* is `true`,
+- `(is_convertible_v<Indices, index_type> && ...)` is `true`, and
+- `(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
+``` cpp
+is_same_v<index_sequence_for<Indices...>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return ((static_cast<index_type>(i) * stride(P)) + ... + 0);
+```
+``` cpp
+constexpr bool is_exhaustive() const noexcept;
+```
+*Returns:*
+- `true` if *rank\_* is 0.
+- Otherwise, `true` if there is a permutation P of the integers in the
+  range [0, rank_) such that `stride(`p₀`)` equals 1, and `stride(`pᵢ`)`
+  equals `stride(`pᵢ₋₁`) * extents().extent(`pᵢ₋₁`)` for i in the range
+  [1, rank_), where pᵢ is the iᵗʰ element of P.
+- Otherwise, `false`.
+``` cpp
+template<class OtherMapping>
+  friend constexpr bool operator==(const mapping& x, const OtherMapping& y) noexcept;
+```
+*Constraints:*
+- `layout-mapping-alike<OtherMapping>` is satisfied.
+- *`rank_`*` == OtherMapping::extents_type::rank()` is `true`.
+- `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`.

Diff to HTML by rtfpessoa