[simd.syn] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpma5s3ww5/{from.md → to.md} +646 -0

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

	@@ -0,0 +1,646 @@

+### Header `<simd>` synopsis <a id="simd.syn">[[simd.syn]]</a>
+``` cpp
+namespace std::simd {
+  // [simd.traits], type traits
+  template<class T, class U = typename T::value_type> struct alignment;
+  template<class T, class U = typename T::value_type>
+    constexpr size_t alignment_v = alignment<T, U>::value;
+  template<class T, class V> struct rebind { using type = see below; };
+  template<class T, class V> using rebind_t = rebind<T, V>::type;
+  template<simd-size-type N, class V> struct resize { using type = see below; };
+  template<simd-size-type N, class V> using resize_t = resize<N, V>::type;
+  // [simd.flags], load and store flags
+  template<class... Flags> struct flags;
+  inline constexpr flags<> flag_default{};
+  inline constexpr flags<convert-flag> flag_convert{};
+  inline constexpr flags<aligned-flag> flag_aligned{};
+  template<size_t N> requires (has_single_bit(N))
+    constexpr flags<overaligned-flag<N>> flag_overaligned{};
+  // [simd.iterator], class template simd-iterator
+  template<class V>
+    class simd-iterator;                // exposition only
+  // [simd.class], class template basic_vec
+  template<class T, class Abi = native-abi<T>> class basic_vec;
+  template<class T, simd-size-type N = simd-size-v<T, native-abi<T>>>
+    using vec = basic_vec<T, deduce-abi-t<T, N>>;
+  // [simd.reductions], reductions
+  template<class T, class Abi, class BinaryOperation = plus<>>
+    constexpr T reduce(const basic_vec<T, Abi>&, BinaryOperation = {});
+  template<class T, class Abi, class BinaryOperation = plus<>>
+    constexpr T reduce(
+      const basic_vec<T, Abi>& x, const typename basic_vec<T, Abi>::mask_type& mask,
+      BinaryOperation binary_op = {}, type_identity_t<T> identity_element = see below);
+  template<class T, class Abi>
+    constexpr T reduce_min(const basic_vec<T, Abi>&) noexcept;
+  template<class T, class Abi>
+    constexpr T reduce_min(const basic_vec<T, Abi>&,
+                           const typename basic_vec<T, Abi>::mask_type&) noexcept;
+  template<class T, class Abi>
+    constexpr T reduce_max(const basic_vec<T, Abi>&) noexcept;
+  template<class T, class Abi>
+    constexpr T reduce_max(const basic_vec<T, Abi>&,
+                           const typename basic_vec<T, Abi>::mask_type&) noexcept;
+  // [simd.loadstore], load and store functions
+  template<class V = see below, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V unchecked_load(R&& r, flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V unchecked_load(R&& r, const typename V::mask_type& k,
+                               flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, class... Flags>
+    constexpr V unchecked_load(I first, iter_difference_t<I> n,
+                               flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, class... Flags>
+    constexpr V unchecked_load(I first, iter_difference_t<I> n,
+                               const typename V::mask_type& k, flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    constexpr V unchecked_load(I first, S last, const typename V::mask_type& k,
+                               flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V partial_load(R&& r, flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V partial_load(R&& r, const typename V::mask_type& k,
+                             flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, class... Flags>
+    constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, class... Flags>
+    constexpr V partial_load(I first, iter_difference_t<I> n,
+                             const typename V::mask_type& k, flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    constexpr V partial_load(I first, S last, flags<Flags...> f = {});
+  template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    constexpr V partial_load(I first, S last, const typename V::mask_type& k,
+                             flags<Flags...> f = {});
+  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
+                                   flags<Flags...> f = {});
+  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
+      const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
+                                   iter_difference_t<I> n, flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
+      iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask,
+      flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
+                                   flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
+      const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
+  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
+    constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
+                                 flags<Flags...> f = {});
+  template<class T, class Abi, ranges::contiguous_range R, class... Flags>
+    requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
+    constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
+      const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void partial_store(
+      const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void partial_store(
+      const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
+      const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
+                                 flags<Flags...> f = {});
+  template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
+    requires indirectly_writable<I, T>
+    constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
+      const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
+  // [simd.permute.static], static permute
+  static constexpr simd-size-type zero_element   = implementation-defined  // value of simd::zero_element;
+  static constexpr simd-size-type uninit_element = implementation-defined  // value of simd::uninit_element;
+  template<simd-size-type N = see below, simd-vec-type V, class IdxMap>
+    constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap);
+  template<simd-size-type N = see below, simd-mask-type M, class IdxMap>
+    constexpr resize_t<N, M> permute(const M& v, IdxMap&& idxmap);
+  // [simd.permute.dynamic], dynamic permute
+  template<simd-vec-type V, simd-integral I>
+    constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);
+  template<simd-mask-type M, simd-integral I>
+    constexpr resize_t<I::size(), M> permute(const M& v, const I& indices);
+  // [simd.permute.mask], mask permute
+  template<simd-vec-type V>
+    constexpr V compress(const V& v, const typename V::mask_type& selector);
+  template<simd-mask-type M>
+    constexpr M compress(const M& v, const type_identity_t<M>& selector);
+  template<simd-vec-type V>
+    constexpr V compress(const V& v, const typename V::mask_type& selector,
+                         const typename V::value_type& fill_value);
+  template<simd-mask-type M>
+    constexpr M compress(const M& v, const type_identity_t<M>& selector,
+                         const typename M::value_type& fill_value);
+  template<simd-vec-type V>
+    constexpr V expand(const V& v, const typename V::mask_type& selector,
+                       const V& original = {});
+  template<simd-mask-type M>
+    constexpr M expand(const M& v, const type_identity_t<M>& selector,
+                       const M& original = {});
+  // [simd.permute.memory], memory permute
+  template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V unchecked_gather_from(R&& in, const typename I::mask_type& mask,
+                                      const I& indices, flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
+  template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask,
+                                    const I& indices, flags<Flags...> f = {});
+  template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr void unchecked_scatter_to(const V& v, R&& out,
+                                        const I& indices, flags<Flags...> f = {});
+  template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr void unchecked_scatter_to(const V& v, R&& out, const typename I::mask_type& mask,
+                                        const I& indices, flags<Flags...> f = {});
+  template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr void partial_scatter_to(const V& v, R&& out,
+                                      const I& indices, flags<Flags...> f = {});
+  template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
+    requires ranges::sized_range<R>
+    constexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask,
+                                      const I& indices, flags<Flags...> f = {});
+  // [simd.creation], creation
+  template<class T, class Abi>
+    constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept;
+  template<class T, class Abi>
+    constexpr auto chunk(const basic_mask<mask-element-size<T>, Abi>& x) noexcept;
+  template<simd-size-type N, class T, class Abi>
+    constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;
+  template<simd-size-type N, size_t Bytes, class Abi>
+    constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept;
+  template<class T, class... Abis>
+    constexpr basic_vec<T, deduce-abi-t<T, (basic_vec<T, Abis>::size() + ...)>>
+      cat(const basic_vec<T, Abis>&...) noexcept;
+  template<size_t Bytes, class... Abis>
+    constexpr basic_mask<Bytes, deduce-abi-t<integer-from<Bytes>,
+                              (basic_mask<Bytes, Abis>::size() + ...)>>
+      cat(const basic_mask<Bytes, Abis>&...) noexcept;
+  // [simd.alg], algorithms
+  template<class T, class Abi>
+    constexpr basic_vec<T, Abi>
+      min(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    constexpr basic_vec<T, Abi>
+      max(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>>
+      minmax(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
+  template<class T, class Abi>
+    constexpr basic_vec<T, Abi>
+      clamp(const basic_vec<T, Abi>& v, const basic_vec<T, Abi>& lo,
+            const basic_vec<T, Abi>& hi);
+  template<class T, class U>
+    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 select(const basic_mask<Bytes, Abi>& c, const T& a, const U& b)
+    noexcept -> decltype(simd-select-impl(c, a, b));
+  // [simd.math], mathematical functions
+  template<math-floating-point V> constexpr deduced-vec-t<V> acos(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> asin(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> atan(const V& x);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> atan2(const V0& y, const V1& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> cos(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> sin(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> tan(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> acosh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> asinh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> atanh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> cosh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> sinh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> tanh(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> exp(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> exp2(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> expm1(const V& x);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V>
+      frexp(const V& value, rebind_t<int, deduced-vec-t<V>>* exp);
+  template<math-floating-point V>
+    constexpr rebind_t<int, deduced-vec-t<V>> ilogb(const V& x);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V> ldexp(const V& x, const rebind_t<int, deduced-vec-t<V>>& exp);
+  template<math-floating-point V> constexpr deduced-vec-t<V> log(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> log10(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> log1p(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> log2(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> logb(const V& x);
+  template<class T, class Abi>
+    constexpr basic_vec<T, Abi>
+      modf(const type_identity_t<basic_vec<T, Abi>>& value, basic_vec<T, Abi>* iptr);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V> scalbn(const V& x, const rebind_t<int, deduced-vec-t<V>>& n);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V> scalbln(
+      const V& x, const rebind_t<long int, deduced-vec-t<V>>& n);
+  template<math-floating-point V> constexpr deduced-vec-t<V> cbrt(const V& x);
+  template<signed_integral T, class Abi>
+    constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j);
+  template<math-floating-point V> constexpr deduced-vec-t<V> abs(const V& j);
+  template<math-floating-point V> constexpr deduced-vec-t<V> fabs(const V& x);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> hypot(const V0& x, const V1& y);
+  template<class V0, class V1, class V2>
+    constexpr math-common-simd-t<V0, V1, V2> hypot(const V0& x, const V1& y, const V2& z);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> pow(const V0& x, const V1& y);
+  template<math-floating-point V> constexpr deduced-vec-t<V> sqrt(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> erf(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> erfc(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> lgamma(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> tgamma(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> ceil(const V& x);
+  template<math-floating-point V> constexpr deduced-vec-t<V> floor(const V& x);
+  template<math-floating-point V> deduced-vec-t<V> nearbyint(const V& x);
+  template<math-floating-point V> deduced-vec-t<V> rint(const V& x);
+  template<math-floating-point V>
+    rebind_t<long int, deduced-vec-t<V>> lrint(const V& x);
+  template<math-floating-point V>
+    rebind_t<long long int, V> llrint(const deduced-vec-t<V>& x);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V> round(const V& x);
+  template<math-floating-point V>
+    constexpr rebind_t<long int, deduced-vec-t<V>> lround(const V& x);
+  template<math-floating-point V>
+    constexpr rebind_t<long long int, deduced-vec-t<V>> llround(const V& x);
+  template<math-floating-point V>
+    constexpr deduced-vec-t<V> trunc(const V& x);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> fmod(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> remainder(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1>
+      remquo(const V0& x, const V1& y, rebind_t<int, math-common-simd-t<V0, V1>>* quo);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> copysign(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> nextafter(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> fdim(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> fmax(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr math-common-simd-t<V0, V1> fmin(const V0& x, const V1& y);
+  template<class V0, class V1, class V2>
+    constexpr math-common-simd-t<V0, V1, V2> fma(const V0& x, const V1& y, const V2& z);
+  template<class V0, class V1, class V2>
+    constexpr math-common-simd-t<V0, V1, V2>
+      lerp(const V0& a, const V1& b, const V2& t) noexcept;
+  template<math-floating-point V>
+    constexpr rebind_t<int, deduced-vec-t<V>> fpclassify(const V& x);
+  template<math-floating-point V>
+    constexpr typename deduced-vec-t<V>::mask_type isfinite(const V& x);
+  template<math-floating-point V>
+    constexpr typename deduced-vec-t<V>::mask_type isinf(const V& x);
+  template<math-floating-point V>
+    constexpr typename deduced-vec-t<V>::mask_type isnan(const V& x);
+  template<math-floating-point V>
+    constexpr typename deduced-vec-t<V>::mask_type isnormal(const V& x);
+  template<math-floating-point V>
+    constexpr typename deduced-vec-t<V>::mask_type signbit(const V& x);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      isgreater(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      isgreaterequal(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      isless(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      islessequal(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      islessgreater(const V0& x, const V1& y);
+  template<class V0, class V1>
+    constexpr typename math-common-simd-t<V0, V1>::mask_type
+      isunordered(const V0& x, const V1& y);
+  template<math-floating-point V>
+    deduced-vec-t<V> assoc_laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n,
+                                    const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> assoc_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l,
+                                    const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& x);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> beta(const V0& x, const V1& y);
+  template<math-floating-point V> deduced-vec-t<V> comp_ellint_1(const V& k);
+  template<math-floating-point V> deduced-vec-t<V> comp_ellint_2(const V& k);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> comp_ellint_3(const V0& k, const V1& nu);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> cyl_bessel_i(const V0& nu, const V1& x);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> cyl_bessel_j(const V0& nu, const V1& x);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> cyl_bessel_k(const V0& nu, const V1& x);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> cyl_neumann(const V0& nu, const V1& x);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> ellint_1(const V0& k, const V1& phi);
+  template<class V0, class V1>
+    math-common-simd-t<V0, V1> ellint_2(const V0& k, const V1& phi);
+  template<class V0, class V1, class V2>
+    math-common-simd-t<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi);
+  template<math-floating-point V> deduced-vec-t<V> expint(const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> hermite(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> riemann_zeta(const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> sph_bessel(
+      const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x);
+  template<math-floating-point V>
+    deduced-vec-t<V> sph_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l,
+      const rebind_t<unsigned, deduced-vec-t<V>>& m, const V& theta);
+  template<math-floating-point V>
+    deduced-vec-t<V>
+      sph_neumann(const rebind_t<unsigned, deduced-vec-t<V>>& n, const V& x);
+  // [simd.bit], bit manipulation
+  template<simd-vec-type V> constexpr V byteswap(const V& v) noexcept;
+  template<simd-vec-type V> constexpr V bit_ceil(const V& v) noexcept;
+  template<simd-vec-type V> constexpr V bit_floor(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr typename V::mask_type has_single_bit(const V& v) noexcept;
+  template<simd-vec-type V0, simd-vec-type V1>
+    constexpr V0 rotl(const V0& v, const V1& s) noexcept;
+  template<simd-vec-type V>
+    constexpr V  rotl(const V& v, int s) noexcept;
+  template<simd-vec-type V0, simd-vec-type V1>
+    constexpr V0 rotr(const V0& v, const V1& s) noexcept;
+  template<simd-vec-type V>
+    constexpr V  rotr(const V& v, int s) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      bit_width(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      countl_zero(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      countl_one(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      countr_zero(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      countr_one(const V& v) noexcept;
+  template<simd-vec-type V>
+    constexpr rebind_t<make_signed_t<typename V::value_type>, V>
+      popcount(const V& v) noexcept;
+  // [simd.complex.math], complex math
+  template<simd-complex V>
+    constexpr rebind_t<simd-complex-value-type<V>, V> real(const V&) noexcept;
+  template<simd-complex V>
+    constexpr rebind_t<simd-complex-value-type<V>, V> imag(const V&) noexcept;
+  template<simd-complex V>
+    constexpr rebind_t<simd-complex-value-type<V>, V> abs(const V&);
+  template<simd-complex V>
+    constexpr rebind_t<simd-complex-value-type<V>, V> arg(const V&);
+  template<simd-complex V>
+    constexpr rebind_t<simd-complex-value-type<V>, V> norm(const V&);
+  template<simd-complex V> constexpr V conj(const V&);
+  template<simd-complex V> constexpr V proj(const V&);
+  template<simd-complex V> constexpr V exp(const V& v);
+  template<simd-complex V> constexpr V log(const V& v);
+  template<simd-complex V> constexpr V log10(const V& v);
+  template<simd-complex V> constexpr V sqrt(const V& v);
+  template<simd-complex V> constexpr V sin(const V& v);
+  template<simd-complex V> constexpr V asin(const V& v);
+  template<simd-complex V> constexpr V cos(const V& v);
+  template<simd-complex V> constexpr V acos(const V& v);
+  template<simd-complex V> constexpr V tan(const V& v);
+  template<simd-complex V> constexpr V atan(const V& v);
+  template<simd-complex V> constexpr V sinh(const V& v);
+  template<simd-complex V> constexpr V asinh(const V& v);
+  template<simd-complex V> constexpr V cosh(const V& v);
+  template<simd-complex V> constexpr V acosh(const V& v);
+  template<simd-complex V> constexpr V tanh(const V& v);
+  template<simd-complex V> constexpr V atanh(const V& v);
+  template<simd-floating-point V>
+    rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
+  template<simd-complex V> constexpr V pow(const V& x, const V& y);
+  // [simd.mask.class], class template basic_mask
+  template<size_t Bytes, class Abi = native-abi<integer-from<Bytes>>> class basic_mask;
+  template<class T, simd-size-type N = simd-size-v<T, native-abi<T>>>
+    using mask = basic_mask<sizeof(T), deduce-abi-t<T, N>>;
+  // [simd.mask.reductions], reductions
+  template<size_t Bytes, class Abi>
+    constexpr bool all_of(const basic_mask<Bytes, Abi>&) noexcept;
+  template<size_t Bytes, class Abi>
+    constexpr bool any_of(const basic_mask<Bytes, Abi>&) noexcept;
+  template<size_t Bytes, class Abi>
+    constexpr bool none_of(const basic_mask<Bytes, Abi>&) noexcept;
+  template<size_t Bytes, class Abi>
+    constexpr simd-size-type reduce_count(const basic_mask<Bytes, Abi>&) noexcept;
+  template<size_t Bytes, class Abi>
+    constexpr simd-size-type reduce_min_index(const basic_mask<Bytes, Abi>&);
+  template<size_t Bytes, class Abi>
+    constexpr simd-size-type reduce_max_index(const basic_mask<Bytes, Abi>&);
+  constexpr bool all_of(same_as<bool> auto) noexcept;
+  constexpr bool any_of(same_as<bool> auto) noexcept;
+  constexpr bool none_of(same_as<bool> auto) noexcept;
+  constexpr simd-size-type reduce_count(same_as<bool> auto) noexcept;
+  constexpr simd-size-type reduce_min_index(same_as<bool> auto);
+  constexpr simd-size-type reduce_max_index(same_as<bool> auto);
+}
+namespace std {
+  // See [simd.alg], algorithms
+  using simd::min;
+  using simd::max;
+  using simd::minmax;
+  using simd::clamp;
+  // See [simd.math], mathematical functions
+  using simd::acos;
+  using simd::asin;
+  using simd::atan;
+  using simd::atan2;
+  using simd::cos;
+  using simd::sin;
+  using simd::tan;
+  using simd::acosh;
+  using simd::asinh;
+  using simd::atanh;
+  using simd::cosh;
+  using simd::sinh;
+  using simd::tanh;
+  using simd::exp;
+  using simd::exp2;
+  using simd::expm1;
+  using simd::frexp;
+  using simd::ilogb;
+  using simd::ldexp;
+  using simd::log;
+  using simd::log10;
+  using simd::log1p;
+  using simd::log2;
+  using simd::logb;
+  using simd::modf;
+  using simd::scalbn;
+  using simd::scalbln;
+  using simd::cbrt;
+  using simd::abs;
+  using simd::fabs;
+  using simd::hypot;
+  using simd::pow;
+  using simd::sqrt;
+  using simd::erf;
+  using simd::erfc;
+  using simd::lgamma;
+  using simd::tgamma;
+  using simd::ceil;
+  using simd::floor;
+  using simd::nearbyint;
+  using simd::rint;
+  using simd::lrint;
+  using simd::llrint;
+  using simd::round;
+  using simd::lround;
+  using simd::llround;
+  using simd::trunc;
+  using simd::fmod;
+  using simd::remainder;
+  using simd::remquo;
+  using simd::copysign;
+  using simd::nextafter;
+  using simd::fdim;
+  using simd::fmax;
+  using simd::fmin;
+  using simd::fma;
+  using simd::lerp;
+  using simd::fpclassify;
+  using simd::isfinite;
+  using simd::isinf;
+  using simd::isnan;
+  using simd::isnormal;
+  using simd::signbit;
+  using simd::isgreater;
+  using simd::isgreaterequal;
+  using simd::isless;
+  using simd::islessequal;
+  using simd::islessgreater;
+  using simd::isunordered;
+  using simd::assoc_laguerre;
+  using simd::assoc_legendre;
+  using simd::beta;
+  using simd::comp_ellint_1;
+  using simd::comp_ellint_2;
+  using simd::comp_ellint_3;
+  using simd::cyl_bessel_i;
+  using simd::cyl_bessel_j;
+  using simd::cyl_bessel_k;
+  using simd::cyl_neumann;
+  using simd::ellint_1;
+  using simd::ellint_2;
+  using simd::ellint_3;
+  using simd::expint;
+  using simd::hermite;
+  using simd::laguerre;
+  using simd::legendre;
+  using simd::riemann_zeta;
+  using simd::sph_bessel;
+  using simd::sph_legendre;
+  using simd::sph_neumann;
+  // See [simd.bit], bit manipulation
+  using simd::byteswap;
+  using simd::bit_ceil;
+  using simd::bit_floor;
+  using simd::has_single_bit;
+  using simd::rotl;
+  using simd::rotr;
+  using simd::bit_width;
+  using simd::countl_zero;
+  using simd::countl_one;
+  using simd::countr_zero;
+  using simd::countr_one;
+  using simd::popcount;
+  // See [simd.complex.math], vec complex math
+  using simd::real;
+  using simd::imag;
+  using simd::arg;
+  using simd::norm;
+  using simd::conj;
+  using simd::proj;
+  using simd::polar;
+}
+```

Diff to HTML by rtfpessoa