friend constexpr basic_vec operator+(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator-(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator*(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator/(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator%(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator&(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator|(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator^(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator<<(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator>>(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec operator<<(const basic_vec& v, simd-size-type n) noexcept;
friend constexpr basic_vec operator>>(const basic_vec& v, simd-size-type n) noexcept;
friend constexpr basic_vec& operator+=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator-=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator*=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator/=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator%=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator&=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator|=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator^=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator<<=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator>>=(basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr basic_vec& operator<<=(basic_vec& lhs, simd-size-type n) noexcept;
friend constexpr basic_vec& operator>>=(basic_vec& lhs, simd-size-type n) noexcept;
friend constexpr mask_type operator==(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr mask_type operator!=(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr mask_type operator>=(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr mask_type operator<=(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr mask_type operator>(const basic_vec& lhs, const basic_vec& rhs) noexcept;
friend constexpr mask_type operator<(const basic_vec& lhs, const basic_vec& rhs) noexcept;
constexpr auto real() const noexcept;
constexpr auto imag() const noexcept;
template<simd-floating-point V>
constexpr void real(const V& v) noexcept;
template<simd-floating-point V>
constexpr void imag(const V& v) noexcept;
friend constexpr basic_vec
simd-select-impl(const mask_type& mask, const basic_vec& a, const basic_vec& b) noexcept;
template<class T, class Abi, class BinaryOperation = plus<>>
constexpr T reduce(const basic_vec<T, Abi>& x, BinaryOperation binary_op = {});
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>& x) 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>& x) noexcept;
template<class T, class Abi>
constexpr T reduce_max(
const basic_vec<T, Abi>&, const typename basic_vec<T, Abi>::mask_type&) noexcept;
template<class V = see below, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R>
constexpr V unchecked_load(R&& r, flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R>
constexpr V unchecked_load(R&& r, const typename V::mask_type& mask, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, class... Flags>
constexpr V unchecked_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, class... Flags>
constexpr V unchecked_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask,
flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
constexpr V unchecked_load(I first, S last, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
constexpr V unchecked_load(I first, S last, const typename V::mask_type& mask,
flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R>
constexpr V partial_load(R&& r, flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R>
constexpr V partial_load(R&& r, const typename V::mask_type& mask, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, class... Flags>
constexpr V partial_load(I first, iter_difference_t<I> n, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, class... Flags>
constexpr V partial_load(I first, iter_difference_t<I> n, const typename V::mask_type& mask,
flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
constexpr V partial_load(I first, S last, flags<Flags...> f = {});
template<class V = see below, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
constexpr V partial_load(I first, S last, const typename V::mask_type& mask,
flags<Flags...> f = {});
template<class T, class Abi, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
template<class T, class Abi, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, class... Flags>
requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, class... Flags>
requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
requires indirectly_writable<I, T>
constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
template<class T, class Abi, ranges::contiguous_range R, class... Flags>
requires ranges::sized_range<R> && indirectly_writable<ranges::iterator_t<R>, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, class... Flags>
requires indirectly_writable<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, class... Flags>
requires indirectly_writable<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
requires indirectly_writable<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
flags<Flags...> f = {});
template<class T, class Abi, contiguous_iterator I, sized_sentinel_for<I> S, class... Flags>
requires indirectly_writable<I, T>
constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
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);
template<simd-vec-type V, simd-integral I>
constexpr resize_t<I::size(), V> permute(const V& v, const I& indices);
template<simd-mask-type M, simd-integral I>
constexpr resize_t<I::size(), M> permute(const M& v, const I& indices);
template<simd-vec-type V>
constexpr V compress(const V& v, const typename V::mask_type& selector);
template<simd-mask-type M>
constexpr M compress(const M& v, const type_identity_t<M>& selector);
template<simd-vec-type V>
constexpr V compress(const V& v, const typename V::mask_type& selector,
const typename V::value_type& fill_value);
template<simd-mask-type M>
constexpr M compress(const M& v, const type_identity_t<M>& selector,
const typename V::value_type& fill_value);
template<simd-vec-type V>
constexpr V expand(const V& v, const typename V::mask_type& selector, const V& original = {});
template<simd-mask-type M>
constexpr M expand(const M& v, const type_identity_t<M>& selector, const M& original = {});
template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr V unchecked_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr V unchecked_gather_from(R&& in, const typename I::mask_type& mask,
const I& indices, flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr V partial_gather_from(R&& in, const I& indices, flags<Flags...> f = {});
template<class V = see below, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr V partial_gather_from(R&& in, const typename I::mask_type& mask,
const I& indices, flags<Flags...> f = {});
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr void unchecked_scatter_to(const V& v, R&& out, const I& indices,
flags<Flags...> f = {});
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr void unchecked_scatter_to(const V& v, R&& out, const typename I::mask_type& mask,
const I& indices, flags<Flags...> f = {});
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr void
partial_scatter_to(const V& v, R&& out, const I& indices, flags<Flags...> f = {});
template<simd-vec-type V, ranges::contiguous_range R, simd-integral I, class... Flags>
requires ranges::sized_range<R>
constexpr void partial_scatter_to(const V& v, R&& out, const typename I::mask_type& mask,
const I& indices, flags<Flags...> f = {});
template<class T, class Abi>
constexpr auto chunk(const basic_vec<typename T::value_type, Abi>& x) noexcept;
template<class T, class Abi>
constexpr auto chunk(const basic_mask<mask-element-size<T>, Abi>& x) noexcept;
template<simd-size-type N, class T, class Abi>
constexpr auto chunk(const basic_vec<T, Abi>& x) noexcept;
template<simd-size-type N, size_t Bytes, class Abi>
constexpr auto chunk(const basic_mask<Bytes, Abi>& x) noexcept;
template<class T, class... Abis>
constexpr vec<T, (basic_vec<T, Abis>::size() + ...)>
cat(const basic_vec<T, Abis>&... xs) 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>&... xs) noexcept;
template<class T, class Abi>
constexpr basic_vec<T, Abi> min(const basic_vec<T, Abi>& a,
const basic_vec<T, Abi>& b) noexcept;
template<class T, class Abi>
constexpr basic_vec<T, Abi> max(const basic_vec<T, Abi>& a,
const basic_vec<T, Abi>& b) noexcept;
template<class T, class Abi>
constexpr pair<basic_vec<T, Abi>, basic_vec<T, Abi>>
minmax(const basic_vec<T, Abi>& a, const basic_vec<T, Abi>& b) noexcept;
template<class T, class Abi>
constexpr basic_vec<T, Abi> clamp(
const basic_vec<T, Abi>& v, const basic_vec<T, Abi>& lo, const basic_vec<T, Abi>& hi);
template<class T, class U>
constexpr auto select(bool c, const T& a, const U& b)
-> remove_cvref_t<decltype(c ? a : b)>;
template<size_t Bytes, class Abi, class T, class U>
constexpr auto select(const basic_mask<Bytes, Abi>& c, const T& a, const U& b)
noexcept -> decltype(simd-select-impl(c, a, b));
template<math-floating-point V>
constexpr rebind_t<int, deduced-vec-t<V>> ilogb(const V& x);
template<math-floating-point V>
constexpr deduced-vec-t<V> ldexp(const V& x, const rebind_t<int, deduced-vec-t<V>>& exp);
template<math-floating-point V>
constexpr deduced-vec-t<V> scalbn(const V& x, const rebind_t<int, deduced-vec-t<V>>& n);
template<math-floating-point V>
constexpr deduced-vec-t<V>
scalbln(const V& x, const rebind_t<long int, deduced-vec-t<V>>& n);
template<signed_integral T, class Abi>
constexpr basic_vec<T, Abi> abs(const basic_vec<T, Abi>& j);
template<math-floating-point V>
constexpr deduced-vec-t<V> abs(const V& j);
template<math-floating-point V>
constexpr deduced-vec-t<V> fabs(const V& x);
template<math-floating-point V>
constexpr deduced-vec-t<V> ceil(const V& x);
template<math-floating-point V>
constexpr deduced-vec-t<V> floor(const V& x);
template<math-floating-point V>
deduced-vec-t<V> nearbyint(const V& x);
template<math-floating-point V>
deduced-vec-t<V> rint(const V& x);
template<math-floating-point V>
rebind_t<long int, deduced-vec-t<V>> lrint(const V& x);
template<math-floating-point V>
rebind_t<long long int, deduced-vec-t<V>> llrint(const V& x);
template<math-floating-point V>
constexpr deduced-vec-t<V> round(const V& x);
template<math-floating-point V>
constexpr rebind_t<long int, deduced-vec-t<V>> lround(const V& x);
template<math-floating-point V>
constexpr rebind_t<long long int, deduced-vec-t<V>> llround(const V& x);
template<class V0, class V1>
constexpr math-common-simd-t<V0, V1> fmod(const V0& x, const V1& y);
template<math-floating-point V>
constexpr deduced-vec-t<V> trunc(const V& x);
template<class V0, class V1>
constexpr math-common-simd-t<V0, V1> remainder(const V0& x, const V1& y);
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<math-floating-point V>
constexpr rebind_t<int, deduced-vec-t<V>> fpclassify(const V& x);
template<math-floating-point V>
constexpr typename deduced-vec-t<V>::mask_type isfinite(const V& x);
template<math-floating-point V>
constexpr typename deduced-vec-t<V>::mask_type isinf(const V& x);
template<math-floating-point V>
constexpr typename deduced-vec-t<V>::mask_type isnan(const V& x);
template<math-floating-point V>
constexpr typename deduced-vec-t<V>::mask_type isnormal(const V& x);
template<math-floating-point V>
constexpr typename deduced-vec-t<V>::mask_type signbit(const V& x);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type isgreater(const V0& x, const V1& y);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type
isgreaterequal(const V0& x, const V1& y);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type isless(const V0& x, const V1& y);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type islessequal(const V0& x, const V1& y);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type islessgreater(const V0& x, const V1& y);
template<class V0, class V1>
constexpr typename math-common-simd-t<V0, V1>::mask_type isunordered(const V0& x, const V1& y);
template<math-floating-point V> constexpr deduced-vec-t<V> acos(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> asin(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> atan(const V& x);
template<class V0, class V1>
constexpr math-common-simd-t<V0, V1> atan2(const V0& y, const V1& x);
template<math-floating-point V> constexpr deduced-vec-t<V> cos(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> sin(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> tan(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> acosh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> asinh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> atanh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> cosh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> sinh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> tanh(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> exp(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> exp2(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> expm1(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> log(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> log10(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> log1p(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> log2(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> logb(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> cbrt(const V& x);
template<class V0, class V1>
constexpr math-common-simd-t<V0, V1> hypot(const V0& x, const V1& y);
template<class V0, class V1, class V2>
constexpr math-common-simd-t<V0, V1, V2> hypot(const V0& x, const V1& y, const V2& z);
template<class V0, class V1>
constexpr math-common-simd-t<V0, V1> pow(const V0& x, const V1& y);
template<math-floating-point V> constexpr deduced-vec-t<V> sqrt(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> erf(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> erfc(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> lgamma(const V& x);
template<math-floating-point V> constexpr deduced-vec-t<V> tgamma(const V& x);
template<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>
deduced-vec-t<V> assoc_laguerre(const rebind_t<unsigned, deduced-vec-t<V>>& n, const
rebind_t<unsigned, deduced-vec-t<V>>& m,
const V& x);
template<math-floating-point V>
deduced-vec-t<V> assoc_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l, const
rebind_t<unsigned, deduced-vec-t<V>>& m,
const V& x);
template<class V0, class V1>
math-common-simd-t<V0, V1> beta(const V0& x, const V1& y);
template<math-floating-point V> deduced-vec-t<V> comp_ellint_1(const V& k);
template<math-floating-point V> deduced-vec-t<V> comp_ellint_2(const V& k);
template<class V0, class V1>
math-common-simd-t<V0, V1> comp_ellint_3(const V0& k, const V1& nu);
template<class V0, class V1>
math-common-simd-t<V0, V1> cyl_bessel_i(const V0& nu, const V1& x);
template<class V0, class V1>
math-common-simd-t<V0, V1> cyl_bessel_j(const V0& nu, const V1& x);
template<class V0, class V1>
math-common-simd-t<V0, V1> cyl_bessel_k(const V0& nu, const V1& x);
template<class V0, class V1>
math-common-simd-t<V0, V1> cyl_neumann(const V0& nu, const V1& x);
template<class V0, class V1>
math-common-simd-t<V0, V1> ellint_1(const V0& k, const V1& phi);
template<class V0, class V1>
math-common-simd-t<V0, V1> ellint_2(const V0& k, const V1& phi);
template<class V0, class V1, class V2>
math-common-simd-t<V0, V1, V2> ellint_3(const V0& k, const V1& nu, const V2& phi);
template<math-floating-point V> deduced-vec-t<V> expint(const V& x);
template<math-floating-point V> deduced-vec-t<V> hermite(const rebind_t<unsigned,
deduced-vec-t<V>>& n, const V& x);
template<math-floating-point V> deduced-vec-t<V> laguerre(const rebind_t<unsigned,
deduced-vec-t<V>>& n, const V& x);
template<math-floating-point V> deduced-vec-t<V> legendre(const rebind_t<unsigned,
deduced-vec-t<V>>& l, const V& x);
template<math-floating-point V> deduced-vec-t<V> riemann_zeta(const V& x);
template<math-floating-point V> deduced-vec-t<V> sph_bessel(const rebind_t<unsigned,
deduced-vec-t<V>>& n, const V& x);
template<math-floating-point V>
deduced-vec-t<V> sph_legendre(const rebind_t<unsigned, deduced-vec-t<V>>& l,
const rebind_t<unsigned, deduced-vec-t<V>>& m,
const V& theta);
template<math-floating-point V> deduced-vec-t<V> sph_neumann(const rebind_t<unsigned,
deduced-vec-t<V>>& n, const V& x);
template<math-floating-point V>
constexpr deduced-vec-t<V> frexp(const V& value, rebind_t<int, deduced-vec-t<V>>* exp);
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 T, class Abi>
constexpr basic_vec<T, Abi> modf(const type_identity_t<basic_vec<T, Abi>>& value,
basic_vec<T, Abi>* iptr);
template<simd-vec-type V> constexpr V byteswap(const V& v) noexcept;
template<simd-vec-type V> constexpr V bit_ceil(const V& v) noexcept;
template<simd-vec-type V> constexpr V bit_floor(const V& v) noexcept;
template<simd-vec-type V>
constexpr typename V::mask_type has_single_bit(const V& v) noexcept;
template<simd-vec-type V0, simd-vec-type V1>
constexpr V0 rotl(const V0& v0, const V1& v1) noexcept;
template<simd-vec-type V0, simd-vec-type V1>
constexpr V0 rotr(const V0& v0, const V1& v1) noexcept;
template<simd-vec-type V> constexpr V rotl(const V& v, int s) noexcept;
template<simd-vec-type V> constexpr V rotr(const V& v, int s) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> bit_width(const V& v) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_zero(const V& v) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> countl_one(const V& v) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_zero(const V& v) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> countr_one(const V& v) noexcept;
template<simd-vec-type V>
constexpr rebind_t<make_signed_t<typename V::value_type>, V> popcount(const V& v) noexcept;
template<simd-complex V>
constexpr rebind_t<simd-complex-value-type<V>, V> real(const V&) noexcept;
template<simd-complex V>
constexpr rebind_t<simd-complex-value-type<V>, V> imag(const V&) noexcept;
template<simd-complex V>
constexpr rebind_t<simd-complex-value-type<V>, V> abs(const V&);
template<simd-complex V>
constexpr rebind_t<simd-complex-value-type<V>, V> arg(const V&);
template<simd-complex V>
constexpr rebind_t<simd-complex-value-type<V>, V> norm(const V&);
template<simd-complex V> constexpr V conj(const V&);
template<simd-complex V> constexpr V proj(const V&);
template<simd-complex V> constexpr V exp(const V& v);
template<simd-complex V> constexpr V log(const V& v);
template<simd-complex V> constexpr V log10(const V& v);
template<simd-complex V> constexpr V sqrt(const V& v);
template<simd-complex V> constexpr V sin(const V& v);
template<simd-complex V> constexpr V asin(const V& v);
template<simd-complex V> constexpr V cos(const V& v);
template<simd-complex V> constexpr V acos(const V& v);
template<simd-complex V> constexpr V tan(const V& v);
template<simd-complex V> constexpr V atan(const V& v);
template<simd-complex V> constexpr V sinh(const V& v);
template<simd-complex V> constexpr V asinh(const V& v);
template<simd-complex V> constexpr V cosh(const V& v);
template<simd-complex V> constexpr V acosh(const V& v);
template<simd-complex V> constexpr V tanh(const V& v);
template<simd-complex V> constexpr V atanh(const V& v);
template<simd-floating-point V>
rebind_t<complex<typename V::value_type>, V> polar(const V& x, const V& y = {});
template<simd-complex V> constexpr V pow(const V& x, const V& y);