|
| 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> |
| | strict_elementwise_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.
|
| |
