eve Namespace Reference

EVE Main Namespace. More...

Detailed Description

This namespace contains all the elements required to use EVE

Classes
struct	abi
	Find proper ABI for Type/Lanes pair. More...
struct	aligned_allocator
	Standard-compliant allocator handling the allocation and deallocation of segment of aligned memory. More...
struct	aligned_ptr
	Wrapper for non-owning aligned pointers. More...
struct	as
	Lightweight type-wrapper. More...
struct	as_element
	Lightweight type-wrapper over element type. More...
struct	as_pattern
	Formula-based pattern holder. More...
struct	callable
	CRTP base class defining an EVE's Callable Object. More...
struct	cardinal
	Computes the cardinal of a given type. More...
struct	common_compatible
	Computes the type compatible with a list of values. More...
struct	common_type
	Computes a type that can represent all values in a list of types. More...
struct	conditional_option
	Option specification for decoration via conditional value and expressions. More...
struct	constant_callable
	CRTP base class giving an EVE's Callable Object the constant function semantic. More...
struct	decorated_with
	Helper class to aggregate options handlers and states. More...
struct	element_type
	Extracts the scalar part of a type. More...
struct	elementwise_callable
	CRTP base class giving an EVE's Callable Object the elementwise function semantic. More...
struct	fixed
	SIMD register cardinal type. More...
struct	fundamental_cardinal
	Computes the fundamental cardinal of a given type. More...
struct	if_
	Extensible wrapper for SIMD conditional. More...
struct	ignore_all_
	Conditional expression selecting no lane from a eve::simd_value. More...
struct	ignore_extrema
	Conditional expression ignoring lanes at both extrema of a eve::simd_value. More...
struct	ignore_first
	Conditional expression ignoring the k first lanes from a eve::simd_value. More...
struct	ignore_last
	Conditional expression ignoring the k last lanes from a eve::simd_value. More...
struct	ignore_none_
	Conditional expression selecting all lanes from a eve::simd_value. More...
struct	keep_between
	Conditional expression keeping all lanes between two position. More...
struct	keep_first
	Conditional expression selecting the k first lanes from a eve::simd_value. More...
struct	keep_last
	Conditional expression keeping the k last lanes from a eve::simd_value. More...
struct	logical< T >
	Wrapper for SIMD compatible logical types. More...
struct	logical< wide< Type, Cardinal > >
	Wrapper for SIMD registers holding logical types with compile-time size. More...
struct	options
	Wrapper class around bundle of options passed to eve::callable. More...
struct	or_
	Conditional/Alternative wrapper. More...
struct	pattern_t
	Shuffling pattern. More...
struct	platform
	Platform specific constexpr information. More...
struct	relative_conditional_option
	Option specification for decoration via relative conditional value and expressions. More...
struct	soa_ptr
	a low level abstraction that is like a tuple of pointers to parallel arrays. We think that in code one should use views::zip_iterator instead, it can do everything soa_ptr can and more. We are still trying to figure out how/where these abstractions should live. More...
struct	stack_buffer
	A stack buffer for a simd-value. More...
struct	struct_support
	CRTP base-class to declare operators for user-defined product type. More...
struct	supports_like
	Opt-in traits for eve::like concept compliance. More...
struct	supports_ordering
	Register a user-defined type to supports ordering. More...
struct	top_bits
	The cheapest to get bitset for simd logical. More...
struct	underlying_type
	Computes the most scalar type associated with a type. More...
struct	wide
	Wrapper for SIMD registers. More...

Concepts
concept	wide_cardinal
	concept to determine if this is cardinal type of a wide
concept	conditional_expr
	Specifies that a type is a Conditional Expression.
concept	relative_conditional_expr
	Specifies that a type is a Conditional Expression using relative mask.
concept	generator
concept	irregular_predicate
	std::predicate but doesn't require regularity
concept	match_option
	Checks if the type associated to a given Keyword in an Option pack is equal to Type.
concept	only_if
	Checks if the type is one of the Choices.
concept	plain_scalar_value
	Specify that a type represents a plain scalar value The concept plain_scalar_value<T> is satisfied if and only if the translation of T is an instance of any non-bool, non-long double, arithmetic types.
concept	logical_scalar_value
	Specify that a type represents a logical scalar value The concept logical_scalar_value<T> is satisfied if and only if T is an instance of eve::logical and its contents satisfy eve::plain_scalar_value.
concept	product_scalar_value
	Specify that a type represents a product type made of scalars The concept product_scalar_value<T> is satisfied if and only if T is a kumi::product_type containing only eve::plain_scalar_value or eve::logical_scalar_value.
concept	arithmetic_scalar_value
	Specify that a type represents a type suitable for vectorization The concept arithmetic_scalar_value<T> is satisfied if and only if T can be used as a base type for eve::wide , i.e it's either satisfying eve::plain_scalar_value or eve::product_scalar_value.
concept	scalar_value
	Specify that a type represents a scalar value The concept scalar_value<T> is satisfied if and only if T satisfies either arithmetic_scalar_value or logical_scalar_value.
concept	logical_simd_value
	Specify that a type represents a logical SIMD value. The concept logical_simd_value<T> is satisfied if and only if T is an instance of eve::logical and its contents satisfy eve::plain_simd_value.
concept	has_plain_translation
	Specify that a type can be translated to a plain scalar value. The concept has_plain_translation<T> is satisfied if and only if calling translate_t<T> returns a type that is different from T.
concept	value
	The concept value<T> is satisfied if and only if T satisfies either eve::scalar_value or eve::simd_value.
concept	integral_value
	The concept integral_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies std::integral
concept	signed_value
	The concept signed_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies std::is_signed
concept	unsigned_value
	The concept unsigned_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies std::unsigned_integral
concept	signed_integral_value
	The concept signed_integral_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies std::signed_integral
concept	floating_value
	The concept floating_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies std::floating_point
concept	logical_value
	The concept logical_value<T> is satisfied if and only if T satisfies eve::value and the element type satisfies is_logical_v.
concept	plain_value
	The concept plain_value<T> is satisfied if and only if T satisfies eve::plain_simd_value or eve::plain_scalar_value.
concept	integral_scalar_value
	Specify that a type represents an integral scalar value. The concept integral_scalar_value<T> is satisfied if and only if T satisfies eve::arithmetic_scalar_value<T> and std::integral<T>.
concept	signed_scalar_value
	Specify that a type represents a signed scalar value. The concept signed_scalar_value<T> is satisfied if and only if T satisfies eve::arithmetic_scalar_value<T> and std::integral<T>.
concept	unsigned_scalar_value
	Specify that a type represents an unsigned scalar value. The concept unsigned_scalar_value<T> is satisfied if and only if T satisfies eve::arithmetic_scalar_value<T> and std::unsigned_integral<T>.
concept	signed_integral_scalar_value
	Specify that a type represents an integral scalar value. The concept unsigned_scalar_value<T> is satisfied if and only if T satisfies eve::arithmetic_scalar_value<T> and std::signed_integral<T>.
concept	floating_scalar_value
	Specify that a type represents a floating scalar value. The concept unsigned_scalar_value<T> is satisfied if and only if T satisfies eve::arithmetic_scalar_value<T> and std::floating_point<T>.
concept	simd_value
	Specifies that a type is a SIMD type. The concept simd_value<T> is satisfied if and only if T satisfies either eve::arithmetic_simd_value or eve::logical_simd_value.
concept	integral_simd_value
	Specifies that a type is a SIMD type with integral elements.
concept	signed_simd_value
	Specifies that a type is a SIMD type with signed elements.
concept	unsigned_simd_value
	Specifies that a type is a SIMD type with unsigned elements.
concept	signed_integral_simd_value
	Specifies that a type is a SIMD type with signed integral elements.
concept	floating_simd_value
	Specifies that a type is a SIMD type with floating elements.
concept	has_store_equivalent
	tests if store_equivalent has a non-default definition for a value and a pointer.
concept	pattern_formula
	what callable can be a pattern formula
concept	callable_object
	EVE callable object
concept	like
	Specifies semantic compatibility between wrapper/wrapped types.

Typedefs
template<typename Type , regular_abi ABI = eve::current_abi_type>
using	expected_cardinal_t = fixed<expected_cardinal_v<Type,ABI>>
	Computes the expected cardinal of a given type.
template<typename T >
using	unaligned_t = decltype(unalign(std::declval<T>()))
	Compute the unaligned pointer type associated to a given type.
template<typename... Vs>
using	zipped = eve::result_t<zip,Vs...>
	Type helper to compute tuple-like result-type.
template<typename... Ts>
using	common_value_t = typename eve::detail::common_value_impl<void, Ts...>::type
	Computes the SIMD-compatible common type between all Ts.
template<typename T >
using	iterator_cardinal_t = decltype(detail::iterator_cardinal_impl<T>())
	A meta-function that returns a cardinal for a relaxed iterator/range. If T defines a nested static function iterator_cardinal() (which should return eve::fixed)
template<typename T >
using	value_type_t = typename decltype(detail::value_type_impl<T>())::type
	A meta function for getting an associated value_type for a relaxed iterator/range.
template<typename T >
using	wide_value_type_t = as_wide_t<value_type_t<T>, iterator_cardinal_t<T>>

Enumerations
enum class	over : std::size_t
	Strong integral type that represents the notion of over-alignment constraints. More...
enum class	under : std::size_t
	Strong integral type that represents the notion of under-alignment constraints. More...

Functions
template<eve::relative_conditional_expr C>
constexpr auto	drop_alternative (C c)
	Returns a conditional without an alternative.
template<eve::relative_conditional_expr C>
auto	map_alternative (C c, auto op)
	Computes a transformed conditional.
template<eve::relative_conditional_expr C, typename T >
constexpr auto	reverse_conditional (C c, eve::as< T > tgt)
	Computes the reverse of a given eve::relative_conditional_expr.
template<std::size_t A, typename T , typename Other >
constexpr bool	is_aligned (aligned_ptr< T, Other > const &ptr) noexcept
	Checks if an aligned_ptr is aligned on a given alignment.
template<typename Lanes , typename Type >
aligned_ptr< Type const, Lanes >	as_aligned (Type const *ptr, Lanes) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<typename Type >
aligned_ptr< Type const >	as_aligned (Type const *ptr) noexcept
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
template<std::size_t Alignment, std::integral T>
constexpr bool	is_aligned (T v) noexcept
	Checks if a pointer satisfies an alignment constraint.
template<std::size_t Alignment, typename T >
constexpr bool	is_aligned (T *ptr) noexcept
	Checks if a pointer satisfies an alignment constraint.
template<typename T , typename Lanes >
constexpr bool	is_aligned (T *ptr, Lanes lanes) noexcept
	Checks if a pointer satisfies an alignment constraint.
template<logical_value Mask, value Value>
void	swap_if (Mask const &mask, Value &lhs, Value &rhs) noexcept
	Conditional swap.
template<typename T , typename U , typename A , typename B >
bool	operator== (aligned_allocator< T, A > const &, aligned_allocator< U, B > const &) noexcept
	Compares aligned_allocators for equality of types and alignment constraints.
template<typename T , typename U , typename A , typename B >
bool	operator!= (aligned_allocator< T, A > const &, aligned_allocator< U, B > const &) noexcept
	Compares aligned_allocators for inequality of types or alignment constraints.
template<typename Lanes , typename Type >
aligned_ptr< Type, Lanes >	as_aligned (Type *ptr, Lanes lanes) noexcept
	Constructs an aligned_ptr from a pointer ptr. Behavior is undefined if ptr does not satisfy alignment constraint Lanes.
template<typename Type >
aligned_ptr< Type >	as_aligned (Type *ptr) noexcept
	Constructs an aligned_ptr from a pointer ptr. Behavior is undefined if ptr does not satisfy the default alignment constraint.
template<typename T , typename Lanes >
auto	previous_aligned_address (T *p, Lanes width) noexcept
	Computes an address lesser or equal to p which satisfies the alignment constraint of SIMD registers of size Lanes.
template<typename T >
auto	previous_aligned_address (T *p) noexcept
	Computes an address lesser or equal to p which is satisfy the alignment constraint of current architecture's SIMD register.
template<typename T , typename Lanes >
auto	next_aligned_address (T *p, Lanes width) noexcept
	Computes an address greater or equal to p which satisfies the alignment constraint of SIMD registers of size Lanes.
template<typename T >
auto	next_aligned_address (T *p) noexcept
	Computes an address greater or equal to p which satisfies the alignment constraint of current architecture's SIMD register.
template<std::ptrdiff_t Sz, pattern_formula F>
constexpr auto	fix_pattern (F)
	Converts a formula pattern to an index pattern.
template<std::ptrdiff_t N, shuffle_pattern Pattern>
constexpr auto	pattern_clamp (Pattern const &) noexcept
	Clamps a pattern to a given size.
template<std::ptrdiff_t B, std::ptrdiff_t E, std::ptrdiff_t N, shuffle_pattern Pattern>
constexpr auto	pattern_view (Pattern const &) noexcept
	Extracts a sub-pattern from an existing pattern.
template<std::ptrdiff_t O, std::ptrdiff_t N, shuffle_pattern Pattern>
constexpr auto	slide_pattern (Pattern) noexcept
Deduction Guides
template<scalar_value S>
	wide (S const &) -> wide< S, expected_cardinal_t< S > >
	Allows deduction from a single eve::scalar_value.
template<scalar_value S, std::same_as< S >... Ss>
	wide (S, Ss...) -> wide< S, fixed< 1+sizeof...(Ss)> >
	Allows deduction from variadic pack of eve::scalar_value.

Variables
template<scalar_value T, regular_abi ABI = eve::current_abi_type>
constexpr std::ptrdiff_t	nofs_cardinal_v
	nofs stands for "no frequency scaling".
constexpr ignore_all_	ignore_all = {}
	Object representing the eve::ignore_all_ conditional expression.
constexpr ignore_none_	ignore_none = {}
	Object representing the eve::ignore_none_ conditional expression.
constexpr auto	airy = functor<airy_t>
	elementwise_callable object computing simutaneously the airy functions values \( Ai(x)\) and \( Bi(x)\).
constexpr auto	airy_ai = functor<airy_ai_t>
	elementwise_callable object computing the airy function \( Ai(x)\).
constexpr auto	airy_bi = functor<airy_bi_t>
	elementwise_callable object computing the airy function \( Bi(x)\).
constexpr auto	bessel_i = eve::functor<bessel_i_t>
	Computes the spherical or cylindrical Modified Bessel functions of the first kind,.
constexpr auto	bessel_j = eve::functor<bessel_j_t>
	Computes the spherical or cylindrical Bessel functions of the first kind,.
constexpr auto	bessel_k = eve::functor<bessel_k_t>
	Computes the modified spherical or cylindrical Bessel functions of the second kind,.
constexpr auto	bessel_y = eve::functor<bessel_y_t>
	Computes the spherical or cylindrical Bessel functions of the second kind,.
constexpr auto	bernouilli = functor<bernouilli_t>
	elementwise_callable object computing the nth Bernouilli number \(b_n\) as a double.
constexpr auto	fibonacci = functor<fibonacci_t>
	Computes the nth element of the Fibonacci sequence \((f_i)_{i\in \mathbb{N}}\).
constexpr auto	gcd = functor<gcd_t>
	elementwise_callable object computing the greatest common divisor of the inputs.
constexpr auto	lcm = functor<lcm_t>
	elementwise_callable object computing the least common multiple of the inputs.
constexpr auto	nth_prime = functor<nth_prime_t>
	Returns the nth prime number.
constexpr auto	prime_ceil = functor<prime_ceil_t>
	strict_elementwise_callable object computing the smallest prime greater or equal to the input.
constexpr auto	prime_floor = functor<prime_floor_t>
	strict_elementwise_callable object computing the greatest prime less or equal to the input.
constexpr callable_compress_	compress = {}
	A low level function to compress one simd value based on a mask.
constexpr auto	compress_copy = detail::compress_callable<compress_copy_core> {}
	A function that copies selected elements from source to destination, while compressing them to the left.
constexpr auto	compress_store = detail::compress_callable_no_density<compress_store_core> {}
	A function that stores selected elements from an eve::simd_value to an eve::simd_compatible_ptr, while compressing them to the beginning.
constexpr auto	allbits = functor<allbits_t>
	Computes a constant with all bits set.
constexpr callable_as_value_	as_value = {}
	converts eve constant or just a value to a type.
constexpr auto	bitincrement = functor<bitincrement_t>
	Computes a constant with only the least significant bit set.
constexpr auto	eps = functor<eps_t>
	Computes a constant to the machine epsilon.
constexpr auto	exponentmask = functor<exponentmask_t>
	Computes the the exponent bit mask of IEEE float or double.
constexpr auto	false_ = functor<false_t>
	Computes the false logical value.
constexpr auto	half = functor<half_t>
	Computes the constant \(1/2\).
constexpr auto	inf = functor<inf_t>
	Computes the infinity ieee value.
constexpr auto	iota = functor<iota_t>
	all numbers from 0 to size() - 1. equivalent to T{ [](int i, int) {return i; } }
constexpr auto	logeps = functor<logeps_t>
	Computes the natural logarithm of the machine epsilon.
constexpr auto	mantissamask = functor<mantissamask_t>
	Computes the mask to extract the mantissa bits of an ieee floating value.
constexpr auto	maxexponent = functor<maxexponent_t>
	Computes the greatest exponent of a floating point IEEE value.
constexpr auto	maxexponentm1 = functor<maxexponentm1_t>
	Computes the the greatest exponent of a floating point IEEE value minus one.
constexpr auto	maxexponentp1 = functor<maxexponentp1_t>
	Computes the the greatest exponent of a floating point IEEE value plus one.
constexpr auto	maxflint = functor<maxflint_t>
	Computes the the greatest floating point representing an integer and such that n != n+1.
constexpr auto	mhalf = functor<mhalf_t>
	Computes the constant \(-1/2\).
constexpr auto	mindenormal = functor<mindenormal_t>
	Computes the smallest denormal positive value.
constexpr auto	minexponent = functor<minexponent_t>
	Computes the the greatest exponent of a floating point IEEE value.
constexpr auto	minf = functor<minf_t>
	Computes the -infinity ieee value.
constexpr auto	mone = functor<mone_t>
	Computes the constant \(-1\).
constexpr auto	mzero = functor<mzero_t>
	Computes the negative zero value.
constexpr auto	nan = functor<nan_t>
	Computes the IEEE quiet NaN constant.
constexpr auto	nbmantissabits = functor<nbmantissabits_t>
	Returns the number of mantissa bits of a floating point value.
constexpr auto	one = functor<one_t>
	Computes the constant \(1\).
constexpr auto	oneosqrteps = functor<oneosqrteps_t>
	Computes the the inverse of the square root of the machine epsilon.
constexpr auto	signmask = functor<signmask_t>
	Computes a value in which the most significant bit is the only bit set.
constexpr auto	smallestposval = functor<smallestposval_t>
	Computes the smallest normal positive value.
constexpr auto	sqrteps = functor<sqrteps_t>
	Computes the square root of the machine epsilon.
constexpr auto	sqrtsmallestposval = functor<sqrtsmallestposval_t>
	Computes the square root of the eve::smallestposval.
constexpr auto	sqrtvalmax = functor<sqrtvalmax_t>
	Computes the the greatest value less than the square root of eve::valmax.
constexpr auto	true_ = functor<true_t>
	Computes the logical true_ value.
constexpr auto	twotonmb = functor<twotonmb_t>
	Computes the 2 power of the number of mantissa bits of a floating value.
constexpr auto	valmax = functor<valmax_t>
	Computes the the greatest representable value.
constexpr auto	valmin = functor<valmin_t>
	Computes the the lowest representable value.
constexpr auto	zero = functor<zero_t>
	Computes the constant 0.
constexpr auto	blend = detail::named_shuffle_2<blend_t> {}
	a named shuffle for mixing 2 registers together, without changing positions.
constexpr auto	broadcast_lane = detail::named_shuffle_1<broadcast_lane_t> {}
	a named shuffle for duplicating the lane across a register.
constexpr auto	reverse = detail::named_shuffle_1<reverse_t> {}
	a named shuffle for reversing a register.
constexpr auto	reverse_in_subgroups = detail::named_shuffle_1<reverse_in_subgroups_t> {}
	a named shuffle for reversing all subgroups in a register
constexpr auto	swap_adjacent = detail::named_shuffle_1<swap_adjacent_t> {}
	a named shuffle that goes all pairs of elements and swaps them: [0, 1, 2, 3] => [1, 0, 3, 2]
constexpr auto	abs = functor<abs_t>
	elementwise_callable object computing the absolute value of the parameter.
constexpr auto	absmax = functor<absmax_t>
	tuple_callable computing the absolute value of the maximal element.
constexpr auto	absmin = functor<absmin_t>
	tuple_callable computing the absolute value of the minimal element.
constexpr auto	add = functor<add_t>
	tuple_callable computing the sum of its arguments.
constexpr auto	agm = functor<agm_t>
	elementwise_callable object computing the the arithmetic-geometric mean.
constexpr callable_all_	all = {}
	Computes a bool value which is true if and only if all elements of x are not zero.
constexpr callable_any_	any = {}
	Computes a bool value which is true if and only if any elements of x is not zero.
constexpr auto	average = functor<average_t>
	tuple_callable computing the arithmetic mean of its arguments.
constexpr auto	bit_and = functor<bit_and_t>
	strict_tuple_callable object computing the bitwise AND of its arguments.
constexpr auto	bit_andnot = functor<bit_andnot_t>
	strict_tuple_callable object computing the bitwise ANDNOT of its arguments.
constexpr auto	bit_cast = functor<bit_cast_t>
	Computes a bitwise reinterpretation of an object.
constexpr auto	bit_ceil = functor<bit_ceil_t>
	elementwise_callable object computing the smallest integral power of two that is not smaller than x.
constexpr auto	bit_flip = functor<bit_flip_t>
	strict_elementwise_callable object flipping the value the ith bit of each element.
constexpr auto	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	bit_mask = functor<bit_mask_t>
	elementwise_callable object computing a bit mask full of zeroes or ones
constexpr auto	bit_not = functor<bit_not_t>
	elementwise_callable object computing the one complement of the parameter.
constexpr auto	bit_notand = functor<bit_notand_t>
	strict_tuple_callable object computing the bitwise NOTAND of its arguments.
constexpr auto	bit_notor = functor<bit_notor_t>
	strict_tuple_callable object computing the bitwise NOTOR of its arguments.
constexpr auto	bit_or = functor<bit_or_t>
	strict_tuple_callable object computing the bitwise OR of its arguments.
constexpr auto	bit_ornot = functor<bit_ornot_t>
	strict_tuple_callable object Computing the bitwise ORNOT of its arguments.
constexpr auto	bit_reverse = functor<bit_reverse_t>
	strict_elementwise_callable object reversing the bit order.
constexpr auto	bit_select = functor<bit_select_t>
	strict_elementwise_callable object selecting bits from a mask and two entries.
constexpr auto	bit_set = functor<bit_set_t>
	strict_elementwise_callable object setting to 1 the ith bit of each element.
constexpr auto	bit_shl = functor<shl_t>
	strict_elementwise_callable object computing a logical left shift.
constexpr auto	bit_shr = functor<bit_shr_t>
	strict_elementwise_callable object computing a logical right shift.
constexpr auto	bit_swap_adjacent = functor<bit_swap_adjacent_t>
	strict_elementwise_callable object swapping adjacent groups of n bits.
constexpr auto	bit_swap_pairs = functor<bit_swap_pairs_t>
	strict_elementwise_callable object swapping pairs.
constexpr auto	bit_ternary = functor<bit_ternary_t>
	callable object implementing ternary logic.
constexpr auto	bit_unset = functor<bit_unset_t>
	strict_elementwise_callable object setting to 01 the ith bit of each element.
constexpr auto	bit_width = functor<bit_width_t>
	elementwise_callable object Computing elementwise the number of bits needed to store the parameter.
constexpr auto	bit_xor = functor<bit_xor_t>
	strict_tuple_callable object computing the bitwise XOR of its arguments.
constexpr auto	bitofsign = functor<bitofsign_t>
	elementwise_callable object computing the bit of sign.
constexpr auto	broadcast = functor<broadcast_t>
	Computes the.
constexpr callable_broadcast_group_	broadcast_group = {}
	Computes the TODO.
constexpr auto	byte_reverse = functor<byte_reverse_t>
	elementwise_callable object reversing the byte order.
constexpr auto	byte_swap_adjacent = functor<byte_swap_adjacent_t>
	strict_elementwise_callable object that swap adjacent groups of N bytes.
constexpr auto	byte_swap_pairs = functor<byte_swap_pairs_t>
	strict_elementwise_callable object swapping chosen pairs of bytes in each vector element.
constexpr auto	ceil = functor<ceil_t>
	strict_elementwise_callable object computing the smallest integer not less than the input.
constexpr auto	chi = functor<chi_t>
	callable indicatrix of the interval \([lo, hi[\) or of the set for which the invocable returns true.
constexpr auto	clamp = functor<clamp_t>
	elementwise_callable clamping the value between two bounds.
constexpr callable_combine_	combine = {}
	Computes the TODO.
constexpr auto	compare_absolute = functor<compare_absolute_t>
	elementwise callable returning a logical true if and only if the absolute value of the first parameters satisfy the predicate parameters.
constexpr auto	convert = functor<convert_t>
	Converts a value to another type.
constexpr auto	copysign = functor<copysign_t>
	elementwise_callable object computing the composition of a value with the magnitude of the first parameter and the bit of sign of the second one.
constexpr callable_count_true_	count_true = {}
	Computes the number of non 0 elements.
constexpr auto	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	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	countr_one = functor<countr_one_t>
	elementwise_callable object computing the number of consecutive bits set in a value starting from right.
constexpr auto	countr_zero = functor<countr_zero_t>
	elementwise_callable object computing the number of consecutive bits unset in a value starting from right.
constexpr auto	dec = functor<dec_t>
	elementwise_callable object returning the input decremented by 1.
constexpr callable_deinterleave_groups_	deinterleave_groups = {}
	Callabe object that deinterleaves values in n wides.
constexpr callable_deinterleave_groups_shuffle_	deinterleave_groups_shuffle = {}
	Callable object for a deinterleave groups shuffle.
constexpr auto	diff_of_prod = functor<diff_of_prod_t>
	elementwise_callable object computing the difference of products operation with better accuracy than the naive formula.
constexpr auto	dist = functor<dist_t>
	elementwise_callable object computing the distance of its arguments.
constexpr auto	div = functor<div_t>
	elementwise_callable object computing the division of multiple values.
constexpr auto	dot = functor<dot_t>
	elementwise_callable object computing elementwise the dot product of the two parameters.
constexpr auto	epsilon = functor<epsilon_t>
	elementwise_callable object computing the distance of the absolute value of the parameter to the next representable element of its type.
constexpr auto	exponent = functor<exponent_t>
	elementwise_callable object computing the integral IEEE exponent of the floating value.
constexpr auto	fam = functor<fam_t>
	strict_elementwise_callable computing the fused add multiply of its three parameters.
constexpr auto	fanm = functor<fanm_t>
	Computes the fused add negate multiply of its three parameters.
constexpr auto	fast_two_add = functor<fast_two_add_t>
	Computes the elementwise pair of add and error,.
constexpr auto	fdim = functor<fdim_t>
	elementwise_callable computing the positive difference between the two parameters.
constexpr callable_first_true_	first_true = {}
	A function to find a first true value, if there is one.
constexpr auto	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	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	floor = functor<floor_t>
	elementwise_callable object computing the largest integer not greater than the input.
constexpr auto	flush_denormal = functor<flush_denormal_t>
	elementwise_callable object computing flushing denormal values to 0.
constexpr auto	fma = functor<fma_t>
	strict_elementwise_callable computing the fused multiply add of its three parameters.
constexpr auto	fmod = functor<fmod_t>
	elementwise_callable object mimicking the std::fmod function for floating values.
constexpr auto	fms = functor<fms_t>
	strict_elementwise_callable computing the fused multiply substract of its three parameters.
constexpr auto	fnma = functor<fnma_t>
	strict_elementwise_callable computing the fused multiply add of its three parameters.
constexpr auto	fnms = functor<fnms_t>
	strict_elementwise_callable computing the fused multiply add of its three parameters.
constexpr auto	frac = functor<frac_t>
	elementwise_callable computing the fractional part of the input.
constexpr auto	fracscale = functor<fracscale_t>
	strict_elementwise_callable object computing the reduced part of the scaled input.
constexpr auto	frexp = functor<frexp_t>
	elementwise_callable computing the ieee pair of mantissa and exponent of a floating value,
constexpr auto	fsm = functor<fsm_t>
	strict_elementwise_callable computing the fused add multiply of its three parameters.
constexpr auto	fsnm = functor<fsnm_t>
	strict_elementwise_callable computing the fused add multiply of its three parameters.
constexpr callable_gather_	gather = {}
	Computes the TODO.
constexpr callable_has_equal_in_	has_equal_in = {}
	Given two simd_values: x, match_against returns a logical mask. The res[i] == eve::any(x[i] == match_against);.
constexpr auto	heaviside = functor<heaviside_t>
	elementwise_callable that return 1 if the input is greater than a threshold else 0.
constexpr auto	hi = functor<hi_t>
	elementwise_callable computing the most significant half of each lane.
constexpr auto	if_else = functor<if_else_t>
	Select value based on conditional mask or values.
constexpr auto	ifrexp = functor<ifrexp_t>
	Computes the elementwise ieee pair of mantissa and exponent of the floating value,.
constexpr auto	ilogb = functor<ilogb_t>
	elementwise_callable object computing the integral IEEE ilogb of the floating value.
constexpr auto	inc = functor<inc_t>
	elementwise_callable object returning the input incremented by 1.
constexpr auto	is_bit_equal = functor<is_bit_equal_t>
	elementwise callable returning a logical true if and only if the element bits are all equal.
constexpr auto	is_denormal = functor<is_denormal_t>
	elementwise callable returning a logical true if and only if the element value is denormal
constexpr auto	is_eqmz = functor<is_eqmz_t>
	elementwise callable returning a logical true if and only if the element value is a floating zero with sign bit set.
constexpr auto	is_eqpz = functor<is_eqpz_t>
	elementwise callable returning a logical true if and only if the element value is a floating zero with signbit unset.
constexpr auto	is_equal = functor<is_equal_t>
	elementwise callable returning a logical true if and only if the element values are equal.
constexpr auto	is_eqz = functor<is_eqz_t>
	elementwise callable returning a logical true if and only if the element value is zero.
constexpr auto	is_even = functor<is_even_t>
	elementwise callable returning a logical true if and only if the element value is even.
constexpr auto	is_finite = functor<is_finite_t>
	elementwise callable returning a logical true if and only if the element is a finite value
constexpr auto	is_flint = functor<is_flint_t>
	elementwise callable returning a logical true if and only if the element value is a floating value representing an integer
constexpr auto	is_gez = functor<is_gez_t>
	elementwise callable returning a logical true if and only if the element value is greater or equal to 0.
constexpr auto	is_greater = functor<is_greater_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is greater than the second one.
constexpr auto	is_greater_equal = functor<is_greater_equal_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is greater or equal to the second one.
constexpr auto	is_gtz = functor<is_gtz_t>
	elementwise callable returning a logical true if and only if the element value is greater than 0.
constexpr auto	is_infinite = functor<is_infinite_t>
	elementwise callable returning a logical true if and only if the element is an infinite value
constexpr auto	is_less = functor<is_less_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is less than the second one.
constexpr auto	is_less_equal = functor<is_less_equal_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is less or equal to the second one.
constexpr auto	is_lessgreater = functor<is_lessgreater_t>
	elementwise callable returning a logical true if and only if the elements pair are not equal or unordered.
constexpr auto	is_lez = functor<is_lez_t>
	elementwise callable returning a logical true if and only if the element value is less or equal to 0.
constexpr auto	is_ltz = functor<is_ltz_t>
	elementwise callable returning a logical true if and only if the element value is less than 0.
constexpr auto	is_minf = functor<is_minf_t>
	elementwise callable returning a logical true if and only if the element is a negative infinite value
constexpr auto	is_nan = functor<is_nan_t>
	elementwise callable returning a logical true if and only if the element value is NaN
constexpr auto	is_negative = functor<is_negative_t>
	elementwise callable returning a logical true if and only if the element value is signed and has its sign bit set
constexpr auto	is_nemz = functor<is_nemz_t>
	elementwise callable returning a logical true if and only if a "negative" zero.
constexpr auto	is_nepz = functor<is_nepz_t>
	elementwise callable returning a logical true if and only if "positive" zero.
constexpr auto	is_nez = functor<is_nez_t>
	elementwise callable returning a logical true if and only if the element value is not zero.
constexpr auto	is_ngez = functor<is_ngez_t>
	elementwise callable returning a logical true if and only if the element value is not greater or equal to 0.
constexpr auto	is_ngtz = functor<is_ngtz_t>
	elementwise callable returning a logical true if and only if the element value is not greater than zero.
constexpr auto	is_nlez = functor<is_nlez_t>
	elementwise callable returning a logical true if and only if the element value is not less or equal to 0.
constexpr auto	is_nltz = functor<is_nltz_t>
	elementwise callable returning a logical true if and only if the element value is not less than zero.
constexpr auto	is_normal = functor<is_normal_t>
	elementwise callable returning a logical true if and only if the element value is normal.
constexpr auto	is_not_denormal = functor<is_not_denormal_t>
	elementwise callable returning a logical true if and only if the element value is not denormal.
constexpr auto	is_not_equal = functor<is_not_equal_t>
	elementwise callable returning a logical true if and only if the element values are not equal.
constexpr auto	is_not_finite = functor<is_not_finite_t>
	elementwise callable returning a logical true if and only if the element is not a finite value
constexpr auto	is_not_flint = functor<is_not_flint_t>
	elementwise callable returning a logical true if and only if the element value is a floating value not representing an integer
constexpr auto	is_not_greater = functor<is_not_greater_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is not greater than the second one.
constexpr auto	is_not_greater_equal = functor<is_not_greater_equal_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is greater or equal to the second one.
constexpr auto	is_not_infinite = functor<is_not_infinite_t>
	elementwise callable returning a logical true if and only if the element is not an infinite value
constexpr auto	is_not_less = functor<is_not_less_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is not less than the second one.
constexpr auto	is_not_less_equal = functor<is_not_less_equal_t>
	elementwise callable returning a logical true if and only if the element value of the first parameter is not less or equal to the second one.
constexpr auto	is_not_nan = functor<is_not_nan_t>
	elementwise callable returning a logical true if and only if the element value is not NaN
constexpr auto	is_odd = functor<is_odd_t>
	elementwise callable returning a logical true if and only if the element value is odd.
constexpr auto	is_ordered = functor<is_ordered_t>
	elementwise callable returning a logical true if and only no parameter is NaN.
constexpr auto	is_pinf = functor<is_pinf_t>
	elementwise callable returning a logical true if and only if the element is a positive infinite value
constexpr auto	is_positive = functor<is_positive_t>
	elementwise callable returning a logical true if and only if the element value is signed and has its sign bit not set
constexpr auto	is_pow2 = functor<is_pow2_t>
	elementwise callable returning a logical true if and only if the element value is a power of 2.
constexpr auto	is_unit = functor<is_unit_t>
	elementwise callable returning a logical true if and only if the element value is zero.
constexpr auto	is_unordered = functor<is_unordered_t>
	elementwise callable returning a logical true if and only if at least one of the parameters is NaN.
constexpr auto	iterate_selected = functor<iterate_selected_t>
	a utility to do scalar iteration over all true elements in a logical.
constexpr auto	ldexp = functor<ldexp_t>
	strict_elementwise callable computing \(\textstyle x 2^n\).
constexpr auto	lerp = functor<lerp_t>
	Computes the linear interpolation.
constexpr auto	lo = functor<lo_t>
	Computes the least significant half of each lane.
constexpr auto	logical_and = functor<logical_and_t>
	strict_elementwise_callable computing the logical AND of its arguments.
constexpr auto	logical_andnot = functor<logical_andnot_t>
	Computes the logical ANDNOT of its arguments.
constexpr auto	logical_not = functor<logical_not_t>
	Computes the logical NOT of its argument.
constexpr auto	logical_notand = functor<logical_notand_t>
	Computes the logical NOTAND of its arguments.
constexpr auto	logical_notor = functor<logical_notor_t>
	Computes the logical NOTOR of its arguments.
constexpr auto	logical_or = functor<logical_or_t>
	Computes the logical OR of its arguments.
constexpr auto	logical_ornot = functor<logical_ornot_t>
	Computes the logical ORNOT of its arguments.
constexpr auto	logical_xor = functor<logical_xor_t>
	Computes the logical XOR of its arguments.
constexpr auto	lohi = functor<lohi_t>
	elementwise_callable computing the the lohi pair of values.
constexpr auto	manhattan = functor<manhattan_t>
	tuple_callable object computing the manhattan norm ( \(l_1\)) of its arguments.
constexpr auto	mantissa = functor<mantissa_t>
	elementwise_callable object computing the IEEE mantissa of the floating value.
constexpr auto	max = functor<max_t>
	Computes the maximum of its arguments.
constexpr auto	maxabs = functor<maxabs_t>
	Computes the maximum of the absolute value norm ( \(l_\infty\)) of its arguments.
constexpr callable_maximum_	maximum = {}
	Computes the maximal value in a simd vector.
constexpr auto	maxmag = functor<maxmag_t>
	Computes the value for which the maximum of the absolute value of its arguments is obtained.
constexpr auto	min = functor<min_t>
	Computes the minimum of its arguments.
constexpr auto	minabs = functor<minabs_t>
	Computes the minimum of the absolute value of its arguments.
constexpr callable_minimum_	minimum = {}
	Computes the minimal value in a simd vector.
constexpr auto	minmag = functor<minmag_t>
	Computes the value for which the minimum of the absolute value of its arguments is obtained.
constexpr auto	minmax = functor<minmax_t>
	Computes the minimum and maximum of its arguments.
constexpr auto	minus = functor<minus_t>
	Computes the opposite of the parameter that must be signed.
constexpr auto	modf = functor<modf_t>
	elementwise_callable object computing the elementwise pair of fractional and integral parts of the value,
constexpr auto	mul = functor<mul_t>
	tuple_callablecomputing the product of its arguments. ! ! @groupheader{Header file} ! ! @code //! #include <eve/module/core.hpp> //! @endcode ! ! @groupheader{Callable Signatures} ! ! @code //! namespace eve //! { //! // Regular overloads //! constexpr auto mul(value auto x, value auto ... xs) noexcept; // 1 //! constexpr auto mul(kumi::non_empty_product_type auto const& tup) noexcept; // 2 //! //! // Lanes masking //! constexpr auto mul[conditional_expr auto c](/*any of the above overloads*/) noexcept; // 3 //! constexpr auto mul[logical_value auto m](/*any of the above overloads*/) noexcept; // 3 //! //! // Semantic options //! constexpr auto mul[saturated](/*any of the above overloads*/) noexcept; // 4 //! constexpr auto mul[lower](/*any of the above overloads*/) noexcept; // 5 //! constexpr auto mul[upper](/*any of the above overloads*/) noexcept; // 6 //! constexpr auto mul[lower][strict](/*any of the above overloads*/) noexcept; // 5 //! constexpr auto mul[upper][strict](/*any of the above overloads*/) noexcept; // 6 //! constexpr auto sub[widen](/*any of the above overloads*/) noexcept; // 7 //! } //! @endcode ! ! **Parameters** ! ! *... xs: [real](@ref eve::value) arguments. ! *tup: [non empty tuple](@ref kumi::non_empty_product_type) of arguments. ! *c: [Conditional expression](@ref eve::conditional_expr) masking the operation. ! *m: [Logical value](@ref eve::logical_value) masking the operation. ! ! **Return value** ! ! The value of the product of the arguments is returned. ! 1. Take care that for floating entries, the multiplication is not perfectly associative due to rounding errors. ! This call performs multiplications in reverse incoming order. ! 2. equivalent to the call on the elements of the tuple. ! 3. [The operation is performed conditionnaly](@ref conditional) ! 4. The callmulsaturatedcomputes a saturated version ofmul. ! Take care that for signed integral entries this kind of multiplication is not associative at all. ! This call perform saturated multiplications in reverse incoming order. ! 5. The product is computed in a 'round toward \f$-\infty\f$ mode. The result is guaranted ! to be less or equal to the exact one (except for Nans). Combined withstrictthe option ! ensures generally faster computation, but strict inequality. ! 6. The product is computed in a 'round toward \f$\infty\f$ mode. The result is guaranted ! to be greater or equal to the exact one (except for Nans). Combined withstrictthe option ! ensures generally faster computation, but strict inequality. ! 7. The operation is computed in the double sized element type (if available). ! This decorator has no effect on double and 64 bits integrals. ! ! @note ! Although the infix notation with*is supported for two parameters, the*` operator on standard scalar types is the original one and so can lead to automatic promotion.
constexpr auto	nb_values = functor<nb_values_t>
	elementwise_callable object computing the number of values representable in the type between the arguments.
constexpr auto	nearest = functor<nearest_t>
	strict_elementwise_callable object computing the nearest integer to the input.
constexpr auto	negabsmax = functor<negabsmax_t>
	tuple_callable computing the absolute value of the maximal element.
constexpr auto	negabsmin = functor<negabsmin_t>
	tuple_callable computing the absolute value of the minimal element.
constexpr auto	negate = functor<negate_t>
	elementwise_callable object computing the product of the first parameter by the sign of the second.
constexpr auto	negatenz = functor<negatenz_t>
	elementwise_callable object computing the product of the first parameter by the never zero sign of the second.
constexpr auto	negmaxabs = functor<negmaxabs_t>
	tuple_callable object computing the negated value of the element of maximal absolute value.
constexpr auto	negminabs = functor<negminabs_t>
	tuple_callable computing the negated value of the element of minimal absolute value.
constexpr auto	next = functor<next_t>
	strict_elementwise_callable computing the nth next representable element
constexpr auto	nextafter = functor<nextafter_t>
	elementwise_callable object computing the next representable element element in the second parameter direction.
constexpr callable_none_	none = {}
	Computes a bool value which is true if and only if all elements of x are 0.
constexpr auto	of_class = functor<of_class_t>
	strict_elementwise_callable object computing classification of elements of the input.
constexpr auto	oneminus = functor<oneminus_t>
	elementwise_callable computing the value of one minus the input.
constexpr auto	popcount = functor<popcount_t>
	elementwise_callable object computing elementwise the number of bits set in the parameter.
constexpr auto	prev = functor<prev_t>
	Computes the nth previous representable element.
constexpr auto	rat = functor<rat_t>
	elementwise_callable object computing a rational approximation.
constexpr auto	read = functor<read_t>
	Callable object reading single value from memory.
constexpr auto	rec = functor<rec_t>
	Computes the inverse of the parameter.
constexpr callable_reduce_	reduce = {}
	Computes the TODO.
constexpr auto	reldist = functor<reldist_t>
	elementwise_callable object computing the relative distance of its arguments.
constexpr auto	rem = functor<rem_t>
	elementwise_callable object computing the remainder after division.
constexpr auto	remainder = functor<remainder_t>
	mimick the std::remainder function for floating values.
constexpr callable_replace_ignored_	replace_ignored = {}
	A small helper to replace ignored values.
constexpr callable_rotate_	rotate = {}
	rotates two halves of the register by a chosen number of elements.
constexpr auto	rotl = functor<rotl_t>
	Bitwise rotation to the left.
constexpr auto	rotr = functor<rotr_t>
	Bitwise rotation to the right.
constexpr auto	round = functor<round_t>
	Computes the integer nearest to the input.
constexpr auto	roundscale = functor<roundscale_t>
	strict_elementwise_callable object computing the scaled input rounding.
constexpr auto	rshl = functor<rshl_t>
	Computes the arithmetic left/right shift operation according to shift sign.
constexpr auto	rshr = functor<rshr_t>
	Computes the arithmetic right/left shift operation according to shift sign.
constexpr auto	rsqrt = functor<rsqrt_t>
	Computes the inverse of the square root of the parameter.
constexpr auto	saturate = functor<saturate_t>
	strict_elementwise_callable computing the saturation of a value in a type.
constexpr callable_scan_	scan = {}
	Computes the TODO.
constexpr auto	scatter = functor<scatter_t>
	Store a SIMD register to memory using scattered indexes.
constexpr auto	shl = functor<shl_t>
	Computes the arithmetic left shift operation.
constexpr auto	shr = functor<shr_t>
	Computes the arithmetic right shift operation.
constexpr auto	sign = functor<sign_t>
	elementwise_callable object computing the sign of the parameter.
constexpr auto	sign_alternate = functor<sign_alternate_t>
	Computes \((-1)^n\).
constexpr auto	signnz = functor<signnz_t>
	elementwise_callable object computing the never zero sign of the parameter.
constexpr auto	simd_cast = functor<simd_cast_t>
	casting bits between simd values.
constexpr callable_slide_left_	slide_left = {}
	a named shuffles for sliding two simd values together and selecting one register. Common names for this would also include "shift", "extract". Second value can be ommitted for an implicit zero.
constexpr auto	sort = functor<sort_t>
	sorts a register in a accedning order accroding to a comparator.
constexpr splat_type const	splat = {}
	Computes the TODO.
constexpr auto	sqr = functor<sqr_t>
	Computes the square of the parameter.
constexpr auto	sqrt = functor<sqrt_t>
	Computes the square root of the parameter.
constexpr callable_store_	store = {}
	Callable object computing //! description NOT FOUND.
constexpr callable_store_equivalent_	store_equivalent = {}
	Callable object, customisation point. If an iterator's store operation can be done as a store to some other iterator/pointer - this is a transformation to customize.
constexpr auto	sub = functor<sub_t>
	tuple_callable computing the difference of its first argument with the sum of the others.
constexpr auto	sum_of_prod = functor<sum_of_prod_t>
	elementwise_callable object computing the sum of products operation with better accuracy than the naive formula.
constexpr callable_swap_pairs_	swap_pairs = {}
	swap chosen pair of elements.
constexpr auto	three_fma = functor<three_fma_t>
	Computes the elementwise triplet of an fma value f and two errors e1 and e2 such that \(ax+y = f+r_1+r_2\).
constexpr auto	trunc = functor<trunc_t>
	elementwise_callable object computing the integral part of x with the same sign as x.
constexpr callable_try_each_group_position_	try_each_group_position = {}
	For a given simd_value and a group size returns a tuple of (x::size() / group_size) permuatitions for this register such that each group will be in each position exactly once.
constexpr auto	two_add = functor<two_add_t>
	Computes the elementwise pair of sum and error,.
constexpr auto	two_prod = functor<two_prod_t>
	Computes the elementwise pair of product and error,.
constexpr auto	ulpdist = functor<ulpdist_t>
	Computes the unit in the last place distance of its arguments.
constexpr auto	unalign = functor<unalign_t>
	Callable object for computing an unaligned version of a relaxed iterator.
constexpr auto	write = functor<write_t>
	Callable object writing a scalar value to memory.
constexpr auto	zip = functor<zip_t>
	Callable for SoA value constructions.
constexpr auto	ellint_1 = functor<ellint_1_t>
	elementwise_callable object computing the elliptic integrals of the first kind.
constexpr auto	ellint_2 = functor<ellint_2_t>
	elementwise_callable object computing the elliptic integrals of the second kind.
constexpr auto	ellint_d = functor<ellint_d_t>
	elementwise_callable object computing the \(\mbox{D}\) elliptic integral.
constexpr auto	ellint_rc = functor<ellint_rc_t>
	elementwise_callable object computing the degenerate Carlson's elliptic integral \( \mathbf{R}_\mathbf{C}(x, y) = \frac12 \int_{0}^{\infty} \scriptstyle(t+x)^{-1/2}(t+y)^{-1}\scriptstyle\;\mathrm{d}t\).
constexpr auto	ellint_rd = functor<ellint_rd_t>
	elementwise_callable object computing the Carlson's elliptic integral \( \mathbf{R}_\mathbf{D}(x, y) = \frac32 \int_{0}^{\infty} \scriptstyle[(t+x)(t+y)]^{-1/2} (t+z)^{-3/2}\scriptstyle\;\mathrm{d}t\).
constexpr auto	ellint_rf = functor<ellint_rf_t>
	Computes the Carlson's elliptic integral \( \mathbf{R}_\mathbf{F}(x, y) = \frac32 \int_{0}^{\infty} \scriptstyle[(t+x)(t+y)]^{-1/2} (t+z)^{-3/2}\scriptstyle\;\mathrm{d}t\).
constexpr auto	ellint_rg = functor<ellint_rg_t>
	Computes the Carlson's elliptic integral \( \mathbf{R}_\mathbf{G}(x, y) = \frac1{4\pi} \int_{0}^{2\pi}\int_{0}^{\pi} \scriptstyle\sqrt{x\sin^2\theta\cos^2\phi +y\sin^2\theta\sin^2\phi +z\cos^2\theta} \scriptstyle\;\mathrm{d}\theta\;\mathrm{d}\phi\).
constexpr auto	ellint_rj = functor<ellint_rj_t>
	Computes the Carlson's elliptic integral \( \mathbf{R}_\mathbf{J}(x, y) = \frac32 \int_{0}^{\infty} \scriptstyle(t+p)^{-1}[(t+x)(t+y)(t+z)]^{-1/2}\scriptstyle\;\mathrm{d}t\).
constexpr auto	catalan = functor<catalan_t>
	Callable object computing the catalan constant \(\beta(2) = \sum_0^\infty \frac{(-1)^n}{(2n+1)^2}\).
constexpr auto	cbrt_pi = functor<cbrt_pi_t>
	Callable object computing the constant \(\sqrt[3]\pi\).
constexpr auto	cos_1 = functor<cos_1_t>
	Callable object computing the constant \(\cos1\).
constexpr auto	cosh_1 = functor<cosh_1_t>
	Callable object computing the constant \(\cosh(1)\).
constexpr auto	egamma = functor<egamma_t>
	Callable object computing the Euler-Mascheroni constant : \(\gamma = \lim_{n\to\infty}\left( \sum_{k = 0}^n \frac1k - \log n\right )\).
constexpr auto	egamma_sqr = functor<egamma_sqr_t>
	Callable object computing the square of the [Euler-Mascheroni constant](eve::egamma).
constexpr auto	epso_2 = functor<epso_2_t>
	Callable object computing the half of the machine epsilon.
constexpr auto	euler = functor<euler_t>
	Callable object computing the constant e basis of the natural logarithms.
constexpr auto	exp_pi = functor<exp_pi_t>
	Callable object computing the constant \(e^\pi\).
constexpr auto	extreme_value_skewness = functor<extreme_value_skewness_t>
	Callable object computing the extreme value distribution skewness : \(12\sqrt6\zeta(3)/\pi^3\).
constexpr auto	four_minus_pi = functor<four_minus_pi_t>
	Callable object computing the constant \(4-\pi\).
constexpr auto	four_pio_3 = functor<four_pio_3_t>
	Callable object computing the constant \(4\pi/3\).
constexpr auto	glaisher = functor<glaisher_t>
	Callable object computing the Glaisher-Kinkelin constant.
constexpr auto	inv_2eps = functor<inv_2eps_t>
	Callable object computing half the inverse of the machine epsilon.
constexpr auto	inv_2pi = functor<inv_2pi_t>
	Callable object computing the constant \(\frac{1}{2\pi}\).
constexpr auto	inv_e = functor<inv_e_t>
	Callable object computing the constant \(e^{-1}\).
constexpr auto	inv_egamma = functor<inv_egamma_t>
	Callable object computing the inverse of the [Euler-Mascheroni constant](eve::egamma).
constexpr auto	inv_pi = functor<inv_pi_t>
	Callable object computing the constant \(\frac{1}{\pi}\).
constexpr auto	invcbrt_pi = functor<invcbrt_pi_t>
	Callable object computing the constant \(\pi^{-1/3}\).
constexpr auto	invlog10_2 = functor<invlog10_2_t>
	Callable object computing the constant \(1/\log_{10}2\).
constexpr auto	invlog10_e = functor<invlog10_e_t>
	Callable object computing the constant \(1/\log_{10}e\).
constexpr auto	invlog_10 = functor<invlog_10_t>
	Callable object computing \(1/\log10\).
constexpr auto	invlog_2 = functor<invlog_2_t>
	Callable object computing the constant \(1/\log2\).
constexpr auto	invlog_phi = functor<invlog_phi_t>
	Callable object computing the inverse of the logarithm of the golden ratio : \(1/\log((1+\sqrt5)/2)\).
constexpr auto	invsqrt_2 = functor<invsqrt_2_t>
	Callable object computing the constant \(2^{-1/2}\).
constexpr auto	khinchin = functor<khinchin_t>
	Callable object computing the Khinchin constant.
constexpr auto	log10_e = functor<log10_e_t>
	Callable object computing the constant \(\log_{10}e\).
constexpr auto	log2_e = functor<log2_e_t>
	Callable object computing the constant \(\log_2 e\).
constexpr auto	log_10 = functor<log_10_t>
	Callable object computing the constant \(\log 10\).
constexpr auto	log_2 = functor<log_2_t>
	Callable object computing the constant \(\log 2\).
constexpr auto	log_phi = functor<log_phi_t>
	Callable object computing the logarithm of the golden ratio : \(\log((1+\sqrt5)/2)\).
constexpr auto	loglog_2 = functor<loglog_2_t>
	Callable object computing the constant \(\log(\log2)\).
constexpr auto	maxlog = functor<maxlog_t>
	Callable object computing the greatest positive value for which eve::exp is finite.
constexpr auto	maxlog10 = functor<maxlog10_t>
	Callable object computing the greatest positive value for which eve::exp10 is finite.
constexpr auto	maxlog2 = functor<maxlog2_t>
	Callable object computing the greatest positive value for which eve::exp2 is finite.
constexpr auto	minlog = functor<minlog_t>
	Callable object computing the least value for which eve::exp is not zero.
constexpr auto	minlog10 = functor<minlog10_t>
	Callable object computing the least value for which eve::exp10 is not zero.
constexpr auto	minlog10denormal = functor<minlog10denormal_t>
	Callable object computing the least value for which eve::exp10 is not zero.
constexpr auto	minlog2 = functor<minlog2_t>
	Callable object computing the least value for which eve::exp2 is not zero.
constexpr auto	minlog2denormal = functor<minlog2denormal_t>
	Callable object computing the least value for which eve::exp2 is not denormal.
constexpr auto	minlogdenormal = functor<minlogdenormal_t>
	Callable object computing the least value for which eve::exp is not denormal.
constexpr auto	oneotwoeps = functor<oneotwoeps_t>
	Computes a constant to the machine oneotwoepsilon.
constexpr auto	phi = functor<phi_t>
	Callable object computing the golden ratio : \(\frac{1+\sqrt5}2\).
constexpr auto	pi = functor<pi_t>
	Callable object computing the constant \(\pi\).
constexpr auto	pi2 = functor<pi2_t>
	Callable object computing the square of \(\pi\).
constexpr auto	pi2o_16 = functor<pi2o_16_t>
	Callable object computing the constant \(\pi^2/16\).
constexpr auto	pi2o_6 = functor<pi2o_6_t>
	Callable object computing the constant \(\pi^2/6\).
constexpr auto	pi3 = functor<pi3_t>
	Callable object computing the pi cubed value : \(\pi^3\).
constexpr auto	pi_minus_3 = functor<pi_minus_3_t>
	Callable object computing the constant \(\pi-3\).
constexpr auto	pi_pow_e = functor<pi_pow_e_t>
	Callable object computing the constant \(\pi^e\).
constexpr auto	pio_2 = functor<pio_2_t>
	Callable object computing the constant \(\pi/2\).
constexpr auto	pio_3 = functor<pio_3_t>
	Callable object computing the constant \(\pi/3\).
constexpr auto	pio_4 = functor<pio_4_t>
	Callable object computing the constant \(\pi/4\).
constexpr auto	pio_6 = functor<pio_6_t>
	Callable object computing the constant \(\pi/6\).
constexpr auto	quarter = functor<quarter_t>
	Callable object computing the constant \(1/3\).
constexpr auto	rayleigh_kurtosis = functor<rayleigh_kurtosis_t>
	Callable object computing the Rayleigh kurtosis value : \(3+(6\pi^2-24\pi+16)/(4-\pi^2)\).
constexpr auto	rayleigh_kurtosis_excess = functor<rayleigh_kurtosis_excess_t>
	Callable object computing the Rayleigh kurtosis excess value : \(-(6\pi^2-24\pi+16)/(4-\pi^2)\).
constexpr auto	rayleigh_skewness = functor<rayleigh_skewness_t>
	Callable object computing the Rayleigh skewness value : \(2\sqrt\pi(\pi-3)/(4-\pi^{3/2})\).
constexpr auto	rsqrt_2pi = functor<rsqrt_2pi_t>
	Callable object computing the constant \(1/\sqrt{2\pi}\).
constexpr auto	rsqrt_e = functor<rsqrt_e_t>
	Callable object computing the constant \(1/\sqrt{e}\).
constexpr auto	rsqrt_pi = functor<rsqrt_pi_t>
	Callable object computing the constant \(\pi^{-1/2}\).
constexpr auto	rsqrt_pio_2 = functor<rsqrt_pio_2_t>
	Callable object computing the constant \((\pi/2)^{-1/2}\).
constexpr auto	sin_1 = functor<sin_1_t>
	Callable object computing the constant \(\sin(1)\).
constexpr auto	sinh_1 = functor<sinh_1_t>
	Callable object computing the constant \(\sinh(1)\).
constexpr auto	sixth = functor<sixth_t>
	Callable object computing the constant \(1/6\).
constexpr auto	sqrt_2 = functor<sqrt_2_t>
	Callable object computing the constant \(\sqrt2\).
constexpr auto	sqrt_2pi = functor<sqrt_2pi_t>
	Callable object computing the constant \(\sqrt{2\pi}\).
constexpr auto	sqrt_3 = functor<sqrt_3_t>
	Callable object computing constant \(\sqrt{3}\).
constexpr auto	sqrt_e = functor<sqrt_e_t>
	Callable object computing the constant \(\sqrt{e}\).
constexpr auto	sqrt_pi = functor<sqrt_pi_t>
	Callable object computing the constant \(\sqrt{\pi}\).
constexpr auto	sqrt_pio_2 = functor<sqrt_pio_2_t>
	Callable object computing the constant \(\sqrt{\pi/2}\).
constexpr auto	sqrtlog_4 = functor<sqrtlog_4_t>
	Callable object computing the constant \(\sqrt{\log4}\).
constexpr auto	third = functor<third_t>
	Callable object computing the constant \(1/3\).
constexpr auto	three_o_4 = functor<three_o_4_t>
	Callable object computing the constant \(3/4\).
constexpr auto	three_pio_4 = functor<three_pio_4_t>
	Callable object computing the constant \(3\pi/4\).
constexpr auto	two_o_3 = functor<two_o_3_t>
	Callable object computing the constant \(2/3\).
constexpr auto	two_o_pi = functor<two_o_pi_t>
	Callable object computing the constant \(2/\pi\).
constexpr auto	two_o_sqrt_pi = functor<two_o_sqrt_pi_t>
	Callable object computing the constant \(2/\sqrt\pi\).
constexpr auto	two_pi = functor<two_pi_t>
	Callable object computing the constant \(2\pi\).
constexpr auto	two_pio_3 = functor<two_pio_3_t>
	Callable object computing the constant \(2\pi/3\).
constexpr auto	zeta_2 = functor<zeta_2_t>
	Callable object computing the constant \(\zeta(2)\).
constexpr auto	zeta_3 = functor<zeta_3_t>
	Callable object computing the constant \(\zeta(3)\).
constexpr auto	acos = functor<acos_t>
	elementwise_callable object computing the arc cosine.
constexpr auto	acosd = functor<acosd_t>
	elementwise_callable object computing the arc cosine in degree.
constexpr auto	acosh = functor<acosh_t>
	elementwise_callable object computing \(\log(x+\sqrt{x^2-1})\).
constexpr auto	acospi = functor<acospi_t>
	elementwise_callable object computing the arc cosine in \(\pi\) multiples.
constexpr auto	acot = functor<acot_t>
	elementwise_callable object computing the arc cotangent.
constexpr auto	acotd = functor<acotd_t>
	elementwise_callable object computing the arc cotangent in degree.
constexpr auto	acoth = functor<acoth_t>
	elementwise_callable object computing the inverse hyperbolic cotangent.
constexpr auto	acotpi = functor<acotpi_t>
	Callable object computing te arc cotangent in \(\pi\) multiples.
constexpr auto	acsc = functor<acsc_t>
	Callable object computing the arc cosecant.
constexpr auto	acscd = functor<acscd_t>
	elementwise_callable object computing the arc cosecant.
constexpr auto	acsch = functor<acsch_t>
	elementwise_callable object computing the inverse hyperbolic cosecant, \(\log(1/x+\sqrt{1/x^2+1})\).
constexpr auto	acscpi = functor<acscpi_t>
	elementwise_callable object computing the arc cosecant in \(\pi\) multiples.
constexpr auto	agd = functor<agd_t>
	elementwise_callable object computing the inverse gudermannian, i.e. \(2\tanh(\tan(x/2))\).
constexpr auto	arg = functor<arg_t>
	elementwise_callable object computing the phase angle (in radians).
constexpr auto	asec = functor<asec_t>
	elementwise_callable object computing the arc secant.
constexpr auto	asecd = functor<asecd_t>
	elementwise_callable object computing the arc secant in degree.
constexpr auto	asech = functor<asech_t>
	elementwise_callable object computing the inverse hyperbolic secant: \(\log(1/x+\sqrt{1/x^2-1})\).
constexpr auto	asecpi = functor<asecpi_t>
	Callable object computing the arc secant in \(\pi\) multiples.
constexpr auto	asin = functor<asin_t>
	elementwise_callable object computing the arc sine.
constexpr auto	asind = functor<asind_t>
	elementwise_callable object computing the arc sine in degree.
constexpr auto	asinh = functor<asinh_t>
	elementwise_callable object computing the inverse hyperbolic sine : \(\log(x+\sqrt{x^2+1})\).
constexpr auto	asinpi = functor<asinpi_t>
	Callable object computing te arc sine in \(\pi\) multiples.
constexpr auto	atan = functor<atan_t>
	elementwise_callable object computing the arc tangent.
constexpr auto	atan2 = functor<atan2_t>
	elementwise_callable object computing the arc tangent using the signs of the arguments to determine the correct quadrant.
constexpr auto	atan2d = functor<atan2d_t>
	elementwise_callable object computing the arc tangent in degrees using the signs of the arguments to determine the correct quadrant.
constexpr auto	atan2pi = functor<atan2pi_t>
	elementwise_callable object computing the arc tangent in degrees using the signs of the arguments to determine the correct quadrant.
constexpr auto	atand = functor<atand_t>
	elementwise_callable object computing the arc tangent in degree.
constexpr auto	atanh = functor<atanh_t>
	elementwise_callable object computing the inverse hyperbolic tangent.
constexpr auto	atanpi = functor<atanpi_t>
	Callable object computing te arc tangent in \(\pi\) multiples.
constexpr auto	cbrt = functor<cbrt_t>
	elementwise_callable object computing the cubic root.
constexpr auto	cos = functor<cos_t>
	elementwise_callable object computing the cosine.
constexpr auto	cosd = functor<cosd_t>
	elementwise_callable object object computing cosine from an input in degrees.
constexpr auto	cosh = functor<cosh_t>
	elementwise_callable object computing the hyperbolic cosine: \(\frac{e^x+e^{-x}}2\).
constexpr auto	cospi = functor<cospi_t>
	elementwise_callable object computing the cosine from an input in \(\pi\) multiples.
constexpr auto	cot = functor<cot_t>
	elementwise_callable object computing the cotangent of the input.
constexpr auto	cotd = functor<cotd_t>
	elementwise_callable object computing the cotangent from an input in degrees.
constexpr auto	coth = functor<coth_t>
	elementwise_callable object computing the hyperbolic cotangent: \(\frac{e^x+e^{-x}}{e^x-e^{-x}}\).
constexpr auto	cotpi = functor<cotpi_t>
	elementwise_callable object computing the cotangent from an input in \(\pi\) multiples.
constexpr auto	csc = functor<csc_t>
	elementwise_callable object computing the cosecant of the input.
constexpr auto	cscd = functor<cscd_t>
	elementwise_callable object computing the cosecant from an input in degree.
constexpr auto	csch = functor<csch_t>
	elementwise_callable object computing \(\frac2{e^x+e^{-x}}\).
constexpr auto	cscpi = functor<cscpi_t>
	elementwise_callable object computing the cosecant in \(\pi\) multiples.
constexpr auto	deginrad = functor<deginrad_t>
	elementwise_callable object computing the product of the input by \(\pi/180\).
constexpr auto	div_180 = functor<div_180_t>
	elementwise_callable object computing the product of the input by \(1/180\).
constexpr auto	exp = functor<exp_t>
	elementwise_callable object computing \(e^x\).
constexpr auto	exp10 = functor<exp10_t>
	Callable object computing \(10^x\).
constexpr auto	exp2 = functor<exp2_t>
	elementwise_callable object computing \(2^x\).
constexpr auto	expm1 = functor<expm1_t>
	Callable object computing \(e^x-1\).
constexpr auto	expmx2 = functor<expmx2_t>
	elementwise_callable object computing \(e^{-x^2}\).
constexpr auto	expx2 = functor<expx2_t>
	Callable object computing \(e^{x^2}\).
constexpr auto	gd = functor<gd_t>
	elementwise_callable object computing the gudermanian gd: \(\int_0^\infty 1/\cosh x dx\).
constexpr auto	geommean = functor<geommean_t>
	Callable object computing the geometric mean of the inputs. \( \left(\prod_{i = 1}^n x_i\right)^{1/n} \).
constexpr auto	horner = functor<horner_t>
	Implement the horner scheme to evaluate polynomials with coefficients in decreasing power order.
constexpr auto	hypot = functor<hypot_t>
	tuple_callable computing the \(l_2\) norm of its inputs.
constexpr auto	lentz_a = functor<lentz_a_t>
	Implement the lentz scheme to evaluate continued fractions.
constexpr auto	lentz_b = functor<lentz_b_t>
	Implement the lentz scheme to evaluate continued fractions.
constexpr auto	log = functor<log_t>
	elementwise_callable object computing the natural logarithm: \(\log x\).
constexpr auto	log10 = functor<log10_t>
	elementwise_callable object computing the base 10 logarithm: \(\log_{10} x\).
constexpr auto	log1p = functor<log1p_t>
	elementwise_callable object computing the natural logarithm of \(1+x\): \(\log(1+x)\).
constexpr auto	log2 = functor<log2_t>
	elementwise_callable object computing the base 2 logarithm: \(\log_2 x\).
constexpr auto	log_abs = functor<log_abs_t>
	Callable object computing the natural logarithm of the absolute value of the input.
constexpr auto	logspace_add = functor<logspace_add_t>
	tuple_callable object computing the logspace_add operation: \(\log\left(\sum_{i = 0}^n e^{\log x_i}\right)\)
constexpr auto	logspace_sub = functor<logspace_sub_t>
	tuple_callable object computing the logspace_sub operation: \(\log\left(e^{\log x_0}-\sum_{i = 1}^n e^{\log x_i}\right)\).
constexpr auto	lpnorm = functor<lpnorm_t>
	strict_elementwise_callable object computing the lpnorm operation \( \left(\sum_{i = 0}^n |x_i|^p\right)^{\frac1p} \).
constexpr auto	newton = functor<newton_t>
	Implement the Newton scheme to evaluate polynomials.
constexpr auto	nthroot = functor<nthroot_t>
	Callable object computing the nth root: \(x^{1/n}\).
constexpr auto	pow = functor<pow_t>
	Callable object computing the pow operation \(x^y\).
constexpr auto	pow1p = functor<pow1p_t>
	Callable object computing pow1p: \((1+x)^y\).
constexpr auto	pow_abs = functor<pow_abs_t>
	Callable object computing the pow_abs function \(|x|^y\).
constexpr auto	powm1 = functor<powm1_t>
	Callable object computing powm1: \(x^y-1\).
constexpr auto	quadrant = functor<quadrant_t>
	Callable object computing the quadrant value.
constexpr auto	radindeg = functor<radindeg_t>
	elementwise_callable object multiplying the input by \(180/\pi\).
constexpr auto	radinpi = functor<radinpi_t>
	elementwise_callable object multiplying the input by \(1/\pi\).
constexpr auto	rempio2 = functor<rempio2_t>
	elementwise_callable object computing the remainder of the division by \(\pi/2\).
constexpr auto	reverse_horner = functor<reverse_horner_t>
	implement the horner scheme to evaluate polynomials with coefficients in increasing power order
constexpr auto	sec = functor<sec_t>
	elementwise_callable object computing the secant of the input.
constexpr auto	secd = functor<secd_t>
	elementwise_callable object computing the secant from an input in degree.
constexpr auto	sech = functor<sech_t>
	elementwise_callable object computing \(\frac2{e^x-e^{-x}}\).
constexpr auto	secpi = functor<secpi_t>
	elementwise_callable object computing secant from an input in \(\pi\) multiples.
constexpr auto	sigmoid = functor<sigmoid_t>
	elementwise_callable object computing the sigmoid (logistic function).
constexpr auto	significants = functor<significants_t>
	Computes the rounding to n significants digits of the first input.
constexpr auto	sin = functor<sin_t>
	elementwise_callable object computing the sine.
constexpr auto	sinc = functor<sinc_t>
	elementwise_callable object computing the sine cardinal.
constexpr auto	sincos = functor<sincos_t>
	elementwise_callable object computing the simultaneous computation of sine an cosine.
constexpr auto	sind = functor<sind_t>
	elementwise_callable object computing the sine from an input in degrees.
constexpr auto	sindcosd = functor<sindcosd_t>
	elementwise_callable object computing the simultaneous computation of sine an cosine from an argument in degrees.
constexpr auto	sinh = functor<sinh_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}2\).
constexpr auto	sinhc = functor<sinhc_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}{2x}\).
constexpr auto	sinhcosh = functor<sinhcosh_t>
	Callable object performing the simultaneous computations of the hyperbolic sine and cosine.
constexpr auto	sinpi = functor<sinpi_t>
	elementwise_callable object computing the sine from an input in \(\pi\) multiples.
constexpr auto	sinpic = functor<sinpic_t>
	elementwise_callable object computing the normalized cardinal sine.
constexpr auto	sinpicospi = functor<sinpicospi_t>
	elementwise_callable object computing the simultaneous computation of sin an cos from an argument in \(\pi\) multiples.
constexpr auto	tan = functor<tan_t>
	elementwise_callable object computing the tangent.
constexpr auto	tand = functor<tand_t>
	elementwise_callable object computing the tangent from an input in degrees.
constexpr auto	tanh = functor<tanh_t>
	elementwise_callable object computing \(\frac{e^x-e^{-x}}{e^x+e^{-x}}\).
constexpr auto	tanpi = functor<tanpi_t>
	elementwise_callable object computing the tangent from an input in \(\pi\) multiples.
constexpr auto	abel = functor<abel_t>
	Computes the value of the Abel polynomial of order n at x: \(x(x-an)^{n-1}\).
constexpr auto	gegenbauer = functor<gegenbauer_t>
	strict_elementwise_callable object computing the value of a gegenbauer polynomial \( \mathbf{C}_n^\lambda(x)\).
constexpr auto	hermite = functor<hermite_t>
	strict_elementwise_callable object computing the value of the 'physicists' Hermite polynomial of order n at x:
constexpr auto	jacobi = functor<jacobi_t>
	strict_elementwise_callable object computing the value of the Jacobi polynomials \(P^{\alpha, \beta}_n(x)\).
constexpr auto	laguerre = functor<laguerre_t>
	strict_elementwise_callable object computing the value of the Laguerre and associated Laguerre polynomials of order n at x:
constexpr auto	legendre = functor<legendre_t>
	Computes the value of the Legendre and associated Legendre polynomials of order n at x:
constexpr auto	tchebytchev = functor<tchebytchev_t>
	Computes the value of the Tchebytchev polynomial of order n at x:
constexpr auto	beta = functor<beta_t>
	elementwise_callable object computing the beta function: \(\displaystyle \mathbf{B}(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\).
constexpr auto	betainc = functor<betainc_t>
	Computes the betainc incomplete function. \(\displaystyle \mbox{I}_s(x,y) = \frac{1}{\mbox{B}(x,y)}\int_0^s t^{x-1}(1-t)^{y-1}\mbox{d}t\).
constexpr auto	betainc_inv = functor<betainc_inv_t>
	elementwise_callable object computing the inverse relative to the first parameter of the beta incomplete function.
constexpr auto	dawson = functor<dawson_t>
	elementwise_callable object computing the Dawson function: \(\displaystyle D_+(x)=e^{-x^2}\int_0^{x} e^{t^2} \mbox{d}t\)
constexpr auto	digamma = functor<digamma_t>
	elementwise_callable object computing the Digamma function i.e. the logarithmic derivative of the \(\Gamma\) function.
constexpr auto	double_factorial = functor<double_factorial_t>
	elementwise_callableobject computing the double factorial ofn ! ! THe double factorial is defined as \f$\displaystyle (2n)!! = //! \prod_{i=1}^n (2i)\f$ and \f$\displaystyle (2n+1)!! = \prod_{i=0}^n (2i+1)\f$ ! ! @groupheader{Header file} ! ! @code //! #include <eve/module/special.hpp> //! @endcode ! ! @groupheader{Callable Signatures} ! ! @code //! namespace eve //! { //! // Regular overload //! template <unsigned_value T> constexpr as_wide_as_t<double,T> double_factorial(T x) noexcept; // 1 //! //! // Lanes masking //! constexpr auto double_factorial[conditional_expr auto c](unsigned_value auto x) noexcept; // 2 //! constexpr auto double_factorial[logical_value auto m](unsigned_value auto x) noexcept; // 2 //! } //! @endcode ! ! **Parameters** ! ! *n: unsigned argument. ! *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 double factorial ofn` is returned.
constexpr auto	erf = functor<erf_t>
	elementwise_callable object computing the error function: \( \displaystyle \mbox{erf}(x)=\frac{2}{\sqrt\pi}\int_0^{x} e^{-t^2}\mbox{d}t\).
constexpr auto	erf_inv = functor<erf_inv_t>
	elementwise_callable object computing the inverse of the error function.
constexpr auto	erfc = functor<erfc_t>
	elementwise_callable object computing the complementary error function \( \displaystyle \mbox{erf}(x)=1-\frac{2}{\sqrt\pi}\int_0^{x} e^{-t^2}\mbox{d}t\)
constexpr auto	erfc_inv = functor<erfc_inv_t>
	Computes the inverse of the complementary error function.
constexpr auto	erfcx = functor<erfcx_t>
	Computes the normalized complementary error function \( \displaystyle \mbox{erfcx}(x) = e^{x^2} \mbox{erfc}(x)\).
constexpr auto	exp_int = functor<exp_int_t>
	elementwise_callable object computing the exponential integral \( \mathbf{E}_n(x) = \displaystyle \int_1^\infty \frac{e^{-xt}}{t^n}\;\mbox{d}t\).
constexpr auto	factorial = functor<factorial_t>
	elementwise_callable computing \(\displaystyle n! = \prod_{i=1}^n i\).
constexpr auto	gamma_p = functor<gamma_p_t>
	elementwise_callable object computing the normalized lower incomplete \(\Gamma\) function.
constexpr auto	gamma_p_inv = functor<gamma_p_inv_t>
	elementwise_callable object computing the inverse of the normalized lower incomplete \(\Gamma\) function.
constexpr auto	lambert = functor<lambert_t>
	Computes the inverse of the function \( x \rightarrow xe^x \).
constexpr auto	lbeta = functor<lbeta_t>
	elementwise_callable object computing the natural logarithm of the beta function.
constexpr auto	lfactorial = functor<lfactorial_t>
	elementwise_callable object computing the natural logarithm of the factorial of unsigned integer values \(\displaystyle \log n! = \sum_{i=1}^n \log i\).
constexpr auto	log_abs_gamma = functor<log_abs_gamma_t>
	elementwise_callable object computing the natural logarithm of the absolute value of the \(\Gamma\) function.
constexpr auto	log_gamma = functor<log_gamma_t>
	elementwise_callable object computing the natural logarithm of the \(\Gamma\) function.
constexpr auto	lrising_factorial = functor<lrising_factorial_t>
	elementwise_callable object computing the natural logarithm of the rising Factorial function i.e. \(\log\left(\frac{\Gamma(x+a)}{\Gamma(x)}\right)\).
constexpr auto	omega = functor<omega_t>
	Computes the Wright \(\omega\) the inverse function of \( x \rightarrow \log x+x\).
constexpr auto	rising_factorial = functor<rising_factorial_t>
	elementwise_callable object computing the rising Factorial function i.e. \(\frac{\Gamma(x+a)}{\Gamma(x)}\).
constexpr auto	signgam = functor<signgam_t>
	elementwise_callable object computing the sign of the \(\Gamma\) function.
constexpr auto	stirling = functor<stirling_t>
	elementwise_callable object computing the Stirling approximation of the \(\Gamma\) function.
constexpr auto	tgamma = functor<tgamma_t>
	elementwise_callable object computing \(\displaystyle \Gamma(x)=\int_0^\infty t^{x-1}e^{-t}\mbox{d}t\).
constexpr auto	zeta = functor<zeta_t>
	Computes the Riemann \(\zeta\) function.
constexpr std::ptrdiff_t	na_ = -1
	Tag for zeroing swizzle index.
constexpr std::ptrdiff_t	we_ = -2
	Tag for indicating to a shuffle that the value doesn't matter.
template<std::ptrdiff_t... I>
constexpr auto	pattern = pattern_t<I...>{}
	Generate a shuffling pattern.
template<typename T >
constexpr std::size_t	max_scalar_size_v
	A meta function for getting a maximum size of scalar.
template<template< typename > class Func>
constexpr auto	functor = Func<eve::options<>>{}
	EVE's Callable Object generator.
constexpr detail::condition_key_t	condition_key = {}
	Keyword for retrieving conditionals decorator.
template<typename... Ts>
constexpr bool	same_lanes_or_scalar = detail::lanes_check<Ts...>()
	Checks that all types Ts are either scalar or share a common number of lanes.
template<typename T >
constexpr bool	same_lanes_or_scalar_tuple = detail::tuple_lanes_check<T>()
	Checks that all types within a product type are either scalar or share a common number of lanes.
template<simd_value T0, simd_value... Ts>
constexpr bool	same_lanes = ((cardinal_v<T0> == cardinal_v<Ts>) && ... && true)
	Checks that all SIMD types Ts share a common number of lanes.