cppdraft_translate/cppdraft/simd/syn.md

[simd.syn]

29 Numerics library [numerics]

29.10 Data-parallel types [simd]

29.10.3 Header synopsis [simd.syn]

🔗

namespace std::simd {// [simd.traits], type traitstemplate<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 = typename 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 = typename resize<N, V>::type; // [simd.flags], load and store flagstemplate<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> flag_overaligned{}; // [simd.iterator], class template simd-iteratortemplateclass simd-iterator; // exposition only// [simd.class], class template basic_vectemplate<class T, class Abi = native-abi> class basic_vec; template<class T, simd-size-type N = simd-size-v<T, native-abi>>using vec = basic_vec<T, deduce-abi-t<T, N>>; // [simd.mask.class], class template basic_masktemplate<size_t Bytes, class Abi = native-abi<integer-from>> class basic_mask; template<class T, simd-size-type N = simd-size-v<T, native-abi>>using mask = basic_mask<sizeof(T), deduce-abi-t<T, N>>; // [simd.loadstore], basic_vec load and store functionstemplate<class V = see below, ranges::contiguous_range R, class... Flags>requires ranges::sized_rangeconstexpr V unchecked_load(R&& r, flags<Flags...> f = {}); template<class V = see below, ranges::contiguous_range R, class... Flags>requires ranges::sized_rangeconstexpr 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 n, flags<Flags...> f = {}); template<class V = see below, contiguous_iterator I, class... Flags>constexpr V unchecked_load(I first, iter_difference_t n, const typename V::mask_type& k, flags<Flags...> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for 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 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_rangeconstexpr V partial_load(R&& r, flags<Flags...> f = {}); template<class V = see below, ranges::contiguous_range R, class... Flags>requires ranges::sized_rangeconstexpr 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 n, flags<Flags...> f = {}); template<class V = see below, contiguous_iterator I, class... Flags>constexpr V partial_load(I first, iter_difference_t n, const typename V::mask_type& k, flags<Flags...> f = {}); template<class V = see below, contiguous_iterator I, sized_sentinel_for 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 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 && indirectly_writable<ranges::iterator_t, 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 && indirectly_writable<ranges::iterator_t, 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 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 n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for 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 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 && indirectly_writable<ranges::iterator_t, 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 && indirectly_writable<ranges::iterator_t, 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 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 n, const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {}); template<class T, class Abi, contiguous_iterator I, sized_sentinel_for 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 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], permute by static index generatorstatic constexpr simd-size-type zero_element = implementation-defined; static constexpr simd-size-type uninit_element = implementation-defined; 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], permute by dynamic indextemplate<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], permute by active mask bitstemplate<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& 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& 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& selector, const M& original = {}); // [simd.permute.memory], permute to and from memorytemplate<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>requires ranges::sized_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr 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_rangeconstexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask, const I& indices, flags<Flags...> f = {}); // [simd.creation], basic_vec and basic_mask creationtemplate<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, 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, (basic_mask<Bytes, Abis>::size() + ...)>> cat(const basic_mask<Bytes, Abis>&...) noexcept; // [simd.mask.reductions], basic_mask reductionstemplate<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 auto) noexcept; constexpr bool any_of(same_as auto) noexcept; constexpr bool none_of(same_as auto) noexcept; constexpr simd-size-type reduce_count(same_as auto) noexcept; constexpr simd-size-type reduce_min_index(same_as auto); constexpr simd-size-type reduce_max_index(same_as auto); // [simd.reductions], basic_vec reductionstemplate<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 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.alg], algorithmstemplate<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 functionstemplate<math-floating-point V> constexpr deduced-vec-t acos(const V& x); template<math-floating-point V> constexpr deduced-vec-t asin(const V& x); template<math-floating-point V> constexpr deduced-vec-t 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 cos(const V& x); template<math-floating-point V> constexpr deduced-vec-t sin(const V& x); template<math-floating-point V> constexpr deduced-vec-t tan(const V& x); template<math-floating-point V> constexpr deduced-vec-t acosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t asinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t atanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t cosh(const V& x); template<math-floating-point V> constexpr deduced-vec-t sinh(const V& x); template<math-floating-point V> constexpr deduced-vec-t tanh(const V& x); template<math-floating-point V> constexpr deduced-vec-t exp(const V& x); template<math-floating-point V> constexpr deduced-vec-t exp2(const V& x); template<math-floating-point V> constexpr deduced-vec-t expm1(const V& x); template<math-floating-point V>constexpr deduced-vec-t frexp(const V& value, rebind_t<int, deduced-vec-t>* exp); template<math-floating-point V>constexpr rebind_t<int, deduced-vec-t> ilogb(const V& x); template<math-floating-point V>constexpr deduced-vec-t ldexp(const V& x, const rebind_t<int, deduced-vec-t>& exp); template<math-floating-point V> constexpr deduced-vec-t log(const V& x); template<math-floating-point V> constexpr deduced-vec-t log10(const V& x); template<math-floating-point V> constexpr deduced-vec-t log1p(const V& x); template<math-floating-point V> constexpr deduced-vec-t log2(const V& x); template<math-floating-point V> constexpr deduced-vec-t 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 scalbn(const V& x, const rebind_t<int, deduced-vec-t>& n); template<math-floating-point V>constexpr deduced-vec-t scalbln(const V& x, const rebind_t<long int, deduced-vec-t>& n); template<math-floating-point V> constexpr deduced-vec-t 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 abs(const V& j); template<math-floating-point V> constexpr deduced-vec-t 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 sqrt(const V& x); template<math-floating-point V> constexpr deduced-vec-t erf(const V& x); template<math-floating-point V> constexpr deduced-vec-t erfc(const V& x); template<math-floating-point V> constexpr deduced-vec-t lgamma(const V& x); template<math-floating-point V> constexpr deduced-vec-t tgamma(const V& x); template<math-floating-point V> constexpr deduced-vec-t ceil(const V& x); template<math-floating-point V> constexpr deduced-vec-t floor(const V& x); template<math-floating-point V> deduced-vec-t nearbyint(const V& x); template<math-floating-point V> deduced-vec-t rint(const V& x); template<math-floating-point V> rebind_t<long int, deduced-vec-t> lrint(const V& x); template<math-floating-point V> rebind_t<long long int, V> llrint(const deduced-vec-t& x); template<math-floating-point V>constexpr deduced-vec-t round(const V& x); template<math-floating-point V>constexpr rebind_t<long int, deduced-vec-t> lround(const V& x); template<math-floating-point V>constexpr rebind_t<long long int, deduced-vec-t> llround(const V& x); template<math-floating-point V>constexpr deduced-vec-t 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> fpclassify(const V& x); template<math-floating-point V>constexpr typename deduced-vec-t::mask_type isfinite(const V& x); template<math-floating-point V>constexpr typename deduced-vec-t::mask_type isinf(const V& x); template<math-floating-point V>constexpr typename deduced-vec-t::mask_type isnan(const V& x); template<math-floating-point V>constexpr typename deduced-vec-t::mask_type isnormal(const V& x); template<math-floating-point V>constexpr typename deduced-vec-t::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 assoc_laguerre(const rebind_t<unsigned, deduced-vec-t>& n, const rebind_t<unsigned, deduced-vec-t>& m, const V& x); template<math-floating-point V>deduced-vec-t assoc_legendre(const rebind_t<unsigned, deduced-vec-t>& l, const rebind_t<unsigned, deduced-vec-t>& 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 comp_ellint_1(const V& k); template<math-floating-point V> deduced-vec-t 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 expint(const V& x); template<math-floating-point V>deduced-vec-t hermite(const rebind_t<unsigned, deduced-vec-t>& n, const V& x); template<math-floating-point V>deduced-vec-t laguerre(const rebind_t<unsigned, deduced-vec-t>& n, const V& x); template<math-floating-point V>deduced-vec-t legendre(const rebind_t<unsigned, deduced-vec-t>& l, const V& x); template<math-floating-point V>deduced-vec-t riemann_zeta(const V& x); template<math-floating-point V>deduced-vec-t sph_bessel(const rebind_t<unsigned, deduced-vec-t>& n, const V& x); template<math-floating-point V>deduced-vec-t sph_legendre(const rebind_t<unsigned, deduced-vec-t>& l, const rebind_t<unsigned, deduced-vec-t>& m, const V& theta); template<math-floating-point V>deduced-vec-t sph_neumann(const rebind_t<unsigned, deduced-vec-t>& n, const V& x); // [simd.bit], bit manipulationtemplate<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, V> bit_width(const V& v) noexcept; template<simd-vec-type V>constexpr rebind_t<make_signed_t, V> countl_zero(const V& v) noexcept; template<simd-vec-type V>constexpr rebind_t<make_signed_t, V> countl_one(const V& v) noexcept; template<simd-vec-type V>constexpr rebind_t<make_signed_t, V> countr_zero(const V& v) noexcept; template<simd-vec-type V>constexpr rebind_t<make_signed_t, V> countr_one(const V& v) noexcept; template<simd-vec-type V>constexpr rebind_t<make_signed_t, V> popcount(const V& v) noexcept; // [simd.complex.math], vec complex mathtemplate<simd-complex V>constexpr rebind_t<simd-complex-value-type, V> real(const V&) noexcept; template<simd-complex V>constexpr rebind_t<simd-complex-value-type, V> imag(const V&) noexcept; template<simd-complex V>constexpr rebind_t<simd-complex-value-type, V> abs(const V&); template<simd-complex V>constexpr rebind_t<simd-complex-value-type, V> arg(const V&); template<simd-complex V>constexpr rebind_t<simd-complex-value-type, 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, V> polar(const V& x, const V& y = {}); template<simd-complex V> constexpr V pow(const V& x, const V& y);}namespace std {// See [simd.alg], algorithmsusing simd::min; using simd::max; using simd::minmax; using simd::clamp; // See [simd.math], mathematical functionsusing 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 manipulationusing 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 mathusing simd::real; using simd::imag; using simd::arg; using simd::norm; using simd::conj; using simd::proj; using simd::polar;}