Bitwise functions

Detailed Description

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>
	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 ofx, starting ! from the most significant bit ("left"), with same type asx` 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 ofx, starting ! from the most significant bit ("left"), with same type asx` 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.