|
| template<saturation_integer To, saturation_integer From> |
| constexpr To | saturating_cast (From value) noexcept |
|
template<saturation_integer T> |
| constexpr T | saturating_add (T lhs, T rhs) noexcept |
| | Add two integers, clamping an unrepresentable mathematical result.
|
|
template<saturation_integer T> |
| constexpr T | saturating_sub (T lhs, T rhs) noexcept |
| | Subtract two integers, clamping an unrepresentable mathematical result.
|
|
template<saturation_integer T> |
| constexpr T | saturating_mul (T lhs, T rhs) noexcept |
| | Multiply two integers, clamping an unrepresentable mathematical result.
|
|
template<saturation_integer T> |
| constexpr T | saturating_div (T lhs, T rhs) noexcept |
| | Divide two integers, clamping an unrepresentable mathematical result.
|
| template<funnel_shift_source T, std::integral S> |
| constexpr T | funnel_shift_right (T high, T low, S s) noexcept |
| template<funnel_shift_source T, std::integral S> |
| constexpr T | funnel_shift_left (T high, T low, S s) noexcept |
template<class To, class From>
requires roundtrippable<From, To> |
| constexpr bool | roundtrip_preserves_value (From x) |
|
constexpr auto | add_unchecked_flag (auto f) |
|
constexpr auto | add_convert_flag (auto f) |
|
template<typename _F, typename... _Flags> |
| constexpr bool | contains_flag (flags< _Flags... >) |
| | Query whether the given flags contains the specified type.
|
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_take (generic_tag, const _Sp &in) |
| | A named permute which keeps the first _Np values of a simd and discards the remainder.
|
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_drop (generic_tag, const _Sp &in) noexcept |
| | A named permute which discards the first _Np values of a vec or mask, returning the remainder.
|
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_repeat_all (generic_tag, const _Sp &in) noexcept |
| | A named permute which creates N copies of the input concatenated together.
|
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_repeat_each (generic_tag, const _Sp &in) noexcept |
| | A named permute which creates N copies of each element.
|
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_stride (generic_tag, const _Sp &in) noexcept |
| | A named permute which extracts every N'th value, discarding values which do not have indexes which are multiples of N.
|
|
template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_grow (generic_tag, const _Sp &in) noexcept |
| | A named permute which increases the number of elements in the vec or mask, placing a copy of the given value into the new element positions.
|
|
template<int _Np, vec_type _Vp> |
| constexpr auto | permute_grow (generic_tag, const _Vp &in, typename _Vp::value_type fill) noexcept |
|
template<int _Np, mask_type _Mp> |
| constexpr auto | permute_grow (generic_tag, const _Mp &in, bool fill) noexcept |
|
template<vec_or_mask_type _Sp> |
| constexpr auto | permute_reverse (generic_tag, const _Sp &in) |
| | Reverse the order in which the elements appear in the given input vec or mask.
|
| template<int _Middle, vec_or_mask_type _Sp> |
| constexpr auto | permute_rotate (generic_tag, const _Sp &in) noexcept |
| | A named permute which rotates the input so that the element at the MIDDLE index becomes the first element.
|
|
template<int ROWS, int COLS, vec_or_mask_type _Sp> |
| constexpr auto | permute_transpose (generic_tag, const _Sp &in) noexcept |
| template<vec_or_mask_type... _Sps> |
| constexpr auto | permute_zip (generic_tag, const _Sps &...simds) noexcept |
| template<int _Np, vec_or_mask_type _Sp> |
| constexpr auto | permute_unzip (generic_tag, const _Sp &in) noexcept |
| | Unzip breaks a vec or mask down into N smaller objects, where each vec or mask is the values at the stride of N and offset by the output index. For example, unzip<2>([a 0 b 1 c 2]) will become [a b c] [0 1 2].
|
|
template<simd_size_type _Begin, simd_size_type _End, vec_or_mask_type _Vp> |
| constexpr auto | extract (generic_tag, const _Vp &v) |
|
template<simd_size_type _Begin, simd_size_type _End, mask_type _Mp> |
| constexpr auto | extract (compact_mask_tag, const _Mp &m) |
template<simd_size_type _Begin, vec_or_mask_type _Container, vec_or_mask_type _Child>
requires (vec_or_mask_same_element_type<_Container, _Child>) |
| constexpr _Container | insert (generic_tag, const _Container &container, const _Child &child) noexcept |
template<simd_size_type _Begin, mask_type _Container, mask_type _Child>
requires (vec_or_mask_same_element_type<_Container, _Child>) |
| constexpr _Container | insert (compact_mask_tag, const _Container &container, const _Child &child) noexcept |
|
template<vec_or_mask_type _Vp, typename _Op> |
| constexpr auto | builtin_operator (generic_tag, _Vp value, _Op op) |
| | General purpose unary operator. Passes through to the compiler's own builtin.
|
| template<vec_type _Vp> |
| constexpr auto | builtin_operator (generic_tag, _Vp value, std::logical_not<>) |
|
template<vec_or_mask_type _Vp, typename _Op> |
| constexpr auto | builtin_operator (generic_tag, _Vp lhs, _Vp rhs, _Op op) |
| | General purpose binary operator.
|
template<vec_integral _Vp, typename _Op>
requires (any_same_v<_Op, std::divides<>, std::modulus<>>) |
| constexpr _Vp | builtin_operator (generic_tag, _Vp lhs, _Vp rhs, _Op) |
| | Special treatment for integral divide and modulus. These often cause hardware exceptions if zero is used in the denominator. Such exceptions should only be raised on the active data in the vec.
|
|
template<vec_complex _Vp> |
| constexpr auto | builtin_operator (generic_tag, const _Vp &lhs, const _Vp &rhs, std::multiplies<>) |
| | Generic complex multipler forwards to the complex FMA.
|
| template<vec_type _Vp, mask_operator _Op> |
| constexpr auto | builtin_operator (compact_mask_tag, const _Vp &x, const _Vp &y, _Op) |
template<typename FN, vec_type _Vp, typename... Args>
requires (std::same_as<Args, _Vp> && ...) |
| constexpr auto | make_mask_from_op (const _Vp &first, const Args &... args) noexcept |
| template<typename FN, vec_type _Vp, vec_type... _Vps> |
| constexpr auto | do_operator (const _Vp &first, const _Vps &... rest) noexcept |
|
template<vec_type _To, vec_type _From> |
| constexpr _To | convert_operator (const _From &v) noexcept |
| | Conversion operator for basic_vec. All gate-keeping has been done, just do the convert.
|
| template<mask_type _M, vec_type _V> |
| constexpr _M | vec_to_mask (const _V &s) |
| template<vec_type _V> |
| constexpr auto | to_container (const _V &v) |
|
template<typename _Op, typename _Tp> |
| constexpr auto | choose_identity_element () |
| template<simd_size_type _Size, typename _Tp, typename _Abi, binary_reduction_fn< _Tp > _BinaryFn> |
| _Tp | reduce_helper (const basic_vec< _Tp, _Abi > &v, _BinaryFn binop) |
| template<typename _Tuple> |
| constexpr auto | get_array_from_tuple (_Tuple &&tuple) |
| template<simd_size_type _Begin, simd_size_type _Np, vec_or_mask_type _Sp> |
| constexpr auto | splitNHelper (const _Sp &v) |
| template<simd_size_type _Begin, typename _Result, typename _Sp> |
| constexpr _Result | concatHelper (const _Result &container, const _Sp &head, const vec_or_mask_type auto &... tail) |
| template<math_floating_point _Vp> |
| constexpr deduced_mask_t< _Vp > | isnan (generic_tag, const _Vp &v) |
| template<detail::math_floating_point _Vp> |
| constexpr detail::deduced_mask_t< _Vp > | isinf (generic_tag tag, const _Vp &v) |
| template<detail::math_floating_point _Vp> |
| constexpr detail::deduced_mask_t< _Vp > | isfinite (generic_tag tag, const _Vp &v) |
| template<detail::math_floating_point _Vp> |
| constexpr detail::deduced_mask_t< _Vp > | isnormal (generic_tag, const _Vp &v) |
| template<detail::math_floating_point _Vp> |
| constexpr detail::deduced_mask_t< _Vp > | signbit (generic_tag, const _Vp &v) |
| template<typename> |
| consteval auto | get_register_type () |
|
template<class... Ts> |
| | target_overloads (Ts...) -> target_overloads< Ts... > |
|
template<typename _Tp> |
| constexpr auto | get_span_static_extent (const _Tp &in) |
| | Query the extent of a given type.
|
| template<typename _Span> |
| constexpr auto | get_span_element_type_helper (const _Span &in) |
|
template<math_floating_point _Vp> |
| constexpr deduced_vec_t< _Vp > | maths_fn (const _Vp &v, auto op) |
|
template<math_floating_point _Vp> |
| constexpr deduced_vec_t< _Vp > | maths_fn (const _Vp &v0, const _Vp &v1, auto op) |
| template<math_floating_point _Vp, typename OP_IMPL> |
| constexpr deduced_vec_t< _Vp > | maths_fn (const _Vp &v, OP_IMPL op_impl) |
|
template<math_floating_point _Vp, typename OP_IMPL> |
| constexpr deduced_vec_t< _Vp > | maths_fn (const _Vp &v0, const _Vp &v1, OP_IMPL op_impl) |
| template<typename _Tp, typename _AbiT, typename _Ip, typename _AbiI> |
| constexpr auto | permute_large_elements (const basic_vec< _Tp, _AbiT > &values, const basic_vec< _Ip, _AbiI > &indexes) |
| template<typename _Tp, typename _AbiT, typename _Ip, typename _AbiI> |
| constexpr auto | permute_byte_shuffle (const basic_vec< _Tp, _AbiT > &v, const basic_vec< _Ip, _AbiI > &indexes) |
template<std::unsigned_integral _Tp, typename _AbiT, std::integral _Ip, typename _AbiI>
requires (sizeof(basic_vec<_Tp, _AbiT>) <= 32) |
| auto | permute_x86_register (x86_avx2_tag, const basic_vec< _Tp, _AbiT > &v, const basic_vec< _Ip, _AbiI > &indexes) |
| | Permute one register of Intel AVX2 values.
|
template<std::unsigned_integral _Tp, typename _AbiT, std::integral _Ip, typename _AbiI>
requires (basic_vec<_Tp, _AbiT>::size <= vec<_Tp>::size) |
| auto | permute_x86_register (x86_avx512_tag, const basic_vec< _Tp, _AbiT > &v, const basic_vec< _Ip, _AbiI > &indexes) |
| | Permute one register of Intel AVX-512 values.
|
template<std::unsigned_integral _Tp, typename _AbiT, std::integral _Ip, typename _AbiI>
requires (basic_vec<_Tp, _AbiT>::size > vec<_Tp>::size && basic_vec<_Tp, _AbiT>::size <= 2 * vec<_Tp>::size && sizeof(_Tp) == sizeof(_Ip)) |
| auto | permute_x86_register (x86_avx512_tag, const basic_vec< _Tp, _AbiT > &v, const basic_vec< _Ip, _AbiI > &indexes) |
| | Permute two Intel AVX-512 registers of values (including 2 Intel AVX10 registers).
|
|
template<std::unsigned_integral _Tp, typename _AbiT, vec_integral _Ip> |
| auto | permute_recurse (const basic_vec< _Tp, _AbiT > &values, const _Ip &indexes) |
| template<typename _Tp, typename _AbiTp, std::integral _Ip, typename _AbiIp, std::derived_from< x86_avx2_tag > VENDOR> |
| constexpr basic_vec< _Tp, _AbiIp > | permute (VENDOR tag, const basic_vec< _Tp, _AbiTp > &v, const basic_vec< _Ip, _AbiIp > &indexes) |
|
template<std::size_t _BytesTp, typename _AbiTp, typename _Ip, typename _AbiIp> |
| constexpr basic_mask< _BytesTp, _AbiIp > | permute (x86_avx512_tag, const basic_mask< _BytesTp, _AbiTp > &m, const basic_vec< _Ip, _AbiIp > &indexes) |
|
template<simd_size_type _OutSize, std::size_t _Bytes, typename _Abi, typename _Gp> |
| constexpr auto | generated_permute (x86_avx512_tag, const basic_mask< _Bytes, _Abi > &m, _Gp) |
| | Use a generator to permute a compact bit mask.
|
| template<int _Np, mask_type _Mp> |
| constexpr auto | permute_drop (x86_avx512_tag, const _Mp &in) noexcept |
| | A named permute which discards the first _Np values of a vec, returning the remainder.
|
|
template<int _Np, mask_type _Mp> |
| constexpr auto | permute_take (x86_avx512_tag, const _Mp &in) noexcept |
| | Create a mask containing only the first _Np elements. The remaining elements are discarded.
|
|
template<int _Np, mask_type _Mp> |
| constexpr auto | permute_grow (x86_avx512_tag, const _Mp &in) noexcept |
| | Make the given mask grow to _Np elements, filling the extra elements with false.
|
|
template<int _Np, mask_type _Mp> |
| constexpr auto | permute_grow (x86_avx512_tag, const _Mp &in, bool fill) noexcept |
| | Make the given mask grow to _Np elements, filling the extra elements with the supplied value.
|
| template<mask_type _Mp, int _Stride> |
| constexpr auto | every_nth_bit () |
|
template<mask_type _Mp> |
| constexpr std::bitset< _Mp::size > | mask_to_bitset (x86_sse_tag, const _Mp &mask) noexcept |
|
template<mask_type _Mp> |
| constexpr std::bitset< _Mp::size > | mask_to_bitset (x86_avx512_tag, const _Mp &mask) noexcept |
|
template<std::floating_point _Tp, typename _Abi> |
| constexpr basic_vec< _Tp, _Abi > | fma (x86_avx2_tag, const basic_vec< _Tp, _Abi > &x, const basic_vec< _Tp, _Abi > &y, const basic_vec< _Tp, _Abi > &acc) |
|
template<std::floating_point _Tp, typename _Abi> |
| constexpr basic_vec< _Tp, _Abi > | fmaddsub (x86_avx2_tag, const basic_vec< _Tp, _Abi > &x, const basic_vec< _Tp, _Abi > &y, const basic_vec< _Tp, _Abi > &acc) |
|
template<std::floating_point _Tp, typename _Abi> |
| constexpr basic_vec< _Tp, _Abi > | fmsubadd (x86_avx2_tag, const basic_vec< _Tp, _Abi > &x, const basic_vec< _Tp, _Abi > &y, const basic_vec< _Tp, _Abi > &acc) |
| template<vec_type _Vp> |
| constexpr _Vp | set_element (generic_tag, const _Vp &v, int index, typename _Vp::value_type new_value) |
| template<mask_type _Mp> |
| constexpr _Mp | set_element (generic_tag, const _Mp &m, int index, bool new_value) |
| template<mask_type _Mp> |
| constexpr _Mp | set_element (compact_mask_tag, const _Mp &m, int index, bool new_value) |
template<RoundOp _Op, typename _Tp, typename _Abi>
requires (detail::is_floating_point_v<_Tp>) |
| constexpr basic_vec< _Tp, _Abi > | round_op (x86_tag, const basic_vec< _Tp, _Abi > &v) |
| | Rounding operations (ceil, floor, etc.).
|
|
|
template<typename> |
| constexpr bool | is_vec_v = false |
|
template<typename _Tp, typename _Abi> |
| constexpr bool | is_vec_v< basic_vec< _Tp, _Abi > > = true |
|
template<typename> |
| constexpr bool | is_mask_v = false |
|
template<std::size_t _Bytes, typename _Abi> |
| constexpr bool | is_mask_v< basic_mask< _Bytes, _Abi > > = true |
| template<typename _From, typename _To> |
| constexpr bool | value_preserving_convertible_to_v |
| template<typename _Tp> |
| constexpr bool | disable_vectorization |
| template<typename _From, typename _To> |
| constexpr bool | needs_explicit_conversion_v |
| template<class Wrapper, class To> |
| constexpr bool | wrapped_value_is_representable_by_v |
| template<typename _Tp> |
| constexpr auto | arg_native_size = _Tp::never_instantiated |
|
template<typename _Tp, typename _Abi> |
| constexpr auto | arg_native_size< basic_vec< _Tp, _Abi > > = detail::max_native_size<_Tp> |
|
template<std::size_t _Bytes, typename _Abi> |
| constexpr auto | arg_native_size< basic_mask< _Bytes, _Abi > > = detail::maxBytesInVec / _Bytes |
|
template<simd_size_type Size, simd_size_type... Sizes> |
| constexpr bool | are_all_sizes_equal = (... && (Size == Sizes)) |
| | Checks that all sizes are equal.
|
|
template<simd_size_type _NewSize, simd_size_type _VecOrMaskSize> |
| constexpr simd_size_type | new_simd_size = (_NewSize == 0) ? _VecOrMaskSize : _NewSize |
| | Utility to get new vec or mask size.
|
|
auto | minBinaryOperator = [](auto lhs, auto rhs) { using std::min; return min(lhs, rhs); } |
|
auto | maxBinaryOperator = [](auto lhs, auto rhs) { using std::max; return max(lhs, rhs); } |
| constexpr int | maxBytesInVec = 16 |
|
template<typename _Tp, int _Np> |
| constexpr int | register_size = maxBytesInVec / sizeof(_Tp) |
|
constexpr bool | isLlvm = false |
| | Compile time flag to indicate whether the LLVM compiler is being used.
|
| template<class T, class... Us> |
| constexpr bool | any_same_v = (std::same_as<std::remove_cvref_t<T>, Us> || ...) |
| template<typename _T> |
| constexpr bool | is_fp16_v = false |
| template<typename> |
| constexpr bool | dependent_false = false |
|
template<class T> |
| constexpr bool | is_floating_point_v = is_floating_point<std::remove_cvref_t<T>>::value |
|
template<class T> |
| constexpr bool | is_arithmetic_like_v = std::is_integral_v<std::remove_cvref_t<T>> || is_floating_point_v<T> |
|
template<typename _Tp> |
| constexpr simd_size_type | max_native_size = detail::maxBytesInVec / sizeof(_Tp) |
| | The maximum native size of a register containing the given types.
|
| template<typename _Tp> |
| constexpr simd_size_type | max_fixed_size = 128 |
|
template<class _Span> |
| constexpr std::size_t | span_extent_v = decltype(get_span_static_extent(std::declval<_Span>()))::value |
|
target_overloads | msb_to_bitmask_impl |
| enum | X86_FP_CLASSIFY {
QUIET_NAN = 0x01
, POS_ZERO = 0x02
, NEG_ZERO = 0x04
, POS_INF = 0x08
,
NEG_INF = 0x10
, DENORM = 0x20
, NEG = 0x40
, SIGNAL_NAN = 0x80
} |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
| template<typename _Tp> |
| constexpr bool | has_native_support_for_classify |
| | Detect whether native classification support is available for the given type. Emulated FP16 has no such support, but native FP16 does.
|
| template<vec_type _Vp, typename _Up, std::size_t _Extent, typename _Flags> |
| constexpr void | store_masked (x86_tag, const _Vp &value_original, std::span< _Up, _Extent > to, const typename _Vp::mask_type &mask_original, _Flags flags) |
| | Implement masked stores for Intel SSE and Intel AVX targets.
|
| template<vec_type _Vp, typename _Up, std::size_t _Extent, typename _Flags> |
| constexpr void | store (x86_tag, const _Vp &value_original, std::span< _Up, _Extent > to, _Flags flags) |
| | Special case code for handling 4 and 8 byte masked stores on Intel AVX2. This is faster than using the Intel SSE variant above.
|
template<typename _Range, std::integral _Idx, typename _IdxAbi, typename... _Flags>
requires std::ranges::contiguous_range<_Range> && std::ranges::sized_range<_Range> && (sizeof(std::ranges::range_value_t<_Range>) <= 8) |
| constexpr auto | gather_from (x86_avx2_tag, const _Range &r, const typename basic_vec< _Idx, _IdxAbi >::mask_type &mask, const basic_vec< _Idx, _IdxAbi > &indexes, flags< _Flags... > flags) |
| | Masked gather operation.
|
|
template<detail::contiguous_sized_range _Range, vec_integral _Idx, typename... _Flags> |
| constexpr auto | gather_from (x86_avx2_tag, const _Range &r, const _Idx &indexes, flags< _Flags... > flags) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
|
template<typename _Tp, typename _Abi, mask_operator _Op> |
| constexpr auto | builtin_operator (x86_avx512_tag, basic_vec< _Tp, _Abi > x, basic_vec< _Tp, _Abi > y, _Op) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<typename _Tp, typename _Abi, mask_operator _Op>
requires (detail::is_floating_point_v<_Tp>) |
| constexpr auto | builtin_operator (x86_avx512_tag, basic_vec< std::complex< _Tp >, _Abi > lhs, basic_vec< std::complex< _Tp >, _Abi > rhs, _Op cmp_op) |
| | Implement equality/inequality for complex values. In all cases the underlying elements are compared (e.g., float for std::complex<float>) using an appropriate operator, and then adjacent bits in the comparison are combined together using AND/OR operation. For example, in equality, the two individual elements in each complex values are first compared for equality, and then the overall bit for the single complex element is created by ANDing the two bits together (i.e., a complex number is only equal if both of its individual elements are equal).
|
| template<int _Op, typename _Tp, typename _Abi> |
| auto | x86_fp_classify_mask (const basic_vec< _Tp, _Abi > &value) |
| | Classify the floating-point vec values using the fpclassify intrinsic.
|
template<typename _Tp, typename _Abi>
requires (has_native_support_for_classify<_Tp>) |
| constexpr basic_vec< _Tp, _Abi >::mask_type | isinf (x86_avx512_tag, const basic_vec< _Tp, _Abi > &v) |
| | x86 floating-point classification function.
|
template<typename _Tp, typename _Abi>
requires (has_native_support_for_classify<_Tp>) |
| constexpr basic_vec< _Tp, _Abi >::mask_type | isnan (x86_avx512_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<typename _Tp, typename _Abi>
requires (has_native_support_for_classify<_Tp>) |
| constexpr basic_vec< _Tp, _Abi >::mask_type | isfinite (x86_avx512_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<typename _Tp, typename _Abi>
requires (has_native_support_for_classify<_Tp>) |
| constexpr basic_vec< _Tp, _Abi >::mask_type | isnormal (x86_avx512_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
| __m128i | shuffle_epi8 (__m128i values, __m128i indexes) |
|
__m256i | shuffle_epi8 (__m256i values, __m256i indexes) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
| template<typename _Gen, typename _Abi> |
| constexpr basic_vec< std::uint8_t, _Abi > | shuffle_epi8_lut (_Gen, basic_vec< std::uint8_t, _Abi > indexes) |
| template<typename _Tp, typename _Abi> |
| constexpr basic_vec< _Tp, _Abi > | popcount (x86_sse_tag, const basic_vec< _Tp, _Abi > &x) noexcept |
| | }@
|
| template<typename _Tp, typename _Abi> |
| constexpr auto | has_single_bit (x86_avxsnc_tag, const basic_vec< _Tp, _Abi > &x) noexcept |
| | Query whether each element has exactly one bit set.
|
| template<std::unsigned_integral _Tp, typename _Abi> |
| constexpr basic_vec< _Tp, _Abi > | clz (x86_sse_tag, const basic_vec< _Tp, _Abi > &x) noexcept |
| | Count the number of leading zero bits in each element.
|
template<typename _Tp, typename _Abi>
requires (sizeof(_Tp) == 1) |
| constexpr basic_vec< _Tp, _Abi > | bitreverse (x86_sse_tag, const basic_vec< _Tp, _Abi > &x) noexcept |
| | Count the number of leading zero bits in each element.
|
template<vec_integral _Vp>
requires (sizeof(typename _Vp::value_type) == 1) |
| constexpr _Vp | bitreverse (x86_avxsnc_tag, const _Vp &x) noexcept |
| | Reverse the order of the bits in each byte using the GFNI ISA.
|
template<typename _Tp, typename _Abi>
requires (detail::is_floating_point_v<_Tp>) |
| constexpr basic_vec< _Tp, _Abi > | rcp (x86_sse_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<typename _Tp, typename _Abi>
requires (detail::is_floating_point_v<_Tp>) |
| constexpr basic_vec< _Tp, _Abi > | rsqrt (x86_sse_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<typename _Tp, typename _Abi>
requires (detail::is_floating_point_v<_Tp>) |
| constexpr basic_vec< _Tp, _Abi > | sqrt (x86_sse_tag, const basic_vec< _Tp, _Abi > &v) |
| | Constants which specify to the compiler intrinsic which FP classification operation to perform.
|
template<std::integral _Tp, typename _Abi>
requires (sizeof(_Tp) <= 2) |
| constexpr basic_vec< _Tp, _Abi > | saturating_add (x86_tag, const basic_vec< _Tp, _Abi > &lhs, const basic_vec< _Tp, _Abi > &rhs) noexcept |
| | Compute the saturated addition of each respective pair of vector elements.
|
template<std::integral _Tp, typename _Abi>
requires (sizeof(_Tp) <= 2) |
| constexpr basic_vec< _Tp, _Abi > | saturating_sub (x86_tag, const basic_vec< _Tp, _Abi > &lhs, const basic_vec< _Tp, _Abi > &rhs) noexcept |
| | Compute the saturated subtraction of each respective pair of vector elements.
|