From b93a719aacf8e73b35f2ecd5ca90d341cb73f90b Mon Sep 17 00:00:00 2001
From: Matthias Kretz <m.kretz@gsi.de>
Date: Tue, 18 Feb 2025 07:55:48 +0100
Subject: [PATCH] P3287R3 Exploration of namespaces for std::simd

---
 source/numerics.tex | 577 ++++++++++++++++++++++++++------------------
 1 file changed, 339 insertions(+), 238 deletions(-)

diff --git a/source/numerics.tex b/source/numerics.tex
index fab9bc7e05..587269c6d6 100644
--- a/source/numerics.tex
+++ b/source/numerics.tex
@@ -16388,24 +16388,24 @@
 \rSec2[simd.syn]{Header \tcode{<simd>} synopsis}
 \indexheader{simd}%
 \begin{codeblock}
-namespace std {
+namespace std::datapar {
   // \ref{simd.traits}, \tcode{simd} type traits
-  template<class T, class U = typename T::value_type> struct simd_alignment;
+  template<class T, class U = typename T::value_type> struct alignment;
   template<class T, class U = typename T::value_type>
-    constexpr size_t simd_alignment_v = simd_alignment<T, U>::value;
+    constexpr size_t alignment_v = alignment<T, U>::value;
 
-  template<class T, class V> struct rebind_simd { using type = @\seebelow@; };
-  template<class T, class V> using rebind_simd_t = typename rebind_simd<T, V>::type;
-  template<@\exposid{simd-size-type}@ N, class V> struct resize_simd { using type = @\seebelow@; };
-  template<@\exposid{simd-size-type}@ N, class V> using resize_simd_t = typename resize_simd<N, V>::type;
+  template<class T, class V> struct rebind { using type = @\seebelow@; };
+  template<class T, class V> using rebind_t = typename rebind<T, V>::type;
+  template<@\exposid{simd-size-type}@ N, class V> struct resize { using type = @\seebelow@; };
+  template<@\exposid{simd-size-type}@ N, class V> using resize_t = typename resize<N, V>::type;
 
   // \ref{simd.flags}, Load and store flags
-  template<class... Flags> struct simd_flags;
-  inline constexpr simd_flags<> simd_flag_default{};
-  inline constexpr simd_flags<@\exposid{convert-flag}@> simd_flag_convert{};
-  inline constexpr simd_flags<@\exposid{aligned-flag}@> simd_flag_aligned{};
+  template<class... Flags> struct flags;
+  inline constexpr flags<> flag_default{};
+  inline constexpr flags<@\exposid{convert-flag}@> flag_convert{};
+  inline constexpr flags<@\exposid{aligned-flag}@> flag_aligned{};
   template<size_t N> requires (has_single_bit(N))
-    constexpr simd_flags<@\exposid{overaligned-flag}<N>@> simd_flag_overaligned{};
+    constexpr flags<@\exposid{overaligned-flag}<N>@> flag_overaligned{};
 
   // \ref{simd.class}, Class template \tcode{basic_simd}
   template<class T, class Abi = @\exposid{native-abi}@<T>> class basic_simd;
@@ -16420,114 +16420,111 @@
   // \ref{simd.loadstore}, \tcode{basic_simd} load and store functions
   template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R>
-    constexpr V simd_unchecked_load(R&& r, simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(R&& r, flags<Flags...> f = {});
   template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R>
-    constexpr V simd_unchecked_load(R&& r, const typename V::mask_type& k,
-                                    simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(R&& r, const typename V::mask_type& k,
+                               flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    constexpr V simd_unchecked_load(I first, iter_difference_t<I> n,
-                                    simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(I first, iter_difference_t<I> n,
+                               flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    constexpr V simd_unchecked_load(I first, iter_difference_t<I> n,
-                                    const typename V::mask_type& k, simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(I first, iter_difference_t<I> n,
+                               const typename V::mask_type& k, flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    constexpr V simd_unchecked_load(I first, S last, simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    constexpr V simd_unchecked_load(I first, S last, const typename V::mask_type& k,
-                                    simd_flags<Flags...> f = {});
+    constexpr V unchecked_load(I first, S last, const typename V::mask_type& k,
+                               flags<Flags...> f = {});
 
   template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R>
-    constexpr V simd_partial_load(R&& r, simd_flags<Flags...> f = {});
+    constexpr V partial_load(R&& r, flags<Flags...> f = {});
   template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R>
-    constexpr V simd_partial_load(R&& r, const typename V::mask_type& k,
-                                  simd_flags<Flags...> f = {});
+    constexpr V partial_load(R&& r, const typename V::mask_type& k,
+                             flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    constexpr V simd_partial_load(I first, iter_difference_t<I> n, simd_flags<Flags...> f = {});
+    constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    constexpr V simd_partial_load(I first, iter_difference_t<I> n,
-                                  const typename V::mask_type& k, simd_flags<Flags...> f = {});
+    constexpr V partial_load(I first, iter_difference_t<I> n,
+                             const typename V::mask_type& k, flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    constexpr V simd_partial_load(I first, S last, simd_flags<Flags...> f = {});
+    constexpr V partial_load(I first, S last, flags<Flags...> f = {});
   template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    constexpr V simd_partial_load(I first, S last, const typename V::mask_type& k,
-                                  simd_flags<Flags...> f = {});
+    constexpr V partial_load(I first, S last, const typename V::mask_type& k,
+                             flags<Flags...> f = {});
 
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, R&& r,
-                                        simd_flags<Flags...> f = {});
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, R&& r,
+                                   flags<Flags...> f = {});
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, R&& r,
-      const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, R&& r,
+      const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first,
-                                        iter_difference_t<I> n, simd_flags<Flags...> f = {});
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first,
+                                   iter_difference_t<I> n, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first,
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first,
       iter_difference_t<I> n, const typename basic_simd<T, Abi>::mask_type& mask,
-      simd_flags<Flags...> f = {});
+      flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
-                                        simd_flags<Flags...> f = {});
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
+                                   flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
-      const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+    constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
+      const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-    constexpr void simd_partial_store(const basic_simd<T, Abi>& v, R&& r,
-                                      simd_flags<Flags...> f = {});
+    constexpr void partial_store(const basic_simd<T, Abi>& v, R&& r,
+                                 flags<Flags...> f = {});
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
     requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-    constexpr void simd_partial_store(const basic_simd<T, Abi>& v, R&& r,
-      const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+    constexpr void partial_store(const basic_simd<T, Abi>& v, R&& r,
+      const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_partial_store(
-      const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-      simd_flags<Flags...> f = {});
+    constexpr void partial_store(
+      const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_partial_store(
+    constexpr void partial_store(
       const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-      const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+      const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, S last,
-      simd_flags<Flags...> f = {});
+    constexpr void partial_store(const basic_simd<T, Abi>& v, I first, S last,
+                                 flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
     requires @\libconcept{indirectly_writable}@<I, T>
-    constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, S last,
-      const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+    constexpr void partial_store(const basic_simd<T, Abi>& v, I first, S last,
+      const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 
   // \ref{simd.creation}, \tcode{basic_simd} and \tcode{basic_simd_mask} creation
   template<class T, class Abi>
-    constexpr auto
-      simd_chunk(const basic_simd<typename T::value_type, Abi>& x) noexcept;
+    constexpr auto chunk(const basic_simd<typename T::value_type, Abi>& x) noexcept;
   template<class T, class Abi>
-    constexpr auto
-      simd_chunk(const basic_simd_mask<@\exposid{mask-element-size}@<T>, Abi>& x) noexcept;
+    constexpr auto chunk(const basic_simd_mask<@\exposid{mask-element-size}@<T>, Abi>& x) noexcept;
 
   template<size_t N, class T, class Abi>
-    constexpr auto simd_chunk(const basic_simd<T, Abi>& x) noexcept;
+    constexpr auto chunk(const basic_simd<T, Abi>& x) noexcept;
   template<size_t N, size_t Bytes, class Abi>
-    constexpr auto simd_chunk(const basic_simd_mask<Bytes, Abi>& x) noexcept;
+    constexpr auto chunk(const basic_simd_mask<Bytes, Abi>& x) noexcept;
 
   template<class T, class... Abis>
     constexpr basic_simd<T, @\exposid{deduce-abi-t}@<T, (basic_simd<T, Abis>::size() + ...)>>
-      simd_cat(const basic_simd<T, Abis>&...) noexcept;
+      cat(const basic_simd<T, Abis>&...) noexcept;
   template<size_t Bytes, class... Abis>
     constexpr basic_simd_mask<Bytes, @\exposid{deduce-abi-t}@<@\exposid{integer-from}@<Bytes>,
                               (basic_simd_mask<Bytes, Abis>::size() + ...)>>
-      simd_cat(const basic_simd_mask<Bytes, Abis>&...) noexcept;
+      cat(const basic_simd_mask<Bytes, Abis>&...) noexcept;
 
   // \ref{simd.mask.reductions}, \tcode{basic_simd_mask} reductions
   template<size_t Bytes, class Abi>
@@ -16585,10 +16582,10 @@
             const basic_simd<T, Abi>& hi);
 
   template<class T, class U>
-    constexpr auto simd_select(bool c, const T& a, const U& b)
+    constexpr auto select(bool c, const T& a, const U& b)
     -> remove_cvref_t<decltype(c ? a : b)>;
   template<size_t Bytes, class Abi, class T, class U>
-    constexpr auto simd_select(const basic_simd_mask<Bytes, Abi>& c, const T& a, const U& b)
+    constexpr auto select(const basic_simd_mask<Bytes, Abi>& c, const T& a, const U& b)
     noexcept -> decltype(@\exposid{simd-select-impl}@(c, a, b));
 
   // \ref{simd.math}, Mathematical functions
@@ -16611,11 +16608,11 @@
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> expm1(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
     constexpr @\exposid{deduced-simd-t}@<V>
-      frexp(const V& value, rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>* exp);
+      frexp(const V& value, rebind_t<int, @\exposid{deduced-simd-t}@<V>>* exp);
   template<@\exposconcept{math-floating-point}@ V>
-    constexpr rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>> ilogb(const V& x);
+    constexpr rebind_t<int, @\exposid{deduced-simd-t}@<V>> ilogb(const V& x);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> ldexp(const V& x, const
-  rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>& exp);
+  rebind_t<int, @\exposid{deduced-simd-t}@<V>>& exp);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> log(const V& x);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> log10(const V& x);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> log1p(const V& x);
@@ -16625,10 +16622,10 @@
     constexpr basic_simd<T, Abi> modf(const type_identity_t<basic_simd<T, Abi>>& value,
                                       basic_simd<T, Abi>* iptr);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> scalbn(const V& x, const
-  rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>& n);
+  rebind_t<int, @\exposid{deduced-simd-t}@<V>>& n);
   template<@\exposconcept{math-floating-point}@ V>
     constexpr @\exposid{deduced-simd-t}@<V> scalbln(
-      const V& x, const rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>>& n);
+      const V& x, const rebind_t<long int, @\exposid{deduced-simd-t}@<V>>& n);
   template<@\exposconcept{math-floating-point}@ V> constexpr @\exposid{deduced-simd-t}@<V> cbrt(const V& x);
   template<@\libconcept{signed_integral}@ T, class Abi>
     constexpr basic_simd<T, Abi> abs(const basic_simd<T, Abi>& j);
@@ -16650,15 +16647,15 @@
   template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> nearbyint(const V& x);
   template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> rint(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>> lrint(const V& x);
+    rebind_t<long int, @\exposid{deduced-simd-t}@<V>> lrint(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    rebind_simd_t<long long int, V> llrint(const @\exposid{deduced-simd-t}@<V>& x);
+    rebind_t<long long int, V> llrint(const @\exposid{deduced-simd-t}@<V>& x);
   template<@\exposconcept{math-floating-point}@ V>
     constexpr @\exposid{deduced-simd-t}@<V> round(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    constexpr rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>> lround(const V& x);
+    constexpr rebind_t<long int, @\exposid{deduced-simd-t}@<V>> lround(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    constexpr rebind_simd_t<long long int, @\exposid{deduced-simd-t}@<V>> llround(const V& x);
+    constexpr rebind_t<long long int, @\exposid{deduced-simd-t}@<V>> llround(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
     constexpr @\exposid{deduced-simd-t}@<V> trunc(const V& x);
   template<class V0, class V1>
@@ -16667,7 +16664,7 @@
     constexpr @\exposid{math-common-simd-t}@<V0, V1> remainder(const V0& x, const V1& y);
   template<class V0, class V1>
     constexpr @\exposid{math-common-simd-t}@<V0, V1>
-      remquo(const V0& x, const V1& y, rebind_simd_t<int, @\exposid{math-common-simd-t}@<V0, V1>>* quo);
+      remquo(const V0& x, const V1& y, rebind_t<int, @\exposid{math-common-simd-t}@<V0, V1>>* quo);
   template<class V0, class V1>
     constexpr @\exposid{math-common-simd-t}@<V0, V1> copysign(const V0& x, const V1& y);
   template<class V0, class V1>
@@ -16684,7 +16681,7 @@
     constexpr @\exposid{math-common-simd-t}@<V0, V1, V2>
     lerp(const V0& a, const V1& b, const V2& t) noexcept;
   template<@\exposconcept{math-floating-point}@ V>
-    constexpr rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>> fpclassify(const V& x);
+    constexpr rebind_t<int, @\exposid{deduced-simd-t}@<V>> fpclassify(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
     constexpr typename @\exposid{deduced-simd-t}@<V>::mask_type isfinite(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
@@ -16714,12 +16711,12 @@
     constexpr typename @\exposid{math-common-simd-t}@<V0, V1>::mask_type
       isunordered(const V0& x, const V1& y);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> assoc_laguerre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const
-      rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
+    @\exposid{deduced-simd-t}@<V> assoc_laguerre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const
+      rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
                      const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> assoc_legendre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const
-      rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
+    @\exposid{deduced-simd-t}@<V> assoc_legendre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const
+      rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
                      const V& x);
   template<class V0, class V1>
     @\exposid{math-common-simd-t}@<V0, V1> beta(const V0& x, const V1& y);
@@ -16743,22 +16740,22 @@
     @\exposid{math-common-simd-t}@<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi);
   template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> expint(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> hermite(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
+    @\exposid{deduced-simd-t}@<V> hermite(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> laguerre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
+    @\exposid{deduced-simd-t}@<V> laguerre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> legendre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const V& x);
+    @\exposid{deduced-simd-t}@<V> legendre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const V& x);
   template<@\exposconcept{math-floating-point}@ V>
     @\exposid{deduced-simd-t}@<V> riemann_zeta(const V& x);
   template<@\exposconcept{math-floating-point}@ V>
     @\exposid{deduced-simd-t}@<V> sph_bessel(
-      const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
+      const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
   template<@\exposconcept{math-floating-point}@ V>
-    @\exposid{deduced-simd-t}@<V> sph_legendre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l,
-      const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m, const V& theta);
+    @\exposid{deduced-simd-t}@<V> sph_legendre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l,
+      const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m, const V& theta);
   template<@\exposconcept{math-floating-point}@ V>
     @\exposid{deduced-simd-t}@<V>
-      sph_neumann(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
+      sph_neumann(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const V& x);
 
   // \ref{simd.bit}, Bit manipulation
   template<@\exposconcept{simd-type}@ V> constexpr V byteswap(const V& v) noexcept;
@@ -16779,39 +16776,35 @@
     constexpr V  rotr(const V& v, int s) noexcept;
 
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-    bit_width(const V& v) noexcept;
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept;
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
     countl_zero(const V& v) noexcept;
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-    countl_one(const V& v) noexcept;
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept;
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
     countr_zero(const V& v) noexcept;
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-    countr_one(const V& v) noexcept;
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept;
   template<@\exposconcept{simd-type}@ V>
-    constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-    popcount(const V& v) noexcept;
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept;
 
   // \ref{simd.complex.math}, simd complex math
   template<@\exposconcept{simd-complex}@ V>
-    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
+    constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
 
   template<@\exposconcept{simd-complex}@ V>
-    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
+    constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
 
   template<@\exposconcept{simd-complex}@ V>
-    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
+    constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
 
   template<@\exposconcept{simd-complex}@ V>
-    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
+    constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
 
   template<@\exposconcept{simd-complex}@ V>
-    constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
+    constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
 
   template<@\exposconcept{simd-complex}@ V> constexpr V conj(const V&);
   template<@\exposconcept{simd-complex}@ V> constexpr V proj(const V&);
@@ -16834,21 +16827,145 @@
   template<@\exposconcept{simd-complex}@ V> constexpr V atanh(const V& v);
 
   template<@\exposconcept{simd-floating-point}@ V>
-    rebind_simd_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
+    rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
 
   template<@\exposconcept{simd-complex}@ V> constexpr V pow(const V& x, const V& y);
 }
+
+namespace std {
+  // See \ref{simd.alg}, Algorithms
+  using datapar::min;
+  using datapar::max;
+  using datapar::minmax;
+  using datapar::clamp;
+
+  // See \ref{simd.math}, Mathematical functions
+  using datapar::acos;
+  using datapar::asin;
+  using datapar::atan;
+  using datapar::atan2;
+  using datapar::cos;
+  using datapar::sin;
+  using datapar::tan;
+  using datapar::acosh;
+  using datapar::asinh;
+  using datapar::atanh;
+  using datapar::cosh;
+  using datapar::sinh;
+  using datapar::tanh;
+  using datapar::exp;
+  using datapar::exp2;
+  using datapar::expm1;
+  using datapar::frexp;
+  using datapar::ilogb;
+  using datapar::ldexp;
+  using datapar::log;
+  using datapar::log10;
+  using datapar::log1p;
+  using datapar::log2;
+  using datapar::logb;
+  using datapar::modf;
+  using datapar::scalbn;
+  using datapar::scalbln;
+  using datapar::cbrt;
+  using datapar::abs;
+  using datapar::abs;
+  using datapar::fabs;
+  using datapar::hypot;
+  using datapar::pow;
+  using datapar::sqrt;
+  using datapar::erf;
+  using datapar::erfc;
+  using datapar::lgamma;
+  using datapar::tgamma;
+  using datapar::ceil;
+  using datapar::floor;
+  using datapar::nearbyint;
+  using datapar::rint;
+  using datapar::lrint;
+  using datapar::llrint;
+  using datapar::round;
+  using datapar::lround;
+  using datapar::llround;
+  using datapar::trunc;
+  using datapar::fmod;
+  using datapar::remainder;
+  using datapar::remquo;
+  using datapar::copysign;
+  using datapar::nextafter;
+  using datapar::fdim;
+  using datapar::fmax;
+  using datapar::fmin;
+  using datapar::fma;
+  using datapar::lerp;
+  using datapar::fpclassify;
+  using datapar::isfinite;
+  using datapar::isinf;
+  using datapar::isnan;
+  using datapar::isnormal;
+  using datapar::signbit;
+  using datapar::isgreater;
+  using datapar::isgreaterequal;
+  using datapar::isless;
+  using datapar::islessequal;
+  using datapar::islessgreater;
+  using datapar::isunordered;
+  using datapar::assoc_laguerre;
+  using datapar::assoc_legendre;
+  using datapar::beta;
+  using datapar::comp_ellint_1;
+  using datapar::comp_ellint_2;
+  using datapar::comp_ellint_3;
+  using datapar::cyl_bessel_i;
+  using datapar::cyl_bessel_j;
+  using datapar::cyl_bessel_k;
+  using datapar::cyl_neumann;
+  using datapar::ellint_1;
+  using datapar::ellint_2;
+  using datapar::ellint_3;
+  using datapar::expint;
+  using datapar::hermite;
+  using datapar::laguerre;
+  using datapar::legendre;
+  using datapar::riemann_zeta;
+  using datapar::sph_bessel;
+  using datapar::sph_legendre;
+  using datapar::sph_neumann;
+
+  // See \ref{simd.bit}, Bit manipulation
+  using datapar::byteswap;
+  using datapar::bit_ceil;
+  using datapar::bit_floor;
+  using datapar::has_single_bit;
+  using datapar::rotl;
+  using datapar::rotr;
+  using datapar::bit_width;
+  using datapar::countl_zero;
+  using datapar::countl_one;
+  using datapar::countr_zero;
+  using datapar::countr_one;
+  using datapar::popcount;
+
+  // See \ref{simd.complex.math}, simd complex math
+  using datapar::real;
+  using datapar::imag;
+  using datapar::arg;
+  using datapar::norm;
+  using datapar::conj;
+  using datapar::proj;
+  using datapar::polar;
+}
 \end{codeblock}
 
 \rSec2[simd.traits]{\tcode{simd} type traits}
 
 \begin{itemdecl}
-template<class T, class U = typename T::value_type> struct simd_alignment { @\seebelow@ };
+template<class T, class U = typename T::value_type> struct alignment { @\seebelow@ };
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
-\tcode{simd_alignment<T, U>} has a member \tcode{value} if and only if
+\tcode{alignment<T, U>} has a member \tcode{value} if and only if
 \begin{itemize}
  \item
    \tcode{T} is a specialization of \tcode{basic_simd_mask} and \tcode{U} is
@@ -16859,7 +16976,7 @@
 \end{itemize}
 
 \pnum
-If \tcode{value} is present, the type \tcode{simd_alignment<T, U>} is a
+If \tcode{value} is present, the type \tcode{alignment<T, U>} is a
 \tcode{BinaryTypeTrait} with a base characteristic of
 \tcode{integral_constant<size_t, N>} for some unspecified
 \tcode{N}\iref{simd.ctor,simd.loadstore}.
@@ -16870,12 +16987,12 @@
 \end{note}
 
 \pnum
-The behavior of a program that adds specializations for \tcode{simd_alignment}
+The behavior of a program that adds specializations for \tcode{alignment}
 is undefined.
 \end{itemdescr}
 
 \begin{itemdecl}
-template<class T, class V> struct rebind_simd { using type = @\seebelow@; };
+template<class T, class V> struct rebind { using type = @\seebelow@; };
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -16904,7 +17021,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-template<@\exposid{simd-size-type}@ N, class V> struct resize_simd { using type = @\seebelow@; };
+template<@\exposid{simd-size-type}@ N, class V> struct resize { using type = @\seebelow@; };
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -16943,21 +17060,21 @@
 
 \rSec2[simd.flags]{Load and store flags}
 
-\rSec3[simd.flags.overview]{Class template \tcode{simd_flags} overview}
+\rSec3[simd.flags.overview]{Class template \tcode{flags} overview}
 
 \begin{codeblock}
-namespace std {
-  template<class... Flags> struct simd_flags {
-    // \ref{simd.flags.oper}, \tcode{simd_flags} operators
+namespace std::datapar {
+  template<class... Flags> struct flags {
+    // \ref{simd.flags.oper}, \tcode{flags} operators
     template<class... Other>
-      friend consteval auto operator|(simd_flags, simd_flags<Other...>);
+      friend consteval auto operator|(flags, flags<Other...>);
   };
 }
 \end{codeblock}
 
 \pnum
 \begin{note}
-The class template \tcode{simd_flags} acts like an integer bit-flag for types.
+The class template \tcode{flags} acts like an integer bit-flag for types.
 \end{note}
 
 \pnum
@@ -16965,17 +17082,17 @@
 Every type in the parameter pack \tcode{Flags} is one of \tcode{\exposid{convert-flag}},
 \tcode{\exposid{aligned-flag}}, or \tcode{\exposid{over\-aligned-\brk{}flag}<N>}.
 
-\rSec3[simd.flags.oper]{\tcode{simd_flags} operators}
+\rSec3[simd.flags.oper]{\tcode{flags} operators}
 
 \begin{itemdecl}
 template<class... Other>
-  friend consteval auto operator|(simd_flags a, simd_flags<Other...> b);
+  friend consteval auto operator|(flags a, flags<Other...> b);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \returns
-  A default-initialized object of type \tcode{simd_flags<Flags2...>} for some
+  A default-initialized object of type \tcode{flags<Flags2...>} for some
   \tcode{Flags2} where every type in \tcode{Flags2} is present either in template parameter pack
   \tcode{Flags} or in template parameter pack \tcode{Other}, and every type in template parameter
   packs \tcode{Flags} and \tcode{Other} is present in \tcode{Flags2}.
@@ -16990,7 +17107,7 @@
 \rSec3[simd.overview]{Class template \tcode{basic_simd} overview}
 
 \begin{codeblock}
-namespace std {
+namespace std::datapar {
   template<class T, class Abi> class basic_simd {
   public:
     using value_type = T;
@@ -17007,9 +17124,9 @@
       constexpr explicit(@\seebelow@) basic_simd(const basic_simd<U, UAbi>&) noexcept;
     template<class G> constexpr explicit basic_simd(G&& gen) noexcept;
     template<class R, class... Flags>
-      constexpr basic_simd(R&& range, simd_flags<Flags...> = {});
+      constexpr basic_simd(R&& range, flags<Flags...> = {});
     template<class R, class... Flags>
-      constexpr basic_simd(R&& range, const mask_type& mask, simd_flags<Flags...> = {});
+      constexpr basic_simd(R&& range, const mask_type& mask, flags<Flags...> = {});
     template<@\exposconcept{simd-floating-point}@ V>
       constexpr explicit(@\seebelow@) basic_simd(const V& reals, const V& imags = {}) noexcept;
 
@@ -17214,9 +17331,9 @@
 
 \begin{itemdecl}
 template<class R, class... Flags>
-  constexpr basic_simd(R&& r, simd_flags<Flags...> = {});
+  constexpr basic_simd(R&& r, flags<Flags...> = {});
 template<class R, class... Flags>
-  constexpr basic_simd(R&& r, const mask_type& mask, simd_flags<Flags...> = {});
+  constexpr basic_simd(R&& r, const mask_type& mask, flags<Flags...> = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17250,7 +17367,7 @@
  \item
    If the template parameter pack \tcode{Flags} contains
    \tcode{\exposid{aligned-flag}}, \tcode{ranges::data(range)} points to
-   storage aligned by \tcode{simd_alignment_v<basic_simd,
+   storage aligned by \tcode{alignment_v<basic_simd,
    ranges::range_value_t<R>>}.
  \item
    If the template parameter pack \tcode{Flags} contains
@@ -17617,7 +17734,7 @@
 
 \pnum
 \returns
-An object of type \tcode{rebind_simd_t<typename T::value_type, basic_simd>}
+An object of type \tcode{rebind_t<typename T::value_type, basic_simd>}
 where the $i^\text{th}$ element is initialized to the result of
 \tcode{\placeholder{cmplx-func}(operator[]($i$))} for all $i$ in the range
 \range{0}{size()}, where \placeholder{cmplx-func} is the corresponding function
@@ -17825,21 +17942,20 @@
 \begin{itemdecl}
 template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R>
-  constexpr V simd_unchecked_load(R&& r, simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(R&& r, flags<Flags...> f = {});
 template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R>
-  constexpr V simd_unchecked_load(R&& r, const typename V::mask_type& mask,
-    simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(R&& r, const typename V::mask_type& mask, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  constexpr V simd_unchecked_load(I first, iter_difference_t<I> n, simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  constexpr V simd_unchecked_load(I first, iter_difference_t<I> n,
-    const typename V::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask,
+                             flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  constexpr V simd_unchecked_load(I first, S last, simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  constexpr V simd_unchecked_load(I first, S last, const typename V::mask_type& mask,
-    simd_flags<Flags...> f = {});
+  constexpr V unchecked_load(I first, S last, const typename V::mask_type& mask,
+                             flags<Flags...> f = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17875,7 +17991,7 @@
 
 \pnum
 \effects
-Equivalent to: \tcode{return simd_partial_load<V>(r, mask, f);}
+Equivalent to: \tcode{return partial_load<V>(r, mask, f);}
 
 \pnum
 \remarks
@@ -17886,21 +18002,20 @@
 \begin{itemdecl}
 template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R>
-  constexpr V simd_partial_load(R&& r, simd_flags<Flags...> f = {});
+  constexpr V partial_load(R&& r, flags<Flags...> f = {});
 template<class V = @\seebelow@, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R>
-  constexpr V simd_partial_load(R&& r, const typename V::mask_type& mask,
-    simd_flags<Flags...> f = {});
+  constexpr V partial_load(R&& r, const typename V::mask_type& mask, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  constexpr V simd_partial_load(I first, iter_difference_t<I> n, simd_flags<Flags...> f = {});
+  constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  constexpr V simd_partial_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask,
-    simd_flags<Flags...> f = {});
+  constexpr V partial_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask,
+                           flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  constexpr V simd_partial_load(I first, S last, simd_flags<Flags...> f = {});
+  constexpr V partial_load(I first, S last, flags<Flags...> f = {});
 template<class V = @\seebelow@, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  constexpr V simd_partial_load(I first, S last, const typename V::mask_type& mask,
-    simd_flags<Flags...> f = {});
+  constexpr V partial_load(I first, S last, const typename V::mask_type& mask,
+                           flags<Flags...> f = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -17947,7 +18062,7 @@
  \item
    If the template parameter pack \tcode{Flags} contains
    \tcode{\exposid{aligned-flag}}, \tcode{ranges::data(r)} points to storage
-   aligned by \tcode{simd_alignment_v<V, ranges::range_value_t<R>>}.
+   aligned by \tcode{alignment_v<V, ranges::range_value_t<R>>}.
  \item
    If the template parameter pack \tcode{Flags} contains
    \tcode{\exposid{overaligned-flag}<N>}, \tcode{ranges::data(r)} points to
@@ -17970,28 +18085,27 @@
 \begin{itemdecl}
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, R&& r,
-    simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, R&& r, flags<Flags...> f = {});
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, R&& r,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, R&& r,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-    simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
+                                 flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
-    simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
+                                 flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void unchecked_store(const basic_simd<T, Abi>& v, I first, S last,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18030,34 +18144,33 @@
 
 \pnum
 \effects
-Equivalent to: \tcode{simd_partial_store(v, r, mask, f)}.
+Equivalent to: \tcode{partial_store(v, r, mask, f)}.
 \end{itemdescr}
 
 \begin{itemdecl}
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, R&& r,
-    simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, R&& r, flags<Flags...> f = {});
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
   requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, R&& r,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, R&& r,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-    simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
+                               flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, I first, iter_difference_t<I> n,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, S last,
-    simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, I first, S last,
+                               flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
   requires @\libconcept{indirectly_writable}@<I, T>
-  constexpr void simd_partial_store(const basic_simd<T, Abi>& v, I first, S last,
-    const typename basic_simd<T, Abi>::mask_type& mask, simd_flags<Flags...> f = {});
+  constexpr void partial_store(const basic_simd<T, Abi>& v, I first, S last,
+    const typename basic_simd<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18099,7 +18212,7 @@
  \item
    If the template parameter pack \tcode{Flags} contains
    \tcode{\exposid{aligned-flag}}, \tcode{ranges::data(r)} points to storage
-   aligned by \tcode{simd_alignment_v<basic_simd<T, Abi>,
+   aligned by \tcode{alignment_v<basic_simd<T, Abi>,
    ranges::range_value_t<R>>}.
  \item
    If the template parameter pack \tcode{Flags} contains
@@ -18118,9 +18231,9 @@
 
 \begin{itemdecl}
 template<class T, class Abi>
-  constexpr auto simd_chunk(const basic_simd<typename T::value_type, Abi>& x) noexcept;
+  constexpr auto chunk(const basic_simd<typename T::value_type, Abi>& x) noexcept;
 template<class T, class Abi>
-  constexpr auto simd_chunk(const basic_simd_mask<@\exposid{mask-element-size}@<T>, Abi>& x) noexcept;
+  constexpr auto chunk(const basic_simd_mask<@\exposid{mask-element-size}@<T>, Abi>& x) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18132,7 +18245,7 @@
    \tcode{basic_simd}.
    If \tcode{basic_simd<\brk{}typename T::\brk{}value_type, Abi>::size() \%
    T::size()} is not \tcode{0} then
-   \tcode{resize_simd_t<basic_simd<\brk{}typename T::\brk{}value_type, Abi>::size()
+   \tcode{resize_t<basic_simd<\brk{}typename T::\brk{}value_type, Abi>::size()
    \% T::size(), T>} is valid and denotes a type.
 
  \item
@@ -18140,7 +18253,7 @@
    \tcode{basic_simd\-_\-mask}.
    If \tcode{basic_simd_mask<\exposid{mask-element-size}<T>, Abi>::size() \%
    T::size()} is not \tcode{0} then
-   \tcode{resize_simd_t<\brk{}ba\-sic\-_\-simd_mask<\brk{}\exposid{mask-element-size}<T>,
+   \tcode{resize_t<\brk{}ba\-sic\-_\-simd_mask<\brk{}\exposid{mask-element-size}<T>,
    Abi>::size() \% T::size(), T>} is valid and denotes a type.
 \end{itemize}
 
@@ -18158,7 +18271,7 @@
 
  \item
    Otherwise, a \tcode{tuple} of $N$ objects of type \tcode{T} and one object
-   of type \tcode{resize_simd_t<x.size() \% T::size(), T>}.
+   of type \tcode{resize_t<x.size() \% T::size(), T>}.
    The $i^\text{th}$ \tcode{basic_simd} or \tcode{basic_simd_mask} element of
    the $j^\text{th}$ \tcode{tuple} element of type \tcode{T} is initialized to
    the value of the element in \tcode{x} with index \tcode{$i$ + $j$ *
@@ -18171,40 +18284,34 @@
 
 \begin{itemdecl}
 template<size_t N, class T, class Abi>
-  constexpr auto simd_chunk(const basic_simd<T, Abi>& x) noexcept;
+  constexpr auto chunk(const basic_simd<T, Abi>& x) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to:
-\begin{codeblock}
-return simd_chunk<resize_simd_t<N, basic_simd<T, Abi>>>(x);
-\end{codeblock}
+Equivalent to: \tcode{return chunk<resize_t<N, basic_simd<T, Abi>>>(x);}
 \end{itemdescr}
 
 \begin{itemdecl}
 template<size_t N, size_t Bytes, class Abi>
-  constexpr auto simd_chunk(const basic_simd_mask<Bytes, Abi>& x) noexcept;
+  constexpr auto chunk(const basic_simd_mask<Bytes, Abi>& x) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \effects
-Equivalent to:
-\begin{codeblock}
-return simd_chunk<resize_simd_t<N, basic_simd_mask<Bytes, Abi>>>(x);
-\end{codeblock}
+Equivalent to: \tcode{return chunk<resize_t<N, basic_simd_mask<Bytes, Abi>>>(x);}
 \end{itemdescr}
 
 \begin{itemdecl}
 template<class T, class... Abis>
   constexpr simd<T, (basic_simd<T, Abis>::size() + ...)>
-    simd_cat(const basic_simd<T, Abis>&... xs) noexcept;
+    cat(const basic_simd<T, Abis>&... xs) noexcept;
 template<size_t Bytes, class... Abis>
   constexpr basic_simd_mask<Bytes, @\exposid{deduce-abi-t}@<@\exposid{integer-from}@<Bytes>,
                             (basic_simd_mask<Bytes, Abis>::size() + ...)>>
-    simd_cat(const basic_simd_mask<Bytes, Abis>&... xs) noexcept;
+    cat(const basic_simd_mask<Bytes, Abis>&... xs) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18303,7 +18410,7 @@
 
 \begin{itemdecl}
 template<class T, class U>
-  constexpr auto simd_select(bool c, const T& a, const U& b)
+  constexpr auto select(bool c, const T& a, const U& b)
   -> remove_cvref_t<decltype(c ? a : b)>;
 \end{itemdecl}
 
@@ -18315,7 +18422,7 @@
 
 \begin{itemdecl}
 template<size_t Bytes, class Abi, class T, class U>
-  constexpr auto simd_select(const basic_simd_mask<Bytes, Abi>& c, const T& a, const U& b)
+  constexpr auto select(const basic_simd_mask<Bytes, Abi>& c, const T& a, const U& b)
   noexcept -> decltype(@\exposid{simd-select-impl}@(c, a, b));
 \end{itemdecl}
 
@@ -18334,14 +18441,14 @@
 
 \begin{itemdecl}
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>> ilogb(const V& x);
+  constexpr rebind_t<int, @\exposid{deduced-simd-t}@<V>> ilogb(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr @\exposid{deduced-simd-t}@<V> ldexp(const V& x, const rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>& exp);
+  constexpr @\exposid{deduced-simd-t}@<V> ldexp(const V& x, const rebind_t<int, @\exposid{deduced-simd-t}@<V>>& exp);
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr @\exposid{deduced-simd-t}@<V> scalbn(const V& x, const rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>& n);
+  constexpr @\exposid{deduced-simd-t}@<V> scalbn(const V& x, const rebind_t<int, @\exposid{deduced-simd-t}@<V>>& n);
 template<@\exposconcept{math-floating-point}@ V>
   constexpr @\exposid{deduced-simd-t}@<V>
-    scalbln(const V& x, const rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>>& n);
+    scalbln(const V& x, const rebind_t<long int, @\exposid{deduced-simd-t}@<V>>& n);
 template<@\libconcept{signed_integral}@ T, class Abi>
   constexpr basic_simd<T, Abi> abs(const basic_simd<T, Abi>& j);
 template<@\exposconcept{math-floating-point}@ V>
@@ -18357,15 +18464,15 @@
 template<@\exposconcept{math-floating-point}@ V>
   @\exposid{deduced-simd-t}@<V> rint(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>> lrint(const V& x);
+  rebind_t<long int, @\exposid{deduced-simd-t}@<V>> lrint(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  rebind_simd_t<long long int, @\exposid{deduced-simd-t}@<V>> llrint(const V& x);
+  rebind_t<long long int, @\exposid{deduced-simd-t}@<V>> llrint(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
   constexpr @\exposid{deduced-simd-t}@<V> round(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr rebind_simd_t<long int, @\exposid{deduced-simd-t}@<V>> lround(const V& x);
+  constexpr rebind_t<long int, @\exposid{deduced-simd-t}@<V>> lround(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr rebind_simd_t<long long int, @\exposid{deduced-simd-t}@<V>> llround(const V& x);
+  constexpr rebind_t<long long int, @\exposid{deduced-simd-t}@<V>> llround(const V& x);
 template<class V0, class V1>
   constexpr @\exposid{math-common-simd-t}@<V0, V1> fmod(const V0& x, const V1& y);
 template<@\exposconcept{math-floating-point}@ V>
@@ -18385,7 +18492,7 @@
 template<class V0, class V1, class V2>
   constexpr @\exposid{math-common-simd-t}@<V0, V1, V2> fma(const V0& x, const V1& y, const V2& z);
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>> fpclassify(const V& x);
+  constexpr rebind_t<int, @\exposid{deduced-simd-t}@<V>> fpclassify(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
   constexpr typename @\exposid{deduced-simd-t}@<V>::mask_type isfinite(const V& x);
 template<@\exposconcept{math-floating-point}@ V>
@@ -18477,12 +18584,12 @@
 template<class V0, class V1, class V2>
   constexpr @\exposid{math-common-simd-t}@<V0, V1, V2> lerp(const V0& a, const V1& b, const V2& t) noexcept;
 template<@\exposconcept{math-floating-point}@ V>
-  @\exposid{deduced-simd-t}@<V> assoc_laguerre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const
-    rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
+  @\exposid{deduced-simd-t}@<V> assoc_laguerre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& n, const
+    rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
                    const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  @\exposid{deduced-simd-t}@<V> assoc_legendre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const
-    rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
+  @\exposid{deduced-simd-t}@<V> assoc_legendre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l, const
+    rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
                    const V& x);
 template<class V0, class V1>
   @\exposid{math-common-simd-t}@<V0, V1> beta(const V0& x, const V1& y);
@@ -18505,20 +18612,20 @@
 template<class V0, class V1, class V2>
   @\exposid{math-common-simd-t}@<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi);
 template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> expint(const V& x);
-template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> hermite(const rebind_simd_t<unsigned,
+template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> hermite(const rebind_t<unsigned,
 @\exposid{deduced-simd-t}@<V>>& n, const V& x);
-template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> laguerre(const rebind_simd_t<unsigned,
+template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> laguerre(const rebind_t<unsigned,
 @\exposid{deduced-simd-t}@<V>>& n, const V& x);
-template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> legendre(const rebind_simd_t<unsigned,
+template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> legendre(const rebind_t<unsigned,
 @\exposid{deduced-simd-t}@<V>>& l, const V& x);
 template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> riemann_zeta(const V& x);
-template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> sph_bessel(const rebind_simd_t<unsigned,
+template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> sph_bessel(const rebind_t<unsigned,
 @\exposid{deduced-simd-t}@<V>>& n, const V& x);
 template<@\exposconcept{math-floating-point}@ V>
-  @\exposid{deduced-simd-t}@<V> sph_legendre(const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l,
-                                 const rebind_simd_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
+  @\exposid{deduced-simd-t}@<V> sph_legendre(const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& l,
+                                 const rebind_t<unsigned, @\exposid{deduced-simd-t}@<V>>& m,
                                  const V& theta);
-template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> sph_neumann(const rebind_simd_t<unsigned,
+template<@\exposconcept{math-floating-point}@ V> @\exposid{deduced-simd-t}@<V> sph_neumann(const rebind_t<unsigned,
 @\exposid{deduced-simd-t}@<V>>& n, const V& x);
 \end{itemdecl}
 
@@ -18552,7 +18659,7 @@
 
 \begin{itemdecl}
 template<@\exposconcept{math-floating-point}@ V>
-  constexpr @\exposid{deduced-simd-t}@<V> frexp(const V& value, rebind_simd_t<int, @\exposid{deduced-simd-t}@<V>>* exp);
+  constexpr @\exposid{deduced-simd-t}@<V> frexp(const V& value, rebind_t<int, @\exposid{deduced-simd-t}@<V>>* exp);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18561,15 +18668,15 @@
 Let \placeholder{frexp-simd} denote:
 \begin{codeblock}
 template<class V>
-pair<Ret, rebind_simd_t<int, Ret>> @\placeholder{frexp-simd}@(const V& x) {
+pair<Ret, rebind_t<int, Ret>> @\placeholder{frexp-simd}@(const V& x) {
   int r1[Ret::size()];
   Ret r0([&](@\exposid{simd-size-type}@ i) {
     frexp(@\exposid{make-compatible-simd-t}@<Ret, V>(x)[i], &r1[i]);
   });
-  return {r0, rebind_simd_t<int, Ret>(r1)};
+  return {r0, rebind_t<int, Ret>(r1)};
 }
 \end{codeblock}
-Let \tcode{ret} be a value of type \tcode{pair<Ret, rebind_simd_t<int, Ret>>}
+Let \tcode{ret} be a value of type \tcode{pair<Ret, rebind_t<int, Ret>>}
 that is the same value as the result of calling
 \placeholder{frexp-simd}\tcode{(x)}.
 
@@ -18585,7 +18692,7 @@
 \begin{itemdecl}
 template<class V0, class V1>
   constexpr @\exposid{math-common-simd-t}@<V0, V1> remquo(const V0& x, const V1& y,
-                                              rebind_simd_t<int, @\exposid{math-common-simd-t}@<V0, V1>>* quo);
+                                              rebind_t<int, @\exposid{math-common-simd-t}@<V0, V1>>* quo);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18594,16 +18701,16 @@
 Let \placeholder{remquo-simd} denote:
 \begin{codeblock}
 template<class V0, class V1>
-pair<Ret, rebind_simd_t<int, Ret>> @\placeholder{remquo-simd}@(const V0& x, const V1& y) {
+pair<Ret, rebind_t<int, Ret>> @\placeholder{remquo-simd}@(const V0& x, const V1& y) {
   int r1[Ret::size()];
   Ret r0([&](@\exposid{simd-size-type}@ i) {
     remquo(@\exposid{make-compatible-simd-t}@<Ret, V0>(x)[i],
            @\exposid{make-compatible-simd-t}@<Ret, V1>(y)[i], &r1[i]);
   });
-  return {r0, rebind_simd_t<int, Ret>(r1)};
+  return {r0, rebind_t<int, Ret>(r1)};
 }
 \end{codeblock}
-Let \tcode{ret} be a value of type \tcode{pair<Ret, rebind_simd_t<int, Ret>>}
+Let \tcode{ret} be a value of type \tcode{pair<Ret, rebind_t<int, Ret>>}
 that is the same value as the result of calling
 \placeholder{remquo-simd}\tcode{(x, y)}.
 If in an invocation of a scalar overload of \tcode{remquo} for index \tcode{i}
@@ -18781,23 +18888,17 @@
 
 \begin{itemdecl}
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  bit_width(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept;
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  countl_zero(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept;
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  countl_one(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept;
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  countr_zero(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept;
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  countr_one(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept;
 template<@\exposconcept{simd-type}@ V>
-  constexpr rebind_simd_t<make_signed_t<typename V::value_type>, V>
-  popcount(const V& v) noexcept;
+  constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -18817,16 +18918,16 @@
 
 \begin{itemdecl}
 template<@\exposconcept{simd-complex}@ V>
-  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
+  constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> real(const V&) noexcept;
 template<@\exposconcept{simd-complex}@ V>
-  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
+  constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> imag(const V&) noexcept;
 
 template<@\exposconcept{simd-complex}@ V>
-  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
+  constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> abs(const V&);
 template<@\exposconcept{simd-complex}@ V>
-  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
+  constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> arg(const V&);
 template<@\exposconcept{simd-complex}@ V>
-  constexpr rebind_simd_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
+  constexpr rebind_t<@\exposid{simd-complex-value-type<V>}@, V> norm(const V&);
 template<@\exposconcept{simd-complex}@ V> constexpr V conj(const V&);
 template<@\exposconcept{simd-complex}@ V> constexpr V proj(const V&);
 
@@ -18866,7 +18967,7 @@
 
 \begin{itemdecl}
 template<@\exposconcept{simd-floating-point}@ V>
-  rebind_simd_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
+  rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
 
 template<@\exposconcept{simd-complex}@ V> constexpr V pow(const V& x, const V& y);
 \end{itemdecl}
@@ -18891,7 +18992,7 @@
 \rSec3[simd.mask.overview]{Class template \tcode{basic_simd_mask} overview}
 
 \begin{codeblock}
-namespace std {
+namespace std::datapar {
   template<size_t Bytes, class Abi> class basic_simd_mask {
   public:
     using value_type = bool;