eve Namespace Reference

EVE Main Namespace. More...

Detailed Description

This namespace contains all the elements required to use EVE

EVE - Expressive Vector Engine Copyright : EVE Contributors & Maintainers SPDX-License-Identifier: MIT

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	comparisons
	Extension point for ordering and equality computation. 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	translation_of
	Notifies EVE that a type is translatable and its translation target. 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	combinable
	Checks that the types passed are all SIMD values that can be passed to eve::combine. i.e they share a common value type and their cardinals and numbers are consistent with eve::combine semantics.
concept	combinable_to
	Checks that the types passed can be passed to eve::combine and that the resulting type would be Tgt.
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	invocable_returning
	Specifies that the function Op, when called with arguments of types Args..., returns a value convertible to R.
concept	simd_predicate
	Specifies a predicate that returns a logical value.
concept	monoid
	Specifies that Op is a monoid function operating on values of type T.
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	translatable_ptr
	Specify that a type is a scalar pointer to a type that has a plain translation.
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	relaxed_logical_scalar_value
	The concept relaxed_logical_scalar_value<T> is satisfied if and only if T is a boolean value or satisfies the eve::logical_scalar_value concept.
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	substitute_for
	Specify that a type can be used as a substitute for another type after calling eve::as_value on a value of the first type.
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	arithmetic_value
	The concept plain_value<T> is satisfied if and only if T satisfies eve::arithmetic_simd_value or eve::arithmetic_scalar_value.
concept	relaxed_logical_value
	The concept relaxed_logical_value<T> is satisfied if and only if T is a boolean value or satisfies the eve::logical_value concept.
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.
concept	translatable_struct
	Defines the requirements for a struct to be translatable.
concept	translatable
	Determines if a type can be translated.
concept	generator_from

Typedefs
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<translatable T>
using	translate_t = typename decltype(detail::as_translated_type(as< T >{}))::type
	Returns the final translated type of 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 V >
constexpr translate_t< V >	translate (V const &val)
	Translates a value to its translated type.
template<typename T , size_t N>
constexpr std::array< translate_t< T >, N >	translate (std::array< T, N > val)
	Translates an std::array to an std::array of its translated value type and the same size.
template<typename V >
constexpr translate_t< V > &	translate (V &val)
	Translates a mutable reference to a reference its translated type.
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
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	allbits = functor<allbits_t>
	Computes a constant with all bits set.
constexpr auto	as_value = functor<as_value_t>
	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	majorant = functor<majorant_t>
	Computes a value x such that for any value y of the same type, is_not_greater(y, x) is true.
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 smallest floating point representing an integer such that n == n+1.
constexpr auto	maxrepint = functor<maxrepint_t>
	Computes the maximum representable integer value. Same as maxflint for floating types and valmax for integral types.
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	minorant = functor<minorant_t>
	Computes a value x such that for any value y of the same type, is_not_less(y, x) is true.
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 auto	all = functor<all_t>
	Computes a bool value which is true if and only if every elements of x evaluates to true.
constexpr auto	any = functor<any_t>
	Computes a bool value which is true if and only if one or more elements of x evaluates to true.
constexpr auto	average = functor<average_t>
	tuple_callable computing the arithmetic mean of its arguments.
constexpr auto	bit_and = functor<bit_and_t>
	bit_callable object computing the bitwise AND of its arguments.
constexpr auto	bit_andnot = functor<bit_andnot_t>
	bit_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>
	bit_callable object computing the bitwise NOTAND of its arguments.
constexpr auto	bit_notor = functor<bit_notor_t>
	bit_callable object computing the bitwise NOTOR of its arguments.
constexpr auto	bit_or = functor<bit_or_t>
	bit_callable object computing the bitwise OR of its arguments.
constexpr auto	bit_ornot = functor<bit_ornot_t>
	bit_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>
	bit_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 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 auto	combine = functor<combine_t>
	Combines two SIMD values in a larger one.
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 auto	cosine_similarity = functor<cosine_similarity_t>
	elementwise_callable object computing the elementwise cosine_similarity of the vector of the first half parameters by the vector of the last half.
constexpr auto	count_true = functor<count_true_t>
	Computes the number of elements of the input which evaluates to true.
constexpr auto	countl_one = functor<countl_one_t>
	elementwise_callable object computing the number of consecutive bits unset in a value starting from left
constexpr auto	countl_zero = functor<countl_zero_t>
	elementwise_callable object computing the number of consecutive bits unset in a value starting from left
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	covariance = functor<covariance_t>
	elementwise_callable object computing the elementwise covariance product of the vector of the first half parameters by the vector of the last half.
constexpr auto	dec = functor<dec_t>
	elementwise_callable object returning the input decremented by 1.
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 the elementwise dot product of the vector of the first half parameter by thevector of the last half.
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	fdim = functor<fdim_t>
	elementwise_callable computing the positive difference between the two parameters.
constexpr auto	first_true = functor<first_true_t>
	Returns the index of the first element in the input which evaluates to true, 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 auto	gather = functor<gather_t>
	Load a SIMD value with values selected from a memory region at the given offsets.
constexpr auto	has_equal_in = functor<has_equal_in_t>
	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 its sign bit set (mzero).
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 its sign bit 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. This includes both positive and negative zero for floating point values.
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 unless the element value is a floating zero with its sign bit set (mzero) or a NaN.
constexpr auto	is_nepz = functor<is_nepz_t>
	elementwise callable returning a logical true unless the element value is a floating zero with its sign bit unset.
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	last_true = functor<last_true_t>
	Returns the index of the last element in the input which evaluates to true, if there is one.
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	load = functor<load_t>
	Loads data from a pointer or a pair of iterators into a SIMD value.
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 auto	maximum = functor<maximum_t>
	Computes the maximal value in a simd vector or valmin if the input is fully masked.
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 auto	minimum = functor<minimum_t>
	Computes the minimal value in a simd vector or majorant if the input is fully masked.
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_callable computing the product of its arguments.
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 auto	none = functor<none_t>
	Computes a bool value which is true if and only if all elements of x evaluate to false.
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 auto	reduce = functor<reduce_t>
	Computes the reduction of a SIMD value using a given callable. Performs an horizontal sum by default.
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 auto	replace_ignored = functor<replace_ignored_t>
	A small helper to replace ignored values.
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	safe_scale = functor<safe_scale_t>
	elementwise_callable object computing underflow-safe and almost overflow-free scaling factor for the input.
constexpr auto	saturate = functor<saturate_t>
	strict_elementwise_callable computing the saturation of a value in a type.
constexpr auto	scan = functor<scan_t>
	Computes the generalized prefix sum over a simd value.
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 auto	sort = functor<sort_t>
	sorts a register in a accedning order accroding to a comparator.
constexpr auto	sqr = functor<sqr_t>
	Computes the square of the parameter.
constexpr auto	sqrt = functor<sqrt_t>
	Computes the elementwise square root of the parameter.
constexpr auto	store = functor<store_t>
	Store the elements of a SIMD value into the given memory location.
constexpr auto	sub = functor<sub_t>
	tuple_callable computing the difference of its first argument with the sum of the others.
constexpr auto	sufp = functor<sufp_t>
	elementwise_callable object computing the signed unit value in the first place of the input i.e. the greatest integer power of 2 less than or equal to |x|, multiplied by the sign of x.
constexpr auto	sulp = functor<sulp_t>
	elementwise_callable object computing the classical unit in the last place (Kahan) or the harrisson version multiplied by the sign of the input.
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 auto	sum_of_squares = functor<sum_of_squares_t>
	tuple_callable object computing the sum_of_squares norm ( \(l_1\)) of its arguments.
constexpr auto	swap_pairs = functor<swap_pairs_t>
	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 auto	two_add = functor<two_add_t>
	Computes the elementwise pair consisting of the sum and its resulting rounding 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. i.e. the number of representable values between these two divided by 2.
constexpr auto	unalign = functor<unalign_t>
	Callable object for computing an unaligned version of a relaxed iterator.
constexpr auto	variance = functor<variance_t>
	tuple_callable computing the variance of its arguments.
constexpr auto	veltkamp = functor<veltkamp_t>
constexpr auto	welford_average = functor<welford_average_t>
	tuple_callable computing the arithmetic mean of its arguments.
constexpr auto	welford_covariance = functor<welford_covariance_t>
	elementwise_callable object computing the elementwise welford_covariance product of the vector of the first half parameter by thevector of the last half.
constexpr auto	welford_variance = functor<welford_variance_t>
	tuple_callable computing the arithmetic mean of its arguments.
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_d = functor<ellint_d_t>
	elementwise_callable object computing the \(\mbox{D}\) elliptic integral.
constexpr auto	ellint_fe = functor<ellint_fe_t>
	elementwise_callable object computing the elliptic integrals of the first and second kind kind.
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	heuman_lambda = functor<heuman_lambda_t>
	elementwise_callable object computing the Heuman lambda function.
constexpr auto	jacobi_elliptic = functor<jacobi_elliptic_t>
	elementwise_callable object computing the Jacobi's sn, cn and dn function simultaneously.
constexpr auto	jacobi_zeta = functor<jacobi_zeta_t>
	elementwise_callable object computing the Jacobi Zeta function.
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	harmmean = functor<harmmean_t>
	Callable object computing the harmonic mean of the inputs. \( \fracn{\sum \frac1/xs} \).
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	kolmmean = functor<kolmmean_t>
	Callable object computing the 'Kolmogorov-Nagumo-de Finetti' mean of the inputs: \( \mathbf{g}(\sum \mathbf{f}(x_s)) \).
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 function of order n at x: \(x(x-an)^{n-1}\). for positive integer n it is Abel polynomial.
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	cos_int = functor<cos_int_t>
	elementwise_callable object computing the cosine integral \( \mathbf{Ci}(x) = \displaystyle -\int_x^\infty \frac{\cos t}{t}\;\mbox{d}t\).
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`
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	hurwitz = functor<hurwitz_t>
	elementwise_callable object computing the Hurwitz function i.e. \(\sum_{k=0}^\infty (k+z)^{-s}\), where any term with \(k+z = 0\) is excluded.
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	polygamma = functor<polygamma_t>
	elementwise_callable object computing the Polygamma function i.e. the nth derivative of the digamma function
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	sin_int = functor<sin_int_t>
	elementwise_callable object computing the sine integral \( \mathbf{Si}(x) = \displaystyle \int_0^x \frac{\sin t}{t}\;\mbox{d}t\).
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	trigamma = functor<trigamma_t>
	elementwise_callable object computing the Trigamma function i.e. the second derivative of the \(\log\Gamma\) function.
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.