Wide register packs

Classes
struct	native::wide< T, N >
	Own N values of T, including an empty pack when N == 0. registers is the underlying array. Tuple access and structured bindings refer to the actual elements. Value initialization follows T's rules; no general floating-point or zero-initialization policy is added here. More...

Functions
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a + b; }
constexpr auto	native::operator+ (A const &a, B const &b) noexcept(noexcept(detail::wide_generic_detail::wide_dispatch(a, b, detail::wide_generic_detail::wide_add{})))
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a - b; }
constexpr auto	native::operator- (A const &a, B const &b) noexcept(noexcept(detail::wide_generic_detail::wide_dispatch(a, b, detail::wide_generic_detail::wide_sub{})))
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a * b; }
constexpr auto	native::operator* (A const &a, B const &b) noexcept(noexcept(detail::wide_generic_detail::wide_dispatch(a, b, detail::wide_generic_detail::wide_mul{})))
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a / b; }
constexpr auto	native::operator/ (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a % b; }
constexpr auto	native::operator% (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a & b; }
constexpr auto	native::operator& (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a | b; }
constexpr auto	native::operator| (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a ^ b; }
constexpr auto	native::operator^ (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a << b; }
constexpr auto	native::operator<< (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a >> b; }
constexpr auto	native::operator>> (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a == b; }
constexpr auto	native::operator== (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a != b; }
constexpr auto	native::operator!= (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a < b; }
constexpr auto	native::operator< (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a > b; }
constexpr auto	native::operator> (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a <= b; }
constexpr auto	native::operator<= (A const &a, B const &b)
template<class A, class B> requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) && requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a >= b; }
constexpr auto	native::operator>= (A const &a, B const &b)
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { +a; }
constexpr auto	native::operator+ (wide< T, N > const &a)
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { -a; }
constexpr auto	native::operator- (wide< T, N > const &a)
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { ~a; }
constexpr auto	native::operator~ (wide< T, N > const &a)
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { !a; }
constexpr auto	native::operator! (wide< T, N > const &a)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_add> || ((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a += b; }))
constexpr wide< T, N > &	native::operator+= (wide< T, N > &a, B const &b) noexcept([] { if constexpr(detail::wide_generic_detail::wide_batch_assignable< wide< T, N >, B, detail::wide_generic_detail::wide_add >) return noexcept(std::declval< wide< T, N > & >()=detail::wide_generic_detail::wide_dispatch(std::declval< wide< T, N > const & >(), std::declval< B const & >(), detail::wide_generic_detail::wide_add{}));else return false;}())
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_sub> || ((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a -= b; }))
constexpr wide< T, N > &	native::operator-= (wide< T, N > &a, B const &b) noexcept([] { if constexpr(detail::wide_generic_detail::wide_batch_assignable< wide< T, N >, B, detail::wide_generic_detail::wide_sub >) return noexcept(std::declval< wide< T, N > & >()=detail::wide_generic_detail::wide_dispatch(std::declval< wide< T, N > const & >(), std::declval< B const & >(), detail::wide_generic_detail::wide_sub{}));else return false;}())
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_mul> || ((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a *= b; }))
constexpr wide< T, N > &	native::operator*= (wide< T, N > &a, B const &b) noexcept([] { if constexpr(detail::wide_generic_detail::wide_batch_assignable< wide< T, N >, B, detail::wide_generic_detail::wide_mul >) return noexcept(std::declval< wide< T, N > & >()=detail::wide_generic_detail::wide_dispatch(std::declval< wide< T, N > const & >(), std::declval< B const & >(), detail::wide_generic_detail::wide_mul{}));else return false;}())
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a /= b; }
constexpr wide< T, N > &	native::operator/= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a %= b; }
constexpr wide< T, N > &	native::operator%= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a &= b; }
constexpr wide< T, N > &	native::operator&= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a |= b; }
constexpr wide< T, N > &	native::operator|= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a ^= b; }
constexpr wide< T, N > &	native::operator^= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a <<= b; }
constexpr wide< T, N > &	native::operator<<= (wide< T, N > &a, B const &b)
template<class T, std::size_t N, class B> requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> && (detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a, detail::wide_generic_detail::wide_element_t<B> const & b) { a >>= b; }
constexpr wide< T, N > &	native::operator>>= (wide< T, N > &a, B const &b)
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_isfinite,T>
constexpr auto	native::isfinite (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_isfinite >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_isinf,T>
constexpr auto	native::isinf (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_isinf >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_isnan,T>
constexpr auto	native::isnan (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_isnan >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_signbit,T>
constexpr auto	native::signbit (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_signbit >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_copysign,T,T> && std::same_as<detail::wide_generic_detail::wide_result <detail::wide_generic_detail::wide_copysign,T,T>,T>
constexpr wide< T, N >	native::copysign (wide< T, N > const &a, wide< T, N > const &b) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_copysign >(a, b)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_floor,T> && std::same_as<detail::wide_generic_detail::wide_result <detail::wide_generic_detail::wide_floor,T>,T>
constexpr wide< T, N >	native::floor (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_floor >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_ceil,T> && std::same_as<detail::wide_generic_detail::wide_result <detail::wide_generic_detail::wide_ceil,T>,T>
constexpr wide< T, N >	native::ceil (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_ceil >(input)))
template<class T, std::size_t N> requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N, detail::wide_generic_detail::wide_trunc,T> && std::same_as<detail::wide_generic_detail::wide_result <detail::wide_generic_detail::wide_trunc,T>,T>
constexpr wide< T, N >	native::trunc (wide< T, N > const &input) noexcept(noexcept(detail::wide_generic_detail::wide_map< detail::wide_generic_detail::wide_trunc >(input)))
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX)
constexpr wide< R, N >	native::broadcast (R value) noexcept(noexcept(wide< R, N >::broadcast(value)))
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_abs(x); }
constexpr wide< R, N >	native::abs (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_abs(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_abs(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_abs(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_sqrt(x); }
constexpr wide< R, N >	native::sqrt (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_sqrt(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_sqrt(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_sqrt(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_sin(x); }
constexpr wide< R, N >	native::sin (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_sin(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_sin(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_sin(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_cos(x); }
constexpr wide< R, N >	native::cos (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_cos(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_cos(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_cos(std::declval< R const & >())));}())
template<bool Flush = false, unsigned Degree = 6, class R, std::size_t N> requires (Degree >= 1 && Degree <= 7) && (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_exp<Flush,Degree>(x); }
constexpr wide< R, N >	native::exp (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_exp< Flush, Degree >(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_exp< Flush, Degree >(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_exp< Flush, Degree >(std::declval< R const & >())));}())
template<bool Flush = false, class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_exp2 <Flush>(x); }
constexpr wide< R, N >	native::exp2 (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_exp2< Flush >(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_exp2< Flush >(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_exp2< Flush >(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_expm1(x); }
constexpr wide< R, N >	native::expm1 (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_expm1(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_expm1(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_expm1(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_damping_gain(x); }
constexpr wide< R, N >	native::damping_gain (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_damping_gain(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_damping_gain(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_damping_gain(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_log(x); }
constexpr wide< R, N >	native::log (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_log2(x); }
constexpr wide< R, N >	native::log2 (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log2(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log2(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log2(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_log1p(x); }
constexpr wide< R, N >	native::log1p (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_log1p(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_log1p(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_log1p(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_tanh(x); }
constexpr wide< R, N >	native::tanh (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_tanh(a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_tanh(std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_tanh(std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_atan2(x,x); }
constexpr wide< R, N >	native::atan2 (wide< R, N > const &y, wide< R, N > const &x) noexcept([] { if constexpr(requires(std::array< R, N > const &a) { detail::wide_generic_detail::adl_atan2(a, a);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_atan2(std::declval< std::array< R, N > const & >(), std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_atan2(std::declval< R const & >(), std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_fma(x, x,x); }
constexpr wide< R, N >	native::fma (wide< R, N > const &a, wide< R, N > const &b, wide< R, N > const &c) noexcept([] { if constexpr(requires(std::array< R, N > const &x) { detail::wide_generic_detail::adl_fma(x, x, x);}) return noexcept(wide< R, N >{detail::wide_generic_detail::adl_fma(std::declval< std::array< R, N > const & >(), std::declval< std::array< R, N > const & >(), std::declval< std::array< R, N > const & >())});else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_fma(std::declval< R const & >(), std::declval< R const & >(), std::declval< R const & >())));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_sincos(x); }
constexpr auto	native::sincos (wide< R, N > const &input) noexcept([] { if constexpr(requires(std::array< R, N > const &x) { detail::wide_generic_detail::adl_sincos(x);}) return noexcept(detail::wide_generic_detail::adl_sincos(std::declval< std::array< R, N > const & >())) &&std::is_nothrow_move_constructible_v< std::array< R, N > >;else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&(N==0||(noexcept(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) &&noexcept(std::declval< R & >()=std::declval< decltype(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) & >().first) &&noexcept(std::declval< R & >()=std::declval< decltype(detail::wide_generic_detail::adl_sincos(std::declval< R const & >())) & >().second)));}())
template<class R, std::size_t N> requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX)
constexpr wide< R, N >	native::select (wide< decltype(R{}==R{}), N > const &masks, wide< R, N > const &a, wide< R, N > const &b) noexcept([] { if constexpr(N==0) return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > >;else if constexpr(std::is_same_v< decltype(R{}==R{}), bool >) return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&noexcept(std::declval< R & >()=std::declval< R const & >());else return noexcept(wide< R, N >()) &&std::is_nothrow_move_constructible_v< wide< R, N > > &&noexcept(std::declval< R & >()=detail::wide_generic_detail::adl_select(std::declval< decltype(R{}==R{}) const & >(), std::declval< R const & >(), std::declval< R const & >()));}())

Detailed Description

A fixed number of independent elements, usually native registers. Operations preserve the element library's contracts. Batch-aware math calls one ADL array kernel when available; otherwise it applies the element operation. This does not repartition a pack or choose a different architecture. The reference shows one representative target-family overload per signature; internal family constraints select the matching implementation for scalar, AVX2, AVX-512 or NEON elements.

template<native::isa<> Arch>
void wide_values() {
  using V = native::simd<float, 4, Arch>;
  native::wide batch{V(1.f), V(2.f), V(3.f)};
  auto result = fma(batch, batch, batch);
  static_assert(std::tuple_size_v<decltype(result)> == 3);
  check(all(result.template get<2>() == V(12.f)));
  native::wide<float, 3> scalar_values{1.f, -2.f, 3.f};
  auto finite = native::isfinite(scalar_values);
  static_assert(std::same_as<decltype(finite), native::wide<bool, 3>>);
  check(finite.template get<0>() && finite.template get<1>());
  native::wide<float, 0> empty{};
  check(native::floor(empty).registers.empty());
}

Function Documentation

abs()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_abs(x); }

wide< R, N > native::abs ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's absolute-value operation.

Definition at line 961 of file wide.h.

atan2()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_atan2(x,x); }

wide< R, N > native::atan2 ( wide< R, N > const & y, wide< R, N > const & x )

inlineconstexprnoexcept

Apply the element library's atan2(y,x), preserving argument order. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1214 of file wide.h.

broadcast()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX)

wide< R, N > native::broadcast ( R value )

inlineconstexprnoexcept

Copy one value to a pack with the explicitly selected extent.

Definition at line 955 of file wide.h.

ceil()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_ceil,T> && std::same_as<detail::wide_generic_detail::wide_result
<detail::wide_generic_detail::wide_ceil,T>,T>

wide< T, N > native::ceil ( wide< T, N > const & input )

inlineconstexprnoexcept

Round each element up, using its ADL operation and retaining the element type.

Definition at line 940 of file wide.h.

copysign()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_copysign,T,T> && std::same_as<detail::wide_generic_detail::wide_result
<detail::wide_generic_detail::wide_copysign,T,T>,T>

wide< T, N > native::copysign ( wide< T, N > const & a, wide< T, N > const & b )

inlineconstexprnoexcept

Copy signs from b to a using the homogeneous element operation. The result construction and ADL call both contribute to conditional noexcept.

Definition at line 923 of file wide.h.

Here is the caller graph for this function:

cos()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_cos(x); }

wide< R, N > native::cos ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's cosine operation in radians. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1024 of file wide.h.

Here is the caller graph for this function:

damping_gain()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_damping_gain(x); }

wide< R, N > native::damping_gain ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's -expm1(-x) operation. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1109 of file wide.h.

Here is the caller graph for this function:

exp()

template<bool Flush = false, unsigned Degree = 6, class R, std::size_t N>
requires (Degree >= 1 && Degree <= 7) && (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_exp<Flush,Degree>(x); }

wide< R, N > native::exp ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply exponential with compile-time cutoff and degree tags when supported. Uses one array call when available, otherwise an elementwise fallback. Untagged element operations are available only at the default degree six.

Definition at line 1046 of file wide.h.

exp2()

template<bool Flush = false, class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_exp2
<Flush>(x); }

wide< R, N > native::exp2 ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply base-two exponential; pass the compile-time Flush tag when the element supports it. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1067 of file wide.h.

expm1()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_expm1(x); }

wide< R, N > native::expm1 ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's exp(x)-1 operation. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1088 of file wide.h.

Here is the caller graph for this function:

floor()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_floor,T> && std::same_as<detail::wide_generic_detail::wide_result
<detail::wide_generic_detail::wide_floor,T>,T>

wide< T, N > native::floor ( wide< T, N > const & input )

inlineconstexprnoexcept

Round each element down, using its ADL operation and retaining the element type. The result construction and ADL call both contribute to conditional noexcept.

Definition at line 932 of file wide.h.

fma()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_fma(x,
x,x); }

wide< R, N > native::fma ( wide< R, N > const & a, wide< R, N > const & b, wide< R, N > const & c )

inlineconstexprnoexcept

Apply the element library's fused multiply-add to corresponding elements. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1238 of file wide.h.

isfinite()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_isfinite,T>

auto native::isfinite ( wide< T, N > const & input )

inlineconstexprnoexcept

Classify each element as finite, preserving its actual bool or mask result type. The result construction and ADL call both contribute to conditional noexcept.

Definition at line 893 of file wide.h.

Here is the caller graph for this function:

isinf()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_isinf,T>

auto native::isinf ( wide< T, N > const & input )

inlineconstexprnoexcept

Classify infinities using the element operation and its actual result type.

Definition at line 900 of file wide.h.

Here is the caller graph for this function:

isnan()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_isnan,T>

auto native::isnan ( wide< T, N > const & input )

inlineconstexprnoexcept

Classify NaNs using the element operation and its actual result type.

Definition at line 907 of file wide.h.

Here is the caller graph for this function:

log()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_log(x); }

wide< R, N > native::log ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's natural logarithm. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1130 of file wide.h.

Here is the caller graph for this function:

log1p()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_log1p(x); }

wide< R, N > native::log1p ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's log(1+x) operation. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1172 of file wide.h.

Here is the caller graph for this function:

log2()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_log2(x); }

wide< R, N > native::log2 ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's base-two logarithm. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1151 of file wide.h.

Here is the caller graph for this function:

operator!()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { !a; }

auto native::operator! ( wide< T, N > const & a )

inlineconstexpr

Apply unary ! to each element, retaining its result type.

Definition at line 610 of file wide.h.

Here is the caller graph for this function:

operator!=()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a != b; }

auto native::operator!= ( A const & a, B const & b )

inlineconstexpr

Apply != to corresponding elements; a non-pack argument is broadcast.

Definition at line 545 of file wide.h.

operator%()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a % b; }

auto native::operator% ( A const & a, B const & b )

inlineconstexpr

Apply % to corresponding elements; a non-pack argument is broadcast.

Definition at line 482 of file wide.h.

operator%=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a %= b; }

wide< T, N > & native::operator%= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise %=; a scalar right side is broadcast.

Definition at line 682 of file wide.h.

operator&()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a & b; }

auto native::operator& ( A const & a, B const & b )

inlineconstexpr

Apply & to corresponding elements; a non-pack argument is broadcast.

Definition at line 491 of file wide.h.

operator&=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a &= b; }

wide< T, N > & native::operator&= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise &=; a scalar right side is broadcast.

Definition at line 691 of file wide.h.

operator*()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a * b; }

auto native::operator* ( A const & a, B const & b )

inlineconstexprnoexcept

Apply * to corresponding elements; a non-pack argument is broadcast.

Definition at line 464 of file wide.h.

operator*=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_mul> ||
((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a *= b; }))

wide< T, N > & native::operator*= ( wide< T, N > & a, B const & b )

inlineconstexprnoexcept

Update the left pack with elementwise *=; a scalar right side is broadcast.

Definition at line 656 of file wide.h.

operator+() [1/2]

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a + b; }

auto native::operator+ ( A const & a, B const & b )

inlineconstexprnoexcept

Apply + to corresponding elements; a non-pack argument is broadcast.

Definition at line 446 of file wide.h.

operator+() [2/2]

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { +a; }

auto native::operator+ ( wide< T, N > const & a )

inlineconstexpr

Apply unary + to each element, retaining its result type.

Definition at line 589 of file wide.h.

operator+=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_add> ||
((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a += b; }))

wide< T, N > & native::operator+= ( wide< T, N > & a, B const & b )

inlineconstexprnoexcept

Update the left pack with elementwise +=; a scalar right side is broadcast.

Definition at line 620 of file wide.h.

operator-() [1/2]

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a - b; }

auto native::operator- ( A const & a, B const & b )

inlineconstexprnoexcept

Apply - to corresponding elements; a non-pack argument is broadcast.

Definition at line 455 of file wide.h.

operator-() [2/2]

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { -a; }

auto native::operator- ( wide< T, N > const & a )

inlineconstexpr

Apply unary - to each element, retaining its result type.

Definition at line 596 of file wide.h.

operator-=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_batch_assignable<wide<T,N>,B,detail::wide_generic_detail::wide_sub> ||
((detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a -= b; }))

wide< T, N > & native::operator-= ( wide< T, N > & a, B const & b )

inlineconstexprnoexcept

Update the left pack with elementwise -=; a scalar right side is broadcast.

Definition at line 638 of file wide.h.

operator/()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a / b; }

auto native::operator/ ( A const & a, B const & b )

inlineconstexpr

Apply / to corresponding elements; a non-pack argument is broadcast.

Definition at line 473 of file wide.h.

operator/=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a /= b; }

wide< T, N > & native::operator/= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise /=; a scalar right side is broadcast.

Definition at line 673 of file wide.h.

operator<()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a < b; }

auto native::operator< ( A const & a, B const & b )

inlineconstexpr

Apply < to corresponding elements; a non-pack argument is broadcast.

Definition at line 554 of file wide.h.

operator<<()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a << b; }

auto native::operator<< ( A const & a, B const & b )

inlineconstexpr

Apply << to corresponding elements; a non-pack argument is broadcast.

Definition at line 518 of file wide.h.

operator<<=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a <<= b; }

wide< T, N > & native::operator<<= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise <<=; a scalar right side is broadcast.

Definition at line 718 of file wide.h.

operator<=()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a <= b; }

auto native::operator<= ( A const & a, B const & b )

inlineconstexpr

Apply <= to corresponding elements; a non-pack argument is broadcast.

Definition at line 572 of file wide.h.

operator==()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a == b; }

auto native::operator== ( A const & a, B const & b )

inlineconstexpr

Apply == to corresponding elements; a non-pack argument is broadcast.

Definition at line 536 of file wide.h.

operator>()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a > b; }

auto native::operator> ( A const & a, B const & b )

inlineconstexpr

Apply > to corresponding elements; a non-pack argument is broadcast.

Definition at line 563 of file wide.h.

operator>=()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a >= b; }

auto native::operator>= ( A const & a, B const & b )

inlineconstexpr

Apply >= to corresponding elements; a non-pack argument is broadcast.

Definition at line 581 of file wide.h.

operator>>()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a >> b; }

auto native::operator>> ( A const & a, B const & b )

inlineconstexpr

Apply >> to corresponding elements; a non-pack argument is broadcast.

Definition at line 527 of file wide.h.

operator>>=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a >>= b; }

wide< T, N > & native::operator>>= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise >>=; a scalar right side is broadcast.

Definition at line 727 of file wide.h.

operator^()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a ^ b; }

auto native::operator^ ( A const & a, B const & b )

inlineconstexpr

Apply ^ to corresponding elements; a non-pack argument is broadcast.

Definition at line 509 of file wide.h.

operator^=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a ^= b; }

wide< T, N > & native::operator^= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise ^=; a scalar right side is broadcast.

Definition at line 709 of file wide.h.

operator|()

template<class A, class B>
requires detail::wide_generic_detail::wide_arguments<A, B> && (::native::detail::wide_target<A,B> == NATIVE_WIDE_INDEX) &&
requires(detail::wide_generic_detail::wide_element_t<A> const & a, detail::wide_generic_detail::wide_element_t<B> const
& b) { a | b; }

auto native::operator| ( A const & a, B const & b )

inlineconstexpr

Apply | to corresponding elements; a non-pack argument is broadcast.

Definition at line 500 of file wide.h.

operator|=()

template<class T, std::size_t N, class B>
requires (::native::detail::wide_target<T,B> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_arguments<wide<T, N>, B> &&
(detail::wide_generic_detail::wide_traits<B>::value || std::copy_constructible<B>) && requires(T & a,
detail::wide_generic_detail::wide_element_t<B> const & b) { a |= b; }

wide< T, N > & native::operator|= ( wide< T, N > & a, B const & b )

inlineconstexpr

Update the left pack with elementwise |=; a scalar right side is broadcast.

Definition at line 700 of file wide.h.

operator~()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && requires(T const & a) { ~a; }

auto native::operator~ ( wide< T, N > const & a )

inlineconstexpr

Apply unary ~ to each element, retaining its result type.

Definition at line 603 of file wide.h.

Here is the caller graph for this function:

select()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX)

wide< R, N > native::select ( wide< decltype(R{}==R{}), N > const & masks, wide< R, N > const & a, wide< R, N > const & b )

inlineconstexprnoexcept

Choose from a or b according to the corresponding element mask.

Definition at line 1287 of file wide.h.

signbit()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_signbit,T>

auto native::signbit ( wide< T, N > const & input )

inlineconstexprnoexcept

Read each element's sign predicate, retaining its actual mask or bool type.

Definition at line 914 of file wide.h.

Here is the caller graph for this function:

sin()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_sin(x); }

wide< R, N > native::sin ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's sine operation in radians. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1003 of file wide.h.

Here is the caller graph for this function:

sincos()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x)
{ detail::wide_generic_detail::adl_sincos(x); }

auto native::sincos ( wide< R, N > const & input )

inlineconstexprnoexcept

Return paired sine and cosine packs using the element's paired operation. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1263 of file wide.h.

Here is the caller graph for this function:

sqrt()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_sqrt(x); }

wide< R, N > native::sqrt ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's square-root operation. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 982 of file wide.h.

tanh()

template<class R, std::size_t N>
requires (::native::detail::wide_target<R> == NATIVE_WIDE_INDEX) && requires(R const & x) { detail::wide_generic_detail::adl_tanh(x); }

wide< R, N > native::tanh ( wide< R, N > const & input )

inlineconstexprnoexcept

Apply the element library's hyperbolic tangent. Uses one array call when available, otherwise an elementwise fallback.

Definition at line 1193 of file wide.h.

Here is the caller graph for this function:

trunc()

template<class T, std::size_t N>
requires (::native::detail::wide_target<T> == NATIVE_WIDE_INDEX) && detail::wide_generic_detail::wide_value_operation<N,
detail::wide_generic_detail::wide_trunc,T> && std::same_as<detail::wide_generic_detail::wide_result
<detail::wide_generic_detail::wide_trunc,T>,T>

wide< T, N > native::trunc ( wide< T, N > const & input )

inlineconstexprnoexcept

Round each element toward zero, using its ADL operation and retaining the element type.

Definition at line 948 of file wide.h.