libstdc++
Data parallel extensions
Collaboration diagram for Data parallel extensions:

Macros

#define __cpp_lib_experimental_parallel_simd
 
using __m128 = float
 
using __m128d = double
 
using __m128i = long long
 
using __m256 = float
 
using __m256d = double
 
using __m256i = long long
 
using __m512 = float
 
using __m512d = double
 
using __m512i = long long
 
template<size_t _Xp>
using _SizeConstant = integral_constant< size_t, _Xp >
 
using _UChar = unsigned char
 
using _SChar = signed char
 
using _UShort = unsigned short
 
using _UInt = unsigned int
 
using _ULong = unsigned long
 
using _ULLong = unsigned long long
 
using _LLong = long long
 
template<typename... _Ts>
using __first_of_pack_t = typename __first_of_pack< _Ts... >::type
 
template<typename _Tp >
using __value_type_or_identity_t = decltype(__value_type_or_identity_impl< _Tp >(int()))
 
template<typename _Tp , typename = enable_if_t<__is_vectorizable_v<_Tp>>>
using _Vectorizable = _Tp
 
template<typename _Ptr , typename _ValueType , typename = enable_if_t< __is_possible_loadstore_conversion<_Ptr, _ValueType>::value>>
using _LoadStorePtr = _Ptr
 
template<typename _Tp >
using __int_for_sizeof_t = decltype(__int_for_sizeof< sizeof(_Tp)>())
 
template<size_t _Np>
using __int_with_sizeof_t = decltype(__int_for_sizeof< _Np >())
 
template<typename _Tp , typename _Up >
using __make_dependent_t = typename __make_dependent< _Tp, _Up >::type
 
template<typename _Tp >
using __may_alias = _Tp
 
template<size_t _Size>
using __bool_storage_member_type_t = typename __bool_storage_member_type< _Size >::type
 
template<typename _Tp , int _Np>
using __fixed_size_storage_t = typename __fixed_size_storage< _Tp, _Np >::type
 
template<typename _Tp >
using _SimdWrapper8 = _SimdWrapper< _Tp, 8/sizeof(_Tp)>
 
template<typename _Tp >
using _SimdWrapper16 = _SimdWrapper< _Tp, 16/sizeof(_Tp)>
 
template<typename _Tp >
using _SimdWrapper32 = _SimdWrapper< _Tp, 32/sizeof(_Tp)>
 
template<typename _Tp >
using _SimdWrapper64 = _SimdWrapper< _Tp, 64/sizeof(_Tp)>
 
template<typename _From , typename _To , typename = enable_if_t<negation< __is_narrowing_conversion<__remove_cvref_t<_From>, _To>>::value>>
using _ValuePreserving = _From
 
template<typename _From , typename _To , typename _DecayedFrom = __remove_cvref_t<_From>, typename = enable_if_t<conjunction< is_convertible<_From, _To>, disjunction< is_same<_DecayedFrom, _To>, is_same<_DecayedFrom, int>, conjunction<is_same<_DecayedFrom, _UInt>, is_unsigned<_To>>, negation<__is_narrowing_conversion<_DecayedFrom, _To>>>>::value>>
using _ValuePreservingOrInt = _From
 
template<typename _Tp , size_t _Size>
using __intrinsic_type_t = typename __intrinsic_type< _Tp, _Size *sizeof(_Tp)>::type
 
template<typename _Tp >
using __intrinsic_type2_t = typename __intrinsic_type< _Tp, 2 >::type
 
template<typename _Tp >
using __intrinsic_type4_t = typename __intrinsic_type< _Tp, 4 >::type
 
template<typename _Tp >
using __intrinsic_type8_t = typename __intrinsic_type< _Tp, 8 >::type
 
template<typename _Tp >
using __intrinsic_type16_t = typename __intrinsic_type< _Tp, 16 >::type
 
template<typename _Tp >
using __intrinsic_type32_t = typename __intrinsic_type< _Tp, 32 >::type
 
template<typename _Tp >
using __intrinsic_type64_t = typename __intrinsic_type< _Tp, 64 >::type
 
template<size_t _Np>
using _SanitizedBitMask = _BitMask< _Np, true >
 
template<typename _Tp , size_t _Size>
using __vector_type_t = typename __vector_type_n< _Tp, _Size >::type
 
template<typename _Tp >
using __vector_type2_t = typename __vector_type< _Tp, 2 >::type
 
template<typename _Tp >
using __vector_type4_t = typename __vector_type< _Tp, 4 >::type
 
template<typename _Tp >
using __vector_type8_t = typename __vector_type< _Tp, 8 >::type
 
template<typename _Tp >
using __vector_type16_t = typename __vector_type< _Tp, 16 >::type
 
template<typename _Tp >
using __vector_type32_t = typename __vector_type< _Tp, 32 >::type
 
template<typename _Tp >
using __vector_type64_t = typename __vector_type< _Tp, 64 >::type
 
template<typename _Tp , typename = typename _VectorTraitsImpl<_Tp>::type>
using _VectorTraits = _VectorTraitsImpl< _Tp >
 
template<typename _Tp , typename _V >
using rebind_simd_t = typename rebind_simd< _Tp, _V >::type
 
template<int _Np, typename _V >
using resize_simd_t = typename resize_simd< _Np, _V >::type
 
template<typename _Tp >
using native_simd = simd< _Tp, simd_abi::native< _Tp > >
 
template<typename _Tp , int _Np>
using fixed_size_simd = simd< _Tp, simd_abi::fixed_size< _Np > >
 
template<typename _Tp , size_t _Np>
using __deduced_simd = simd< _Tp, simd_abi::deduce_t< _Tp, _Np > >
 
template<typename _Tp >
using native_simd_mask = simd_mask< _Tp, simd_abi::native< _Tp > >
 
template<typename _Tp , int _Np>
using fixed_size_simd_mask = simd_mask< _Tp, simd_abi::fixed_size< _Np > >
 
template<typename _Tp , size_t _Np>
using __deduced_simd_mask = simd_mask< _Tp, simd_abi::deduce_t< _Tp, _Np > >
 
template<typename _Tp >
using safe_make_signed_t = typename __safe_make_signed< _Tp >::type
 
constexpr element_aligned_tag element_aligned
 
constexpr vector_aligned_tag vector_aligned
 
template<size_t _Np>
constexpr overaligned_tag< _Np > overaligned
 
template<typename _Tp >
constexpr bool __is_vectorizable_v
 
template<typename _Tp >
constexpr bool __is_bitmask_v
 
template<typename _Tp >
constexpr bool __is_fixed_size_abi_v
 
constexpr bool __have_mmx
 
constexpr bool __have_sse
 
constexpr bool __have_sse2
 
constexpr bool __have_sse3
 
constexpr bool __have_ssse3
 
constexpr bool __have_sse4_1
 
constexpr bool __have_sse4_2
 
constexpr bool __have_xop
 
constexpr bool __have_avx
 
constexpr bool __have_avx2
 
constexpr bool __have_bmi
 
constexpr bool __have_bmi2
 
constexpr bool __have_lzcnt
 
constexpr bool __have_sse4a
 
constexpr bool __have_fma
 
constexpr bool __have_fma4
 
constexpr bool __have_f16c
 
constexpr bool __have_popcnt
 
constexpr bool __have_avx512f
 
constexpr bool __have_avx512dq
 
constexpr bool __have_avx512vl
 
constexpr bool __have_avx512bw
 
constexpr bool __have_avx512dq_vl
 
constexpr bool __have_avx512bw_vl
 
constexpr bool __have_neon
 
constexpr bool __have_neon_a32
 
constexpr bool __have_neon_a64
 
constexpr bool __support_neon_float
 
constexpr bool __have_power10vec
 
constexpr bool __have_power9vec
 
constexpr bool __have_power8vec
 
constexpr bool __have_power_vsx
 
constexpr bool __have_power_vmx
 
template<typename _Abi >
constexpr int __abi_bytes_v
 
template<typename _Tp , typename _Ap >
constexpr size_t __size_or_zero_v
 
constexpr struct _PrivateInit __private_init
 
constexpr struct _BitsetInit __bitset_init
 
template<typename _Tp >
constexpr bool __is_simd_wrapper_v
 
template<typename _Tp = void>
static constexpr int __min_vector_size
 
template<>
constexpr int __min_vector_size< void >
 
template<typename _Tp >
constexpr bool __is_vector_type_v
 
template<typename _Tp >
constexpr bool __is_intrinsic_type_v
 
template<typename _Tp >
constexpr bool is_abi_tag_v
 
template<typename _Tp >
constexpr bool is_simd_v
 
template<typename _Tp >
constexpr bool is_simd_mask_v
 
template<typename _Tp , typename _Abi = simd_abi::__default_abi<_Tp>>
constexpr size_t simd_size_v
 
template<typename _Tp , typename _Up = typename _Tp::value_type>
constexpr size_t memory_alignment_v
 
template<typename _Fp , size_t... _I>
constexpr _GLIBCXX_SIMD_INTRINSIC void __execute_on_index_sequence (_Fp &&__f, index_sequence< _I... >)
 
template<typename _Fp >
constexpr _GLIBCXX_SIMD_INTRINSIC void __execute_on_index_sequence (_Fp &&, index_sequence<>)
 
template<size_t _Np, typename _Fp >
constexpr _GLIBCXX_SIMD_INTRINSIC void __execute_n_times (_Fp &&__f)
 
template<typename _R , typename _Fp , size_t... _I>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __execute_on_index_sequence_with_return (_Fp &&__f, index_sequence< _I... >)
 
template<size_t _Np, typename _R , typename _Fp >
constexpr _GLIBCXX_SIMD_INTRINSIC _R __generate_from_n_evaluations (_Fp &&__f)
 
template<size_t... _I, typename _F0 , typename _FArgs >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __call_with_n_evaluations (index_sequence< _I... >, _F0 &&__f0, _FArgs &&__fargs)
 
template<size_t _Np, typename _F0 , typename _FArgs >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __call_with_n_evaluations (_F0 &&__f0, _FArgs &&__fargs)
 
template<size_t _First = 0, size_t... _It, typename _Tp , typename _Fp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __call_with_subscripts (_Tp &&__x, index_sequence< _It... >, _Fp &&__fun)
 
template<size_t _Np, size_t _First = 0, typename _Tp , typename _Fp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __call_with_subscripts (_Tp &&__x, _Fp &&__fun)
 
template<typename _Tp >
_Tp::value_type __value_type_or_identity_impl (int)
 
template<typename _Tp >
_Tp __value_type_or_identity_impl (float)
 
template<size_t _Bytes>
constexpr auto __int_for_sizeof ()
 
template<typename _Abi >
constexpr bool __is_scalar_abi ()
 
template<template< int > class _Abi, int _Bytes>
constexpr int __abi_bytes_impl (_Abi< _Bytes > *)
 
template<typename _Tp >
constexpr int __abi_bytes_impl (_Tp *)
 
template<typename _Abi >
constexpr bool __is_builtin_bitmask_abi ()
 
template<typename _Abi >
constexpr bool __is_sse_abi ()
 
template<typename _Abi >
constexpr bool __is_avx_abi ()
 
template<typename _Abi >
constexpr bool __is_avx512_abi ()
 
template<typename _Abi >
constexpr bool __is_neon_abi ()
 
template<typename... _Args>
_GLIBCXX_SIMD_ALWAYS_INLINE void __invoke_ub ([[maybe_unused]] const char *__msg, [[maybe_unused]] const _Args &... __args)
 
template<typename _Tp , typename _Ap , size_t _Np = simd_size<_Tp, _Ap>::value>
constexpr size_t __size_or_zero_dispatch (int)
 
template<typename _Tp , typename _Ap >
constexpr size_t __size_or_zero_dispatch (float)
 
constexpr size_t __div_roundup (size_t __a, size_t __b)
 
template<typename _Tp , typename _Ap >
constexpr _GLIBCXX_SIMD_INTRINSIC const auto & __data (const simd< _Tp, _Ap > &__x)
 
template<typename _Tp , typename _Ap >
constexpr _GLIBCXX_SIMD_INTRINSIC auto & __data (simd< _Tp, _Ap > &__x)
 
template<typename _Tp , typename _Ap >
constexpr _GLIBCXX_SIMD_INTRINSIC const auto & __data (const simd_mask< _Tp, _Ap > &__x)
 
template<typename _Tp , typename _Ap >
constexpr _GLIBCXX_SIMD_INTRINSIC auto & __data (simd_mask< _Tp, _Ap > &__x)
 
template<typename _V >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __to_value_type_or_member_type (const _V &__x) -> decltype(__data(__x))
 
template<typename _V >
constexpr _GLIBCXX_SIMD_INTRINSIC const _V::value_type & __to_value_type_or_member_type (const typename _V::value_type &__x)
 
template<typename _V >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __as_vector (_V __x)
 
template<size_t _Np = 0, typename _V >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __as_wrapper (_V __x)
 
template<typename _To , typename _From >
constexpr _GLIBCXX_SIMD_INTRINSIC _To __intrin_bitcast (_From __v)
 
template<typename _To , size_t _NN = 0, typename _From , typename _FromVT = _VectorTraits<_From>, size_t _Np = _NN == 0 ? sizeof(_From) / sizeof(_To) : _NN>
constexpr _GLIBCXX_SIMD_INTRINSIC __vector_type_t< _To, _Np > __vector_bitcast (_From __x)
 
template<typename _To , size_t _NN = 0, typename _Tp , size_t _Nx, size_t _Np = _NN == 0 ? sizeof(_SimdWrapper<_Tp, _Nx>) / sizeof(_To) : _NN>
constexpr _GLIBCXX_SIMD_INTRINSIC __vector_type_t< _To, _Np > __vector_bitcast (const _SimdWrapper< _Tp, _Nx > &__x)
 
template<typename _To , typename _From >
constexpr _GLIBCXX_SIMD_INTRINSIC _To __bit_cast (const _From __x)
 
template<typename _Tp , typename _TVT = _VectorTraits<_Tp>, typename _R = __intrinsic_type_t<typename _TVT::value_type, _TVT::_S_full_size>>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __to_intrin (_Tp __x)
 
template<typename _Tp , typename... _Args>
constexpr _GLIBCXX_SIMD_INTRINSIC __vector_type_t< _Tp, sizeof...(_Args)> __make_vector (const _Args &... __args)
 
template<size_t _Np, typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC __vector_type_t< _Tp, _Np > __vector_broadcast (_Tp __x)
 
template<typename _Tp , size_t _Np, typename _Gp , size_t... _I>
constexpr _GLIBCXX_SIMD_INTRINSIC __vector_type_t< _Tp, _Np > __generate_vector_impl (_Gp &&__gen, index_sequence< _I... >)
 
template<typename _V , typename _VVT = _VectorTraits<_V>, typename _Gp >
constexpr _GLIBCXX_SIMD_INTRINSIC _V __generate_vector (_Gp &&__gen)
 
template<typename _TW >
constexpr _GLIBCXX_SIMD_INTRINSIC _TW __xor (_TW __a, _TW __b) noexcept
 
template<typename _TW >
constexpr _GLIBCXX_SIMD_INTRINSIC _TW __or (_TW __a, _TW __b) noexcept
 
template<typename _TW >
constexpr _GLIBCXX_SIMD_INTRINSIC _TW __and (_TW __a, _TW __b) noexcept
 
template<typename _TW >
constexpr _GLIBCXX_SIMD_INTRINSIC _TW __andnot (_TW __a, _TW __b) noexcept
 
template<typename _Tp , typename _TVT = _VectorTraits<_Tp>>
constexpr _GLIBCXX_SIMD_INTRINSIC _Tp __not (_Tp __a) noexcept
 
template<typename _Tp , typename _TVT = _VectorTraits<_Tp>, typename _R = __vector_type_t<typename _TVT::value_type, _TVT::_S_full_size * 2>>
constexpr _R __concat (_Tp a_, _Tp b_)
 
template<typename _Tp , typename _TVT = _VectorTraits<_Tp>>
_GLIBCXX_SIMD_INTRINSIC _ZeroExtendProxy< _Tp, _TVT > __zero_extend (_Tp __x)
 
template<int _Offset, int _SplitBy, typename _Tp , typename _TVT = _VectorTraits<_Tp>, typename _R = __vector_type_t<typename _TVT::value_type, _TVT::_S_full_size / _SplitBy>>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __extract (_Tp __in)
 
template<typename _Tp , typename _R = __vector_type8_t<typename _VectorTraits<_Tp>::value_type>>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __lo64 (_Tp __x)
 
template<typename _Tp , typename _R = __vector_type8_t<typename _VectorTraits<_Tp>::value_type>>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __hi64 (_Tp __x)
 
template<typename _Tp , typename _R = __vector_type8_t<typename _VectorTraits<_Tp>::value_type>>
constexpr _GLIBCXX_SIMD_INTRINSIC _R __hi64z ([[maybe_unused]] _Tp __x)
 
template<typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __lo128 (_Tp __x)
 
template<typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __hi128 (_Tp __x)
 
template<typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __lo256 (_Tp __x)
 
template<typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC auto __hi256 (_Tp __x)
 
template<typename _Tp >
constexpr _GLIBCXX_SIMD_INTRINSIC _AutoCast< _Tp > __auto_bitcast (const _Tp &__x)
 
template<typename _Tp , size_t _Np>
constexpr _GLIBCXX_SIMD_INTRINSIC _AutoCast< typename _SimdWrapper< _Tp, _Np >::_BuiltinType > __auto_bitcast (const _SimdWrapper< _Tp, _Np > &__x)
 
template<typename _Tp >
constexpr size_t __vectorized_sizeof ()
 
template<typename _Tp , typename _Up , typename _Ap , typename _R = typename __static_simd_cast_return_type<_Tp, _Up, _Ap>::type>
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _R static_simd_cast (const simd< _Up, _Ap > &__x)
 
template<typename _Tp , typename _Up , typename _Ap , typename _To = __value_type_or_identity_t<_Tp>>
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR auto simd_cast (const simd< _ValuePreserving< _Up, _To >, _Ap > &__x) -> decltype(static_simd_cast< _Tp >(__x))
 
template<typename _Tp , int _Np>
_GLIBCXX_SIMD_INTRINSIC fixed_size_simd< _Tp, _Np > to_fixed_size (const fixed_size_simd< _Tp, _Np > &__x)
 
template<typename _Tp , int _Np>
_GLIBCXX_SIMD_INTRINSIC fixed_size_simd_mask< _Tp, _Np > to_fixed_size (const fixed_size_simd_mask< _Tp, _Np > &__x)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC auto to_fixed_size (const simd< _Tp, _Ap > &__x)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC auto to_fixed_size (const simd_mask< _Tp, _Ap > &__x)
 
template<typename _Tp , int _Np>
_GLIBCXX_SIMD_INTRINSIC enable_if_t<(_Np==native_simd< _Tp >::size()), native_simd< _Tp > > to_native (const fixed_size_simd< _Tp, _Np > &__x)
 
template<typename _Tp , size_t _Np>
_GLIBCXX_SIMD_INTRINSIC enable_if_t<(_Np==native_simd_mask< _Tp >::size()), native_simd_mask< _Tp > > to_native (const fixed_size_simd_mask< _Tp, _Np > &__x)
 
template<typename _Tp , size_t _Np>
_GLIBCXX_SIMD_INTRINSIC enable_if_t<(_Np==simd< _Tp >::size()), simd< _Tp > > to_compatible (const simd< _Tp, simd_abi::fixed_size< _Np >> &__x)
 
template<typename _Tp , size_t _Np>
_GLIBCXX_SIMD_INTRINSIC enable_if_t<(_Np==simd_mask< _Tp >::size()), simd_mask< _Tp > > to_compatible (const simd_mask< _Tp, simd_abi::fixed_size< _Np >> &__x)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC where_expression< simd_mask< _Tp, _Ap >, simd< _Tp, _Ap > > where (const typename simd< _Tp, _Ap >::mask_type &__k, simd< _Tp, _Ap > &__value)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC const_where_expression< simd_mask< _Tp, _Ap >, simd< _Tp, _Ap > > where (const typename simd< _Tp, _Ap >::mask_type &__k, const simd< _Tp, _Ap > &__value)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC where_expression< simd_mask< _Tp, _Ap >, simd_mask< _Tp, _Ap > > where (const remove_const_t< simd_mask< _Tp, _Ap >> &__k, simd_mask< _Tp, _Ap > &__value)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC const_where_expression< simd_mask< _Tp, _Ap >, simd_mask< _Tp, _Ap > > where (const remove_const_t< simd_mask< _Tp, _Ap >> &__k, const simd_mask< _Tp, _Ap > &__value)
 
template<typename _Tp >
_GLIBCXX_SIMD_INTRINSIC where_expression< bool, _Tp > where (_ExactBool __k, _Tp &__value)
 
template<typename _Tp >
_GLIBCXX_SIMD_INTRINSIC const_where_expression< bool, _Tp > where (_ExactBool __k, const _Tp &__value)
 
template<typename _Tp , typename _Ap >
void where (bool __k, simd< _Tp, _Ap > &__value)=delete
 
template<typename _Tp , typename _Ap >
void where (bool __k, const simd< _Tp, _Ap > &__value)=delete
 
template<typename _Tp , typename _Abi , typename _BinaryOperation = plus<>>
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _Tp reduce (const simd< _Tp, _Abi > &__v, _BinaryOperation __binary_op=_BinaryOperation())
 
template<typename _M , typename _V , typename _BinaryOperation = plus<>>
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, typename _V::value_type __identity_element, _BinaryOperation __binary_op)
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, plus<> __binary_op={})
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, multiplies<> __binary_op)
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, bit_and<> __binary_op)
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, bit_or<> __binary_op)
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _V::value_type reduce (const const_where_expression< _M, _V > &__x, bit_xor<> __binary_op)
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _Tp hmin (const simd< _Tp, _Abi > &__v) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _Tp hmax (const simd< _Tp, _Abi > &__v) noexcept
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _V::value_type hmin (const const_where_expression< _M, _V > &__x) noexcept
 
template<typename _M , typename _V >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR _V::value_type hmax (const const_where_expression< _M, _V > &__x) noexcept
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR simd< _Tp, _Ap > min (const simd< _Tp, _Ap > &__a, const simd< _Tp, _Ap > &__b)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR simd< _Tp, _Ap > max (const simd< _Tp, _Ap > &__a, const simd< _Tp, _Ap > &__b)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR pair< simd< _Tp, _Ap >, simd< _Tp, _Ap > > minmax (const simd< _Tp, _Ap > &__a, const simd< _Tp, _Ap > &__b)
 
template<typename _Tp , typename _Ap >
_GLIBCXX_SIMD_INTRINSIC _GLIBCXX_SIMD_CONSTEXPR simd< _Tp, _Ap > clamp (const simd< _Tp, _Ap > &__v, const simd< _Tp, _Ap > &__lo, const simd< _Tp, _Ap > &__hi)
 
template<size_t... _Sizes, typename _Tp , typename _Ap , typename = enable_if_t<((_Sizes + ...) == simd<_Tp, _Ap>::size())>>
tuple< simd< _Tp, simd_abi::deduce_t< _Tp, _Sizes > >... > split (const simd< _Tp, _Ap > &)
 
template<int _Index, int _Total, int _Combine = 1, typename _Tp , size_t _Np>
_GLIBCXX_SIMD_INTRINSIC _SimdWrapper< _Tp, _Np/_Total *_Combine > __extract_part (const _SimdWrapper< _Tp, _Np > __x)
 
template<int Index, int Parts, int _Combine = 1, typename _Tp , typename _A0 , typename... _As>
_GLIBCXX_SIMD_INTRINSIC auto __extract_part (const _SimdTuple< _Tp, _A0, _As... > &__x)
 
template<typename _Tp , size_t _Np>
_GLIBCXX_SIMD_INTRINSIC _SimdWrapper< _Tp, _Np/2 > __extract_center (_SimdWrapper< _Tp, _Np > __x)
 
template<typename _Tp , typename _A0 , typename... _As>
_GLIBCXX_SIMD_INTRINSIC _SimdWrapper< _Tp, _SimdTuple< _Tp, _A0, _As... >::_S_size()/2 > __extract_center (const _SimdTuple< _Tp, _A0, _As... > &__x)
 
template<size_t... _Sizes, typename _Tp , typename... _As>
auto __split_wrapper (_SizeList< _Sizes... >, const _SimdTuple< _Tp, _As... > &__x)
 
template<typename _V , typename _Ap , size_t Parts = simd_size_v<typename _V::value_type, _Ap> / _V::size()>
enable_if_t< simd_size_v< typename _V::value_type, _Ap >==Parts *_V::size() &&is_simd_v< _V >, array< _V, Parts > > split (const simd< typename _V::value_type, _Ap > &__x)
 
template<typename _V , typename _Ap , size_t _Parts = simd_size_v<typename _V::simd_type::value_type, _Ap> / _V::size()>
enable_if_t< is_simd_mask_v< _V > &&simd_size_v< typename _V::simd_type::value_type, _Ap >==_Parts *_V::size(), array< _V, _Parts > > split (const simd_mask< typename _V::simd_type::value_type, _Ap > &__x)
 
template<size_t _I, typename _Tp , typename _Ap , typename... _As>
constexpr _GLIBCXX_SIMD_INTRINSIC _Tp __subscript_in_pack (const simd< _Tp, _Ap > &__x, const simd< _Tp, _As > &... __xs)
 
template<typename _Tp , typename _A0 , typename... _As>
_GLIBCXX_SIMD_INTRINSIC void __store_pack_of_simd (char *__mem, const simd< _Tp, _A0 > &__x0, const simd< _Tp, _As > &... __xs)
 
template<typename _Tp , typename... _As>
_GLIBCXX_SIMD_CONSTEXPR simd< _Tp, simd_abi::deduce_t< _Tp,(simd_size_v< _Tp, _As >+...)> > concat (const simd< _Tp, _As > &... __xs)
 
template<typename _Tp , typename _Abi , size_t _Np>
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR __deduced_simd< _Tp, simd_size_v< _Tp, _Abi > *_Np > concat (const array< simd< _Tp, _Abi >, _Np > &__x)
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool all_of (const simd_mask< _Tp, _Abi > &__k) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool any_of (const simd_mask< _Tp, _Abi > &__k) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool none_of (const simd_mask< _Tp, _Abi > &__k) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool some_of (const simd_mask< _Tp, _Abi > &__k) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int popcount (const simd_mask< _Tp, _Abi > &__k) noexcept
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int find_first_set (const simd_mask< _Tp, _Abi > &__k)
 
template<typename _Tp , typename _Abi >
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int find_last_set (const simd_mask< _Tp, _Abi > &__k)
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool all_of (_ExactBool __x) noexcept
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool any_of (_ExactBool __x) noexcept
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool none_of (_ExactBool __x) noexcept
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR bool some_of (_ExactBool) noexcept
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int popcount (_ExactBool __x) noexcept
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int find_first_set (_ExactBool)
 
_GLIBCXX_SIMD_ALWAYS_INLINE _GLIBCXX_SIMD_CONSTEXPR int find_last_set (_ExactBool)
 

Detailed Description

Data-parallel types library.

Since
C++17