E.V.E
v2023.02.15
 
Loading...
Searching...
No Matches
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 cyl_bessel_i0 = functor<cyl_bessel_i0_t>
 elementwise_callable object computing the modified Bessel function of the first kind, \( I_0(x)=\frac1{\pi}\int_{0}^{\pi}e^{x\cos\tau}\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_i1 = functor<cyl_bessel_i1_t>
 elementwise_callable object computing the modified Bessel function of the first kind, \( I_1(x)=\frac1{\pi}\int_{0}^{\pi}e^{x\cos\tau}\cos\tau\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_in = functor<cyl_bessel_in_t>
 elementwise_callable object computing the modified Bessel functions of the first kind, \( I_{n}(x)=\left(\frac12z\right)^n\sum_{k=0}^{\infty}{\frac{(x^2/4)^k} {k!\,\Gamma (k+n +1)}}\).
 
constexpr auto cyl_bessel_j0 = functor<cyl_bessel_j0_t>
 elementwise_callable object computing the Bessel function of the first kind, \( J_0(x)=\frac1{\pi }\int _{0}^{\pi}\cos(x\sin \tau) \,\mathrm {d} \tau \).
 
constexpr auto cyl_bessel_j1 = functor<cyl_bessel_j1_t>
 elementwise_callable object computing the Bessel function of the first kind, \( J_1(x)=\frac1{\pi }\int _{0}^{\pi}\cos(\tau-x\sin \tau )\,\mathrm {d} \tau \).
 
constexpr auto cyl_bessel_jn = functor<cyl_bessel_jn_t>
 elementwise_callable object computing the Bessel functions of the first kind, \( J_{n}(x)=\sum_{p=0}^{\infty}{\frac{(-1)^p}{p!\,\Gamma (p+n +1)}} {\left({x \over 2}\right)}^{2p+n }\).
 
constexpr auto cyl_bessel_k0 = functor<cyl_bessel_k0_t>
 elementwise_callable object computing the modified Bessel function of the second kind, \( K_0(x)=\int_{0}^{\infty}\frac{\cos(x\tau)} {\sqrt{\tau^2+1}}\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_k1 = functor<cyl_bessel_k1_t>
 elementwise_callable object computing the modified Bessel function of the second kind, \( K_1(x)=\int_{0}^{\infty} e^{-x \cosh \tau} \cosh \tau\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_kn = functor<cyl_bessel_kn_t>
 elementwise_callable object computing the modified Bessel function of the second kind, \( K_n(x)=\frac{\Gamma(n+1/2)(2x)^n}{\sqrt\pi} \int_{0}^{\infty}\frac{\cos\tau} {(\tau^2+x^2)^{n+1/2}}\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_y0 = functor<cyl_bessel_y0_t>
 elementwise_callable object computing the Bessel function of the second kind, \( Y_0(x)=\frac2{\pi}\int_{1}^{\infty}\frac{\cos x\tau} {\sqrt{\tau^2-1}}\,\mathrm {d} \tau\).
 
constexpr auto cyl_bessel_y1 = functor<cyl_bessel_y1_t>
 elementwise_callable object computing the Bessel function of the second kind, \( Y_1(x)=\frac2{\pi}\int_{1}^{\infty}\frac{\cos x\tau} {(\tau^2-1)^{3/2}}\,\mathrm{d}\tau\).
 
constexpr auto cyl_bessel_yn = functor<cyl_bessel_yn_t>
 elementwise_callable object computing the Bessel functions of the second kind, \( Y_{n}(x)=\frac{2(z/2)^{-n}}{\sqrt\pi\, \Gamma(1/2-n)}\int _{1}^{\infty}\frac{\cos x\tau} {(\tau^2-1)^{n+1/2}}\,\mathrm {d} \tau \).
 
constexpr auto sph_bessel_j0 = functor<sph_bessel_j0_t>
 Computes the spherical Bessel function of the first kind and order 0, that is \( j_0(x) = \sqrt{\frac\pi{2x}}J_{1/2}(x)\) ,.
 
constexpr auto sph_bessel_j1 = functor<sph_bessel_j1_t>
 Computes the spherical Bessel function of the first kind of order 1,.
 
constexpr auto sph_bessel_jn = functor<sph_bessel_jn_t>
 Computes the spherical Bessel functions of the first kind of order n, \( j_{n}(x)= \sqrt{\frac\pi{2x}}J_{n+1/2}(x)\).
 
constexpr auto sph_bessel_y0 = functor<sph_bessel_y0_t>
 Computes the spherical Bessel function of the second kind of order 0, \( y_{0}(x)= \sqrt{\frac\pi{2x}}Y_{1/2}(x) \).
 
constexpr auto sph_bessel_y1 = functor<sph_bessel_y1_t>
 Computes the spherical Bessel function of the second kind of order 1, \( y_{1}(x)= \sqrt{\frac\pi{2x}}Y_{3/2}(x) \).
 
constexpr auto sph_bessel_yn = functor<sph_bessel_yn_t>
 Computes the the spherical Bessel functions of the second kind of order n, \( y_{n}(x)= \sqrt{\frac\pi{2x}}Y_{n+1/2}(x)\).
 
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.