This header is part of thenumeric library.
Classes | ||
(C++26) | data-parallel vector type (class template)[edit] | |
(C++26) | convenience alias template forbasic_simd that can specify its width(alias template)[edit] | |
(C++26) | data-parallel type with the element typebool (class template)[edit] | |
(C++26) | convenience alias template forbasic_simd_mask that can specify its width(alias template)[edit] | |
(C++26) | load and store flags for data-parallel types (class template)[edit] | |
(C++26) | obtains an appropriate alignment fordatapar::flag_aligned (class template)[edit] | |
(C++26) | changes element type of the data-parallel type (class template)[edit] | |
(C++26) | changes the width of the data-parallel type (class template)[edit] | |
Functions | ||
loads elements from a contiguous range tobasic_simd (function template)[edit] | ||
stores elements frombasic_simd to a contiguous range(function template)[edit] | ||
(C++26) | splits single data-parallel object to multiple ones (function template)[edit] | |
(C++26) | concatenates multiple data-parallel objects into a single one (function template)[edit] | |
reductions ofbasic_simd_mask tobool(function template)[edit] | ||
(C++26) | reduction ofbasic_simd_mask to number oftrue values(function template)[edit] | |
reductions ofbasic_simd_mask to the index of first or lasttrue value(function template)[edit] | ||
reduces all values inbasic_simd over a specified binary operation to a single value(function template)[edit] | ||
element-wise min/max operations forbasic_simd (function template)[edit] | ||
(C++26) | element-wise clamp operation forbasic_simd (function template)[edit] | |
(C++26) | element-wise selection using conditional operator (function template)[edit] | |
Constants | ||
(C++26) | default flag used on load and store operations (constant)[edit] | |
(C++26) | flag enabling conversions that are not value-preserving on load and store operations (constant)[edit] | |
(C++26) | flag indicating alignment of the load-store address to some specified storage to the value ofdatapar::alignment (constant)[edit] | |
(C++26) | flag indicating alignment of the load-store address to some specified storage to the specified alignment (variable template)[edit] |
namespace std::datapar{// simd 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 description */;};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 description */;};template</*simd-size-type*/ N,class V>using resize_t=typename resize<N, V>::type; // Load and store flagstemplate<class...Flags>struct flags;inlineconstexpr flags<> flag_default{};inlineconstexpr flags</*convert-flag*/> flag_convert{};inlineconstexpr flags</*aligned-flag*/> flag_aligned{};template<size_t N> requires(has_single_bit(N))constexpr flags</*overaligned-flag*/<N>> flag_overaligned{}; // Class template basic_simdtemplate<class T,class Abi=/*native-abi*/<T>>class basic_simd;template<class T,/*simd-size-type*/ N=/*simd-size-v*/<T,/*native-abi*/<T>>>using simd= basic_simd<T,/*deduce-abi-t*/<T, N>>; // Class template basic_simd_masktemplate<size_t Bytes,class Abi=/*native-abi*/</*integer-from*/<Bytes>>>class basic_simd_mask;template<class T,/*simd-size-type*/ N=/*simd-size-v*/<T,/*native-abi*/<T>>>using simd_mask= basic_simd_mask<sizeof(T),/*deduce-abi-t*/<T, N>>; // basic_simd load and store functionstemplate<class V=/* see description */,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>constexpr V unchecked_load(R&&r, flags<Flags...> f={});template<class V=/* see description */,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>constexpr V unchecked_load(R&&r,consttypename V::mask_type&k, flags<Flags...> f={});template<class V=/* see description */, contiguous_iterator I,class...Flags>constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags...> f={});template<class V=/* see description */, contiguous_iterator I,class...Flags>constexpr V unchecked_load(I first, iter_difference_t<I> n,consttypename V::mask_type&k, flags<Flags...> f={});template<class V=/* see description */, 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 description */, contiguous_iterator I, sized_sentinel_for<I> S,class...Flags>constexpr V unchecked_load(I first, S last,consttypename V::mask_type&k, flags<Flags...> f={}); template<class V=/* see description */,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>constexpr V partial_load(R&&r, flags<Flags...> f={});template<class V=/* see description */,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>constexpr V partial_load(R&&r,consttypename V::mask_type&k, flags<Flags...> f={});template<class V=/* see description */, contiguous_iterator I,class...Flags>constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f={});template<class V=/* see description */, contiguous_iterator I,class...Flags>constexpr V partial_load(I first, iter_difference_t<I> n,consttypename V::mask_type&k, flags<Flags...> f={});template<class V=/* see description */, 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 description */, contiguous_iterator I, sized_sentinel_for<I> S,class...Flags>constexpr V partial_load(I first, S last,consttypename V::mask_type&k, flags<Flags...> f={}); template<class T,class Abi,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>&& indirectly_writable<ranges::iterator_t<R>, T>constexprvoid unchecked_store(const basic_simd<T, Abi>&v, R&&r, flags<Flags...> f={});template<class T,class Abi,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>&& indirectly_writable<ranges::iterator_t<R>, T>constexprvoidunchecked_store(const basic_simd<T, Abi>&v, R&&r,consttypename basic_simd<T, Abi>::mask_type&mask, flags<Flags...> f={});template<class T,class Abi, contiguous_iterator I,class...Flags> requires indirectly_writable<I, T>constexprvoid unchecked_store(const basic_simd<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>constexprvoidunchecked_store(const basic_simd<T, Abi>&v, I first, iter_difference_t<I> n,consttypename basic_simd<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>constexprvoid unchecked_store(const basic_simd<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>constexprvoidunchecked_store(const basic_simd<T, Abi>&v, I first, S last,consttypename basic_simd<T, Abi>::mask_type&mask, flags<Flags...> f={}); template<class T,class Abi,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>&& indirectly_writable<ranges::iterator_t<R>, T>constexprvoid partial_store(const basic_simd<T, Abi>&v, R&&r, flags<Flags...> f={});template<class T,class Abi,ranges::contiguous_range R,class...Flags> requiresranges::sized_range<R>&& indirectly_writable<ranges::iterator_t<R>, T>constexprvoid partial_store(const basic_simd<T, Abi>&v, R&&r,consttypename basic_simd<T, Abi>::mask_type&mask, flags<Flags...> f={});template<class T,class Abi, contiguous_iterator I,class...Flags> requires indirectly_writable<I, T>constexprvoid partial_store(const basic_simd<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>constexprvoid partial_store(const basic_simd<T, Abi>&v, I first, iter_difference_t<I> n,consttypename basic_simd<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>constexprvoid partial_store(const basic_simd<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>constexprvoid partial_store(const basic_simd<T, Abi>&v, I first, S last,consttypename basic_simd<T, Abi>::mask_type&mask, flags<Flags...> f={}); // basic_simd and basic_simd_mask creationtemplate<class T,class Abi>constexprauto chunk(const basic_simd<typename T::value_type, Abi>&x)noexcept;template<class T,class Abi>constexprautochunk(const basic_simd_mask</*mask-element-size*/<T>, Abi>&x)noexcept; template<size_t N,class T,class Abi>constexprauto chunk(const basic_simd<T, Abi>&x)noexcept;template<size_t N, size_t Bytes,class Abi>constexprauto chunk(const basic_simd_mask<Bytes, Abi>&x)noexcept; template<class T,class...Abis>constexpr basic_simd<T,/*deduce-abi-t*/<T,(basic_simd<T, Abis>::size()+ ...)>>cat(const basic_simd<T, Abis>&...)noexcept;template<size_t Bytes,class...Abis>constexpr basic_simd_mask< Bytes,/*deduce-abi-t*/</*integer-from*/<Bytes>,(basic_simd_mask<Bytes, Abis>::size()+ ...)>>cat(const basic_simd_mask<Bytes, Abis>&...)noexcept; // basic_simd_mask reductionstemplate<size_t Bytes,class Abi>constexprbool all_of(const basic_simd_mask<Bytes, Abi>&)noexcept;template<size_t Bytes,class Abi>constexprbool any_of(const basic_simd_mask<Bytes, Abi>&)noexcept;template<size_t Bytes,class Abi>constexprbool none_of(const basic_simd_mask<Bytes, Abi>&)noexcept;template<size_t Bytes,class Abi>constexpr/*simd-size-type*/reduce_count(const basic_simd_mask<Bytes, Abi>&)noexcept;template<size_t Bytes,class Abi>constexpr/*simd-size-type*/reduce_min_index(const basic_simd_mask<Bytes, Abi>&);template<size_t Bytes,class Abi>constexpr/*simd-size-type*/reduce_max_index(const basic_simd_mask<Bytes, Abi>&); constexprbool all_of(same_as<bool>auto)noexcept;constexprbool any_of(same_as<bool>auto)noexcept;constexprbool 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); // basic_simd reductionstemplate<class T,class Abi,class BinaryOperation= plus<>>constexpr T reduce(const basic_simd<T, Abi>&, BinaryOperation={});template<class T,class Abi,class BinaryOperation= plus<>>constexpr T reduce(const basic_simd<T, Abi>&x,consttypename basic_simd<T, Abi>::mask_type&mask, BinaryOperation binary_op={}, type_identity_t<T> identity_element=/* see description */); template<class T,class Abi>constexpr T reduce_min(const basic_simd<T, Abi>&)noexcept;template<class T,class Abi>constexpr T reduce_min(const basic_simd<T, Abi>&,consttypename basic_simd<T, Abi>::mask_type&)noexcept;template<class T,class Abi>constexpr T reduce_max(const basic_simd<T, Abi>&)noexcept;template<class T,class Abi>constexpr T reduce_max(const basic_simd<T, Abi>&,consttypename basic_simd<T, Abi>::mask_type&)noexcept; // Algorithmstemplate<class T,class Abi>constexpr basic_simd<T, Abi> min(const basic_simd<T, Abi>&a,const basic_simd<T, Abi>&b)noexcept;template<class T,class Abi>constexpr basic_simd<T, Abi> max(const basic_simd<T, Abi>&a,const basic_simd<T, Abi>&b)noexcept;template<class T,class Abi>constexpr pair<basic_simd<T, Abi>, basic_simd<T, Abi>>minmax(const basic_simd<T, Abi>&a,const basic_simd<T, Abi>&b)noexcept;template<class T,class Abi>constexpr basic_simd<T, Abi> clamp(const basic_simd<T, Abi>&v,const basic_simd<T, Abi>&lo,const basic_simd<T, Abi>&hi); template<class T,class U>constexprauto 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>constexprauto select(const basic_simd_mask<Bytes, Abi>&c,const T&a,const U&b)noexcept-> decltype(/*simd-select-impl*/(c, a, b)); // Mathematical functionstemplate</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> acos(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> asin(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-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-simd-t*/<V> cos(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> sin(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> tan(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> acosh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> asinh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> atanh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> cosh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> sinh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> tanh(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> exp(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> exp2(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> expm1(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V>frexp(const V&value, rebind_t<int,/*deduced-simd-t*/<V>>*exp);template</*math-floating-point*/ V>constexpr rebind_t<int,/*deduced-simd-t*/<V>> ilogb(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V>ldexp(const V&x,const rebind_t<int,/*deduced-simd-t*/<V>>&exp);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> log(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> log10(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> log1p(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> log2(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> logb(const V&x);template<class T,class Abi>constexpr basic_simd<T, Abi>modf(const type_identity_t<basic_simd<T, Abi>>&value, basic_simd<T, Abi>*iptr);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V>scalbn(const V&x,const rebind_t<int,/*deduced-simd-t*/<V>>&n);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V>scalbln(const V&x,const rebind_t<longint,/*deduced-simd-t*/<V>>&n);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> cbrt(const V&x);template<signed_integral T,class Abi>constexpr basic_simd<T, Abi> abs(const basic_simd<T, Abi>&j);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> abs(const V&j);template</*math-floating-point*/ V>constexpr/*deduced-simd-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-simd-t*/<V> sqrt(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> erf(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> erfc(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> lgamma(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> tgamma(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> ceil(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> floor(const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V> nearbyint(const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V> rint(const V&x);template</*math-floating-point*/ V>rebind_t<longint,/*deduced-simd-t*/<V>> lrint(const V&x);template</*math-floating-point*/ V>rebind_t<longlongint, V> llrint(const/*deduced-simd-t*/<V>&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-t*/<V> round(const V&x);template</*math-floating-point*/ V>constexpr rebind_t<longint,/*deduced-simd-t*/<V>> lround(const V&x);template</*math-floating-point*/ V>constexpr rebind_t<longlongint,/*deduced-simd-t*/<V>> llround(const V&x);template</*math-floating-point*/ V>constexpr/*deduced-simd-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-simd-t*/<V>> fpclassify(const V&x);template</*math-floating-point*/ V>constexprtypename/*deduced-simd-t*/<V>::mask_type isfinite(const V&x);template</*math-floating-point*/ V>constexprtypename/*deduced-simd-t*/<V>::mask_type isinf(const V&x);template</*math-floating-point*/ V>constexprtypename/*deduced-simd-t*/<V>::mask_type isnan(const V&x);template</*math-floating-point*/ V>constexprtypename/*deduced-simd-t*/<V>::mask_type isnormal(const V&x);template</*math-floating-point*/ V>constexprtypename/*deduced-simd-t*/<V>::mask_type signbit(const V&x);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeisgreater(const V0&x,const V1&y);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeisgreaterequal(const V0&x,const V1&y);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeisless(const V0&x,const V1&y);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeislessequal(const V0&x,const V1&y);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeislessgreater(const V0&x,const V1&y);template<class V0,class V1>constexprtypename/*math-common-simd-t*/<V0, V1>::mask_typeisunordered(const V0&x,const V1&y);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>assoc_laguerre(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&n,const rebind_t<unsigned,/*deduced-simd-t*/<V>>&m,const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>assoc_legendre(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&l,const rebind_t<unsigned,/*deduced-simd-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-simd-t*/<V> comp_ellint_1(const V&k);template</*math-floating-point*/ V>/*deduced-simd-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-simd-t*/<V> expint(const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>hermite(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&n,const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>laguerre(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&n,const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>legendre(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&l,const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V> riemann_zeta(const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>sph_bessel(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&n,const V&x);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>sph_legendre(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&l,const rebind_t<unsigned,/*deduced-simd-t*/<V>>&m,const V&theta);template</*math-floating-point*/ V>/*deduced-simd-t*/<V>sph_neumann(const rebind_t<unsigned,/*deduced-simd-t*/<V>>&n,const V&x); // Bit manipulationtemplate</*simd-type*/ V>constexpr V byteswap(const V&v)noexcept;template</*simd-type*/ V>constexpr V bit_ceil(const V&v)noexcept;template</*simd-type*/ V>constexpr V bit_floor(const V&v)noexcept; template</*simd-type*/ V>constexprtypename V::mask_type has_single_bit(const V&v)noexcept; template</*simd-type*/ V0,/*simd-type*/ V1>constexpr V0 rotl(const V0&v,const V1&s)noexcept;template</*simd-type*/ V>constexpr V rotl(const V&v,int s)noexcept; template</*simd-type*/ V0,/*simd-type*/ V1>constexpr V0 rotr(const V0&v,const V1&s)noexcept;template</*simd-type*/ V>constexpr V rotr(const V&v,int s)noexcept; template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>bit_width(const V&v)noexcept;template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>countl_zero(const V&v)noexcept;template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>countl_one(const V&v)noexcept;template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>countr_zero(const V&v)noexcept;template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>countr_one(const V&v)noexcept;template</*simd-type*/ V>constexpr rebind_t<make_signed_t<typename V::value_type>, V>popcount(const V&v)noexcept; // simd complex mathtemplate</*simd-complex*/ V>constexpr</*simd-complex-value-type*/<V>, V> real(const V&)noexcept; template</*simd-complex*/ V>constexpr</*simd-complex-value-type*/<V>, V> imag(const V&)noexcept; template</*simd-complex*/ V>constexpr</*simd-complex-value-type*/<V>, V> abs(const V&); template</*simd-complex*/ V>constexpr</*simd-complex-value-type*/<V>, V> arg(const V&); template</*simd-complex*/ V>constexpr</*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);} namespace std{// See Algorithmsusing datapar::clamp;using datapar::max;using datapar::min;using datapar::minmax; // See Mathematical functionsusing datapar::abs;using datapar::acos;using datapar::acosh;using datapar::asin;using datapar::asinh;using datapar::assoc_laguerre;using datapar::assoc_legendre;using datapar::atan;using datapar::atan2;using datapar::atanh;using datapar::beta;using datapar::cbrt;using datapar::ceil;using datapar::comp_ellint_1;using datapar::comp_ellint_2;using datapar::comp_ellint_3;using datapar::copysign;using datapar::cos;using datapar::cosh;using datapar::cyl_bessel_i;using datapar::cyl_bessel_j;using datapar::cyl_bessel_k;using datapar::cyl_neumann;using datapar::ellint_1;using datapar::ellint_2;using datapar::ellint_3;using datapar::erf;using datapar::erfc;using datapar::exp;using datapar::exp2;using datapar::expint;using datapar::expm1;using datapar::fabs;using datapar::fdim;using datapar::floor;using datapar::fma;using datapar::fmax;using datapar::fmin;using datapar::fmod;using datapar::fpclassify;using datapar::frexp;using datapar::hermite;using datapar::hypot;using datapar::ilogb;using datapar::isfinite;using datapar::isgreater;using datapar::isgreaterequal;using datapar::isinf;using datapar::isless;using datapar::islessequal;using datapar::islessgreater;using datapar::isnan;using datapar::isnormal;using datapar::isunordered;using datapar::laguerre;using datapar::ldexp;using datapar::legendre;using datapar::lerp;using datapar::lgamma;using datapar::llrint;using datapar::llround;using datapar::log;using datapar::log10;using datapar::log1p;using datapar::log2;using datapar::logb;using datapar::lrint;using datapar::lround;using datapar::modf;using datapar::nearbyint;using datapar::nextafter;using datapar::pow;using datapar::remainder;using datapar::remquo;using datapar::riemann_zeta;using datapar::rint;using datapar::round;using datapar::scalbln;using datapar::scalbn;using datapar::signbit;using datapar::sin;using datapar::sinh;using datapar::sph_bessel;using datapar::sph_legendre;using datapar::sph_neumann;using datapar::sqrt;using datapar::tan;using datapar::tanh;using datapar::tgamma;using datapar::trunc; // See Bit manipulationusing datapar::bit_ceil;using datapar::bit_floor;using datapar::bit_width;using datapar::byteswap;using datapar::countl_one;using datapar::countl_zero;using datapar::countr_one;using datapar::countr_zero;using datapar::has_single_bit;using datapar::popcount;using datapar::rotl;using datapar::rotr; // See simd complex mathusing datapar::arg;using datapar::conj;using datapar::imag;using datapar::norm;using datapar::polar;using datapar::proj;using datapar::real;}
namespace std::datapar{template<class...Flags>struct flags{// flags operatorstemplate<class...Other>friend constevalauto operator|(flags, flags<Other...>);};}
namespace std::datapar{template<class T,class Abi>class basic_simd{public:using value_type= T;using mask_type= basic_simd_mask<sizeof(T), Abi>;using abi_type= Abi; staticconstexpr integral_constant</*simd-size-type*/,/*simd-size-v*/<T, Abi>> size{}; constexpr basic_simd()noexcept=default; // basic_simd constructorstemplate<class U>constexprexplicit(/* see description */) basic_simd(U&&value)noexcept;template<class U,class UAbi>constexprexplicit(/* see description */) basic_simd(const basic_simd<U, UAbi>&)noexcept;template<class G>constexprexplicit basic_simd(G&&gen)noexcept;template<class R,class...Flags>constexpr basic_simd(R&&range, flags<Flags...>={});template<class R,class...Flags>constexpr basic_simd(R&&range,const mask_type&mask, flags<Flags...>={});template</*simd-floating-point*/ V>constexprexplicit(/* see description */) basic_simd(const V&reals,const V&imags={})noexcept; // basic_simd subscript operatorsconstexpr value_type operator[](/*simd-size-type*/)const; // basic_simd unary operatorsconstexpr basic_simd&operator++()noexcept;constexpr basic_simd operator++(int)noexcept;constexpr basic_simd&operator--()noexcept;constexpr basic_simd operator--(int)noexcept;constexpr mask_type operator!()constnoexcept;constexpr basic_simd operator~()constnoexcept;constexpr basic_simd operator+()constnoexcept;constexpr basic_simd operator-()constnoexcept; // basic_simd binary operatorsfriendconstexpr basic_simd operator+(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator-(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator*(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator/(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator%(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator&(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator|(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator^(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator<<(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator>>(const basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd operator<<(const basic_simd&,/*simd-size-type*/)noexcept;friendconstexpr basic_simd operator>>(const basic_simd&,/*simd-size-type*/)noexcept; // basic_simd compound assignmentfriendconstexpr basic_simd&operator+=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator-=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator*=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator/=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator%=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator&=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator|=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator^=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator<<=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator>>=(basic_simd&,const basic_simd&)noexcept;friendconstexpr basic_simd&operator<<=(basic_simd&,/*simd-size-type*/)noexcept;friendconstexpr basic_simd&operator>>=(basic_simd&,/*simd-size-type*/)noexcept; // basic_simd compare operatorsfriendconstexpr mask_type operator==(const basic_simd&,const basic_simd&)noexcept;friendconstexpr mask_type operator!=(const basic_simd&,const basic_simd&)noexcept;friendconstexpr mask_type operator>=(const basic_simd&,const basic_simd&)noexcept;friendconstexpr mask_type operator<=(const basic_simd&,const basic_simd&)noexcept;friendconstexpr mask_type operator>(const basic_simd&,const basic_simd&)noexcept;friendconstexpr mask_type operator<(const basic_simd&,const basic_simd&)noexcept; // basic_simd complex-value accessorsconstexprauto real()constnoexcept;constexprauto imag()constnoexcept;template</*simd-floating-point*/ V>constexprvoid real(const V&v)noexcept;template</*simd-floating-point*/ V>constexprvoid imag(const V&v)noexcept; // basic_simd exposition only conditional operatorsfriendconstexpr basic_simd/*simd-select-impl*/(// exposition onlyconst mask_type&,const basic_simd&,const basic_simd&)noexcept;}; template<class R,class...Ts> basic_simd(R&&r, Ts...)->/* see description */;}
namespace std::datapar{template<size_t Bytes,class Abi>class basic_simd_mask{public:using value_type=bool;using abi_type= Abi; staticconstexpr integral_constant</*simd-size-type*/,/*simd-size-v*/</*integer-from*/<Bytes>, Abi>> size{}; constexpr basic_simd_mask()noexcept=default; // basic_simd_mask constructorsconstexprexplicit basic_simd_mask(value_type)noexcept;template<size_t UBytes,class UAbi>constexprexplicit basic_simd_mask(const basic_simd_mask<UBytes, UAbi>&)noexcept;template<class G>constexprexplicit basic_simd_mask(G&&gen)noexcept; // basic_simd_mask subscript operatorsconstexpr value_type operator[](/*simd-size-type*/)const; // basic_simd_mask unary operatorsconstexpr basic_simd_mask operator!()constnoexcept;constexpr basic_simd</*integer-from*/<Bytes>, Abi> operator+()constnoexcept;constexpr basic_simd</*integer-from*/<Bytes>, Abi> operator-()constnoexcept;constexpr basic_simd</*integer-from*/<Bytes>, Abi> operator~()constnoexcept; // basic_simd_mask conversion operatorstemplate<class U,class A>constexprexplicit(sizeof(U)!= Bytes) operator basic_simd<U, A>()constnoexcept; // basic_simd_mask binary operatorsfriendconstexpr basic_simd_mask operator&&(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator||(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator&(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator|(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator^(const basic_simd_mask&,const basic_simd_mask&)noexcept; // basic_simd_mask compound assignmentfriendconstexpr basic_simd_mask& operator&=(basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask& operator|=(basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask& operator^=(basic_simd_mask&,const basic_simd_mask&)noexcept; // basic_simd_mask comparisonsfriendconstexpr basic_simd_mask operator==(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator!=(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator>=(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator<=(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator>(const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask operator<(const basic_simd_mask&,const basic_simd_mask&)noexcept; // basic_simd_mask exposition only conditional operatorsfriendconstexpr basic_simd_mask/*simd-select-impl*/(// exposition onlyconst basic_simd_mask&,const basic_simd_mask&,const basic_simd_mask&)noexcept;friendconstexpr basic_simd_mask/*simd-select-impl*/(// exposition onlyconst basic_simd_mask&, same_as<bool>auto, same_as<bool>auto)noexcept;template<class T0,class T1>friendconstexpr simd</* see description */, size()>/*simd-select-impl*/(const basic_simd_mask&,const T0&,const T1&)noexcept;// exposition only};}