These functions are low level and acting on the bit representation of the involved datas.
Variables | |
constexpr auto | eve::bit_and = functor<bit_and_t> |
strict_tuple_callable object computing the bitwise AND of its arguments. | |
constexpr auto | eve::bit_andnot = functor<bit_andnot_t> |
strict_tuple_callable object computing the bitwise ANDNOT of its arguments. | |
constexpr auto | eve::bit_cast = functor<bit_cast_t> |
Computes a bitwise reinterpretation of an object. | |
constexpr auto | eve::bit_ceil = functor<bit_ceil_t> |
elementwise_callable object computing the smallest integral power of two that is not smaller than x . | |
constexpr auto | eve::bit_flip = functor<bit_flip_t> |
strict_elementwise_callable object flipping the value the ith bit of each element. | |
constexpr auto | eve::bit_floor = functor<bit_floor_t> |
elementwise_callable object computing, if x is not zero, the largest integral power of two that is not greater than x . | |
constexpr auto | eve::bit_mask = functor<bit_mask_t> |
elementwise_callable object computing a bit mask full of zeroes or ones | |
constexpr auto | eve::bit_not = functor<bit_not_t> |
elementwise_callable object computing the one complement of the parameter. | |
constexpr auto | eve::bit_notand = functor<bit_notand_t> |
strict_tuple_callable object computing the bitwise NOTAND of its arguments. | |
constexpr auto | eve::bit_notor = functor<bit_notor_t> |
strict_tuple_callable object computing the bitwise NOTOR of its arguments. | |
constexpr auto | eve::bit_or = functor<bit_or_t> |
strict_tuple_callable object computing the bitwise OR of its arguments. | |
constexpr auto | eve::bit_ornot = functor<bit_ornot_t> |
strict_tuple_callable object Computing the bitwise ORNOT of its arguments. | |
constexpr auto | eve::bit_reverse = functor<bit_reverse_t> |
strict_elementwise_callable object reversing the bit order. | |
constexpr auto | eve::bit_select = functor<bit_select_t> |
strict_elementwise_callable object selecting bits from a mask and two entries. | |
constexpr auto | eve::bit_set = functor<bit_set_t> |
strict_elementwise_callable object setting to 1 the ith bit of each element. | |
constexpr auto | eve::bit_shl = functor<shl_t> |
strict_elementwise_callable object computing a logical left shift. | |
constexpr auto | eve::bit_shr = functor<bit_shr_t> |
strict_elementwise_callable object computing a logical right shift. | |
constexpr auto | eve::bit_swap_adjacent = functor<bit_swap_adjacent_t> |
strict_elementwise_callable object swapping adjacent groups of n bits. | |
constexpr auto | eve::bit_swap_pairs = functor<bit_swap_pairs_t> |
strict_elementwise_callable object swapping pairs. | |
constexpr auto | eve::bit_ternary = functor<bit_ternary_t> |
strict_elementwise_callable object implementing ternary logic. | |
constexpr auto | eve::bit_unset = functor<bit_unset_t> |
strict_elementwise_callable object setting to 01 the ith bit of each element. | |
constexpr auto | eve::bit_width = functor<bit_width_t> |
elementwise_callable object Computing elementwise the number of bits needed to store the parameter. | |
constexpr auto | eve::bit_xor = functor<bit_xor_t> |
strict_tuple_callable object computing the bitwise XOR of its arguments. | |
constexpr auto | eve::byte_reverse = functor<byte_reverse_t> |
elementwise_callable object reversing the byte order. | |
constexpr auto | eve::byte_swap_adjacent = functor<byte_swap_adjacent_t> |
strict_elementwise_callable object that swap adjacent groups of N bytes. | |
constexpr auto | eve::byte_swap_pairs = functor<byte_swap_pairs_t> |
strict_elementwise_callable object swapping chosen pairs of bytes in each vector element. | |
constexpr auto | eve::countl_one = functor<countl_one_t> |
elementwise_callableobject computing the number of consecutive bits unset in a value starting from left ! ! @groupheader{Header file} ! ! @code //! #include <eve/module/core.hpp> //! @endcode ! ! @groupheader{Callable Signatures} ! ! @code //! namespace eve //! { //! // Regular overload //! constexpr auto countl_one(unsigned_value auto x) noexcept; // 1 //! //! // Lanes masking //! constexpr auto countl_one[conditional_expr auto c](unsigned_value auto x) noexcept; // 2 //! constexpr auto countl_one[logical_value auto m](unsigned_value auto x) noexcept; // 2 //! } //! @endcode ! ! **Parameters** ! ! * x: [argument](@ref eve::unsigned_value). ! * c: [Conditional expression](@ref eve::conditional_expr) masking the operation. ! * m: [Logical value](@ref eve::logical_value) masking the operation. ! ! **Return value** ! ! 1. The value of the number of consecutive 1 ("one") bits in the value of x, starting ! from the most significant bit ("left"), with same type as x` is returned. | |
constexpr auto | eve::countl_zero = functor<countl_zero_t> |
elementwise_callableobject computing the number of consecutive bits unset in a value starting from left ! ! @groupheader{Header file} ! ! @code //! #include <eve/module/core.hpp> //! @endcode ! ! @groupheader{Callable Signatures} ! ! @code //! namespace eve //! { //! // Regular overload //! constexpr auto countl_zero(unsigned_value auto x) noexcept; // 1 //! //! // Lanes masking //! constexpr auto countl_zero[conditional_expr auto c](unsigned_value auto x) noexcept; // 2 //! constexpr auto countl_zero[logical_value auto m](unsigned_value auto x) noexcept; // 2 //! } //! @endcode ! ! **Parameters** ! ! * x: [argument](@ref eve::unsigned_value). ! * c: [Conditional expression](@ref eve::conditional_expr) masking the operation. ! * m: [Logical value](@ref eve::logical_value) masking the operation. ! ! **Return value** ! ! 1. The value of the number of consecutive 0 ("zero") bits in the value of x, starting ! from the most significant bit ("left"), with same type as x` is returned. | |
constexpr auto | eve::countr_one = functor<countr_one_t> |
elementwise_callable object computing the number of consecutive bits set in a value starting from right. | |
constexpr auto | eve::countr_zero = functor<countr_zero_t> |
elementwise_callable object computing the number of consecutive bits unset in a value starting from right. | |
constexpr auto | eve::firstbitset = functor<firstbitset_t> |
Computes elementwise the bit pattern in which the only bit set (if it exists) is the first bit set in the input. | |
constexpr auto | eve::firstbitunset = functor<firstbitunset_t> |
Computes elementwise the bit pattern in which the only bit set (if it exists) is the first bit unset in the input. | |
constexpr auto | eve::hi = functor<hi_t> |
elementwise_callable computing the most significant half of each lane. | |
constexpr auto | eve::lo = functor<lo_t> |
Computes the least significant half of each lane. | |
constexpr auto | eve::lohi = functor<lohi_t> |
elementwise_callable computing the the lohi pair of values. | |
constexpr auto | eve::popcount = functor<popcount_t> |
elementwise_callable object computing elementwise the number of bits set in the parameter. | |
constexpr auto | eve::rotl = functor<rotl_t> |
Bitwise rotation to the left. | |
constexpr auto | eve::rotr = functor<rotr_t> |
Bitwise rotation to the right. | |
constexpr auto | eve::rshl = functor<rshl_t> |
Computes the arithmetic left/right shift operation according to shift sign. | |
constexpr auto | eve::rshr = functor<rshr_t> |
Computes the arithmetic right/left shift operation according to shift sign. | |
constexpr auto | eve::shl = functor<shl_t> |
Computes the arithmetic left shift operation. | |
constexpr auto | eve::shr = functor<shr_t> |
Computes the arithmetic right shift operation. | |
constexpr callable_swap_pairs_ | eve::swap_pairs = {} |
swap chosen pair of elements. | |