[simd.syn]

# 29 Numerics library [[numerics]](./#numerics)

## 29.10 Data-parallel types [[simd]](simd#syn)

### 29.10.3 Header <simd> synopsis [simd.syn]

[🔗](#header:%3csimd%3e)

namespace std::simd {// [[simd.traits]](simd.traits "29.10.4 Type 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](#lib:simd,alignment_v "29.10.3 Header <simd> synopsis [simd.syn]") = alignment<T, U>::value; template<class T, class V> struct rebind { using type = *see below*; }; template<class T, class V> using [rebind_t](#lib:simd,rebind_t "29.10.3 Header <simd> synopsis [simd.syn]") = 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](#lib:simd,resize_t "29.10.3 Header <simd> synopsis [simd.syn]") = typename resize<N, V>::type; // [[simd.flags]](simd.flags "29.10.5 Load and store flags"), load and store flagstemplate<class... Flags> struct flags; inline constexpr flags<> [flag_default](#lib:simd,flag_default "29.10.3 Header <simd> synopsis [simd.syn]"){}; inline constexpr flags<*convert-flag*> [flag_convert](#lib:simd,flag_convert "29.10.3 Header <simd> synopsis [simd.syn]"){}; inline constexpr flags<*aligned-flag*> [flag_aligned](#lib:simd,flag_aligned "29.10.3 Header <simd> synopsis [simd.syn]"){}; template<size_t N> requires (has_single_bit(N))constexpr flags<*overaligned-flag*<N>> [flag_overaligned](#lib:simd,flag_overaligned "29.10.3 Header <simd> synopsis [simd.syn]"){}; // [[simd.iterator]](simd.iterator "29.10.6 Class template simd-iterator"), class template *simd-iterator*template<class V>class *simd-iterator*; // *exposition only*// [[simd.class]](simd.class "29.10.7 Class template basic_­vec"), class template basic_vectemplate<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](#lib:simd,vec "29.10.3 Header <simd> synopsis [simd.syn]") = basic_vec<T, *deduce-abi-t*<T, N>>; // [[simd.mask.class]](simd.mask.class "29.10.9 Class template basic_­mask"), class template basic_masktemplate<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](#lib:simd,mask "29.10.3 Header <simd> synopsis [simd.syn]") = basic_mask<sizeof(T), *deduce-abi-t*<T, N>>; // [[simd.loadstore]](simd.loadstore "29.10.8.6 basic_­vec load and store functions"), basic_vec load and store functionstemplate<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V unchecked_load(R&& r, flags<Flags...> f = {}); template<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V unchecked_load(R&& r, const typename V::mask_type& k,
 flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>constexpr V unchecked_load(I first, iter_difference_t<I> n,
 flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") 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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>constexpr V unchecked_load(I first, S last, flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V partial_load(R&& r, flags<Flags...> f = {}); template<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V partial_load(R&& r, const typename V::mask_type& k,
 flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") 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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>constexpr V partial_load(I first, S last, flags<Flags...> f = {}); template<class V = *see below*, [contiguous_iterator](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R> && [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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](iterator.concept.contiguous#concept:contiguous_iterator "24.3.4.14 Concept contiguous_­iterator [iterator.concept.contiguous]") I, [sized_sentinel_for](iterator.concept.sizedsentinel#concept:sized_sentinel_for "24.3.4.8 Concept sized_­sentinel_­for [iterator.concept.sizedsentinel]")<I> S, class... Flags>requires [indirectly_writable](iterator.concept.writable#concept:indirectly_writable "24.3.4.3 Concept indirectly_­writable [iterator.concept.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]](simd.permute.static "29.10.8.7 vec static permute"), permute by static index generatorstatic constexpr *simd-size-type* [zero_element](#lib:simd,zero_element "29.10.3 Header <simd> synopsis [simd.syn]") = *implementation-defined*; static constexpr *simd-size-type* [uninit_element](#lib:simd,uninit_element "29.10.3 Header <simd> synopsis [simd.syn]") = *implementation-defined*; template<*simd-size-type* N = *see below*, [*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, class IdxMap>constexpr resize_t<N, V> permute(const V& v, IdxMap&& idxmap); template<*simd-size-type* N = *see below*, [*simd-mask-type*](simd.expos#concept:simd-mask-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") M, class IdxMap>constexpr resize_t<N, M> permute(const M& v, IdxMap&& idxmap); // [[simd.permute.dynamic]](simd.permute.dynamic "29.10.8.8 vec dynamic permute"), permute by dynamic indextemplate<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I>constexpr resize_t<I::size(), V> permute(const V& v, const I& indices); template<[*simd-mask-type*](simd.expos#concept:simd-mask-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") M, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I>constexpr resize_t<I::size(), M> permute(const M& v, const I& indices); // [[simd.permute.mask]](simd.permute.mask "29.10.8.9 vec mask permute"), permute by active mask bitstemplate<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr V compress(const V& v, const typename V::mask_type& selector); template<[*simd-mask-type*](simd.expos#concept:simd-mask-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") M>constexpr M compress(const M& v, const type_identity_t<M>& selector); template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr V compress(const V& v, const typename V::mask_type& selector, const typename V::value_type& fill_value); template<[*simd-mask-type*](simd.expos#concept:simd-mask-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") M>constexpr M compress(const M& v, const type_identity_t<M>& selector, const typename M::value_type& fill_value); template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {}); template<[*simd-mask-type*](simd.expos#concept:simd-mask-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") M>constexpr M expand(const M& v, const type_identity_t<M>& selector, const M& original = {}); // [[simd.permute.memory]](simd.permute.memory "29.10.8.10 simd memory permute"), permute to and from memorytemplate<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags...> f = {}); template<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags...> f = {}); template<class V = *see below*, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask, const I& indices, flags<Flags...> f = {}); template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr void unchecked_scatter_to(const V& v, R&& out, const I& indices, flags<Flags...> f = {}); template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<R>constexpr void partial_scatter_to(const V& v, R&& out, const I& indices, flags<Flags...> f = {}); template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V, ranges::[contiguous_range](range.refinements#concept:contiguous_range "25.4.6 Other range refinements [range.refinements]") R, [*simd-integral*](simd.expos#concept:simd-integral "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") I, class... Flags>requires ranges::[sized_range](range.sized#concept:sized_range "25.4.4 Sized ranges [range.sized]")<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]](simd.creation "29.10.8.11 basic_­vec and basic_­mask 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*<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.mask.reductions]](simd.mask.reductions "29.10.10.5 basic_­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](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto) noexcept; constexpr bool any_of([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto) noexcept; constexpr bool none_of([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto) noexcept; constexpr *simd-size-type* reduce_count([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto) noexcept; constexpr *simd-size-type* reduce_min_index([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto); constexpr *simd-size-type* reduce_max_index([same_as](concept.same#concept:same_as "18.4.2 Concept same_­as [concept.same]")<bool> auto); // [[simd.reductions]](simd.reductions "29.10.8.5 basic_­vec 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<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]](simd.alg "29.10.8.12 Algorithms"), 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]](simd.math "29.10.8.13 Mathematical functions"), mathematical functionstemplate<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> acos(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> asin(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> cos(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> sin(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> tan(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> acosh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> asinh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> atanh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> cosh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> sinh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> tanh(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> exp(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> exp2(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> expm1(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr *deduced-vec-t*<V> frexp(const V& value, rebind_t<int, *deduced-vec-t*<V>>* exp); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<int, *deduced-vec-t*<V>> ilogb(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr *deduced-vec-t*<V> ldexp(const V& x, const rebind_t<int, *deduced-vec-t*<V>>& exp); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> log(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> log10(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> log1p(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> log2(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr *deduced-vec-t*<V> scalbn(const V& x, const rebind_t<int, *deduced-vec-t*<V>>& n); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr *deduced-vec-t*<V> scalbln(const V& x, const rebind_t<long int, *deduced-vec-t*<V>>& n); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> cbrt(const V& x); template<[signed_integral](concepts.arithmetic#concept:signed_integral "18.4.7 Arithmetic concepts [concepts.arithmetic]") T, class Abi>constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> abs(const V& j); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> sqrt(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> erf(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> erfc(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> lgamma(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> tgamma(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> ceil(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr *deduced-vec-t*<V> floor(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> *deduced-vec-t*<V> nearbyint(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> *deduced-vec-t*<V> rint(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> rebind_t<long int, *deduced-vec-t*<V>> lrint(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> rebind_t<long long int, V> llrint(const *deduced-vec-t*<V>& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr *deduced-vec-t*<V> round(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<long int, *deduced-vec-t*<V>> lround(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<long long int, *deduced-vec-t*<V>> llround(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<int, *deduced-vec-t*<V>> fpclassify(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr typename *deduced-vec-t*<V>::mask_type isfinite(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr typename *deduced-vec-t*<V>::mask_type isinf(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr typename *deduced-vec-t*<V>::mask_type isnan(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr typename *deduced-vec-t*<V>::mask_type isnormal(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> *deduced-vec-t*<V> comp_ellint_1(const V& k); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> *deduced-vec-t*<V> expint(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> hermite(const rebind_t<unsigned, *deduced-vec-t*<V>>& n, const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> laguerre(const rebind_t<unsigned, *deduced-vec-t*<V>>& n, const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> legendre(const rebind_t<unsigned, *deduced-vec-t*<V>>& l, const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> riemann_zeta(const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> sph_bessel(const rebind_t<unsigned, *deduced-vec-t*<V>>& n, const V& x); template<[*math-floating-point*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") 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*](simd.expos#concept:math-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>*deduced-vec-t*<V> sph_neumann(const rebind_t<unsigned, *deduced-vec-t*<V>>& n, const V& x); // [[simd.bit]](simd.bit "29.10.8.14 basic_­vec bit library"), bit manipulationtemplate<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V byteswap(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V bit_ceil(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V bit_floor(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr typename V::mask_type has_single_bit(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V0, [*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V1>constexpr V0 rotl(const V0& v, const V1& s) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr V rotl(const V& v, int s) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V0, [*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V1>constexpr V0 rotr(const V0& v, const V1& s) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr V rotr(const V& v, int s) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept; template<[*simd-vec-type*](simd.expos#concept:simd-vec-type "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept; // [[simd.complex.math]](simd.complex.math "29.10.8.15 vec complex math"), vec complex mathtemplate<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<*simd-complex-value-type<V>*, V> real(const V&) noexcept; template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<*simd-complex-value-type<V>*, V> imag(const V&) noexcept; template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<*simd-complex-value-type<V>*, V> abs(const V&); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<*simd-complex-value-type<V>*, V> arg(const V&); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V>constexpr rebind_t<*simd-complex-value-type<V>*, V> norm(const V&); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V conj(const V&); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V proj(const V&); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V exp(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V log(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V log10(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V sqrt(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V sin(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V asin(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V cos(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V acos(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V tan(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V atan(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V sinh(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V asinh(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V cosh(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V acosh(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V tanh(const V& v); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V atanh(const V& v); template<[*simd-floating-point*](simd.expos#concept:simd-floating-point "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {}); template<[*simd-complex*](simd.expos#concept:simd-complex "29.10.2 Exposition-only types, variables, and concepts [simd.expos]") V> constexpr V pow(const V& x, const V& y);}namespace std {// See [[simd.alg]](simd.alg "29.10.8.12 Algorithms"), algorithmsusing simd::min; using simd::max; using simd::minmax; using simd::clamp; // See [[simd.math]](simd.math "29.10.8.13 Mathematical functions"), 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]](simd.bit "29.10.8.14 basic_­vec bit library"), 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]](simd.complex.math "29.10.8.15 vec 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;}