|
| 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> |
| | Computes the airy functions values \( Ai(x)\) and \( Bi(x)\).
|
| |
| constexpr auto | airy_ai = functor<airy_ai_t> |
| | Computes the airy function \( Ai(x)\).
|
| |
| constexpr auto | airy_bi = functor<airy_bi_t> |
| | Computes the airy function \( Bi(x)\).
|
| |
| constexpr auto | cyl_bessel_i0 = functor<cyl_bessel_i0_t> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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> |
| | Computes 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, \( 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, \( j_{1}(x)= \sqrt{\frac\pi{2x}}J_{3/2}(x) \).
|
| |
| constexpr auto | sph_bessel_jn = functor<sph_bessel_jn_t> |
| | Computes the spherical Bessel functions of the first kind, \( 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, \( 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, \( 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, \( y_{n}(x)= \sqrt{\frac\pi{2x}}Y_{n+1/2}(x)\).
|
| |
| constexpr auto | bernouilli = functor<bernouilli_t> |
| | Computes 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> |
| | Computes the greatest common divisor of the inputs.
|
| |
| constexpr auto | lcm = functor<lcm_t> |
| | Computes 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> |
| | Returns the smallest prime greater or equal to the input.
|
| |
| constexpr auto | prime_floor = functor<prime_floor_t> |
| | Returns the 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 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 callable_mmone_ | mmone = {} |
| | 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 | promote = ::rbr::flag( promote_mode{} ) |
| | Higher-order Callable Object imbuing more standard semantic onto other Callable Objects.
|
| |
| constexpr auto | spherical = ::rbr::flag( spherical_mode{} ) |
| | Higher-order Callable Object imbuing sphericalerical semantic onto other Callable Objects.
|
| |
| constexpr auto | successor = ::rbr::flag( successor_mode{} ) |
| | Higher-order Callable Object imbuing incrementation behaviour onto other Callable Objects.
|
| |
| constexpr pedantic_type const | pedantic = {} |
| | Higher-order Callable Object imbuing more standard semantic onto other Callable Objects.
|
| |
| constexpr raw_type const | raw = {} |
| | Higher-order Callable Object imbuing quick and dirty behaviour onto other Callable Objects.
|
| |
| constexpr upward_type const | upward = {} |
| | Higher-order Callable Object imbuing upward rounding semantic onto other Callable Objects.
|
| |
| constexpr downward_type const | downward = {} |
| | Higher-order Callable Object imbuing rounding downard semantic onto other Callable Objects.
|
| |
| constexpr to_nearest_type const | to_nearest = {} |
| | Higher-order Callable Object imbuing rounding to nearest semantic onto other Callable Objects.
|
| |
| constexpr toward_zero_type const | toward_zero = {} |
| | Higher-order Callable Object imbuing rounding toward zero semantic onto other Callable Objects.
|
| |
| constexpr saturated_type const | saturated = {} |
| | Higher-order Callable Object imbuing saturation semantic onto other Callable Objects.
|
| |
| 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> |
| | Computes the absolute value of the parameter.
|
| |
| constexpr auto | absmax = functor<absmax_t> |
| | Computes the absolute value of the maximal element.
|
| |
| constexpr auto | absmin = functor<absmin_t> |
| | Computes the absolute value of the minimal element.
|
| |
| constexpr callable_add_ | add = {} |
| | Computes the sum of its arguments.
|
| |
| constexpr auto | agm = functor<agm_t> |
| | Computes 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> |
| | Computes the arithmetic mean of its arguments.
|
| |
| constexpr auto | bit_and = functor<bit_and_t> |
| | Computes the bitwise AND of its arguments.
|
| |
| constexpr auto | bit_andnot = functor<bit_andnot_t> |
| | Computes the bitwise ANDNOT of its arguments.
|
| |
| constexpr callable_bit_cast_ | bit_cast = {} |
| | Computes a a bitwise reinterpretation of an object.
|
| |
| constexpr auto | bit_ceil = functor<bit_ceil_t> |
| | Computes the smallest integral power of two that is not smaller than x.
|
| |
| constexpr auto | bit_flip = functor<bit_flip_t> |
| | flip the value the ith bit of each element.
|
| |
| constexpr auto | bit_floor = functor<bit_floor_t> |
| | If x is not zero, computes the largest integral power of two that is not greater than x.
|
| |
| constexpr auto | bit_mask = functor<bit_mask_t> |
| | Computes a bit mask full of zeroes or ones.
|
| |
| constexpr auto | bit_not = functor<bit_not_t> |
| | computes the ones complement of the parameter.
|
| |
| constexpr auto | bit_notand = functor<bit_notand_t> |
| | Computes the bitwise NOTAND of its arguments.
|
| |
| constexpr auto | bit_notor = functor<bit_notor_t> |
| | Computes the bitwise NOTOR of its arguments.
|
| |
| constexpr auto | bit_or = functor<bit_or_t> |
| | Computes the bitwise OR of its arguments.
|
| |
| constexpr auto | bit_ornot = functor<bit_ornot_t> |
| | Computes the bitwise ORNOT of its arguments.
|
| |
| constexpr auto | bit_reverse = functor<bit_reverse_t> |
| | elementwise reverse the bit order.
|
| |
| constexpr auto | bit_select = functor<bit_select_t> |
| | selects bits from a mask and two entries.
|
| |
| constexpr auto | bit_set = functor<bit_set_t> |
| | set to 1 the ith bit of each element.
|
| |
| detail::callable_object< tag::shl_ > const | bit_shl = {} |
| | Computes a logical left shift.
|
| |
| constexpr auto | bit_shr = functor<bit_shr_t> |
| | Computes a logical right shift.
|
| |
| constexpr auto | bit_swap_adjacent = functor<bit_swap_adjacent_t> |
| | swap_adjacents elementwise groups of n bits.
|
| |
| constexpr auto | bit_swap_pairs = functor<bit_swap_pairs_t> |
| | swap_pairs elementwise.
|
| |
| constexpr auto | bit_unset = functor<bit_unset_t> |
| | set to 0 the ith bit of each element.
|
| |
| constexpr auto | bit_width = functor<bit_width_t> |
| | Computes elementwise the number of bits needed to store the parameter.
|
| |
| constexpr auto | bit_xor = functor<bit_xor_t> |
| | Computes the bitwise XOR of its arguments.
|
| |
| constexpr auto | bitofsign = functor<bitofsign_t> |
| | Computes the value in the input type of the bit of sign.
|
| |
| constexpr callable_broadcast_ | broadcast = {} |
| | Computes the.
|
| |
| constexpr callable_broadcast_group_ | broadcast_group = {} |
| | Computes the TODO.
|
| |
| constexpr auto | byte_reverse = functor<byte_reverse_t> |
| | elementwise reverses the byte order.
|
| |
| constexpr auto | byte_swap_adjacent = functor<byte_swap_adjacent_t> |
| | swap_adjacents elementwise groups of N bytes.
|
| |
| constexpr auto | ceil = functor<ceil_t> |
| | Computes the smallest integer not less than the input.
|
| |
| constexpr auto | clamp = functor<clamp_t> |
| | Computes the largest integer not greater than the input.
|
| |
| constexpr callable_combine_ | combine = {} |
| | Computes the TODO.
|
| |
| constexpr auto | conj = functor<conj_t> |
| | Computes the the conjugate value.
|
| |
| detail::callable_object< tag::convert_ > const | convert = {} |
| | Converts a value to another type.
|
| |
| constexpr auto | copysign = functor<copysign_t> |
| | Computes the elementwise 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 callable_countl_one_ | countl_one = {} |
| | Computes the number of consecutive 1 in a value starting from left.
|
| |
| constexpr callable_countl_zero_ | countl_zero = {} |
| | Computes the number of consecutive 0 in a value starting from left.
|
| |
| constexpr callable_countr_one_ | countr_one = {} |
| | Computes the number of consecutive 1 in a value starting from right.
|
| |
| constexpr callable_countr_zero_ | countr_zero = {} |
| | Computes the number of consecutive 0 in a value starting from right.
|
| |
| constexpr auto | dec = functor<dec_t> |
| | return 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> |
| | Computes the difference of products operation with better accuracy than the naive formula.
|
| |
| constexpr auto | dist = functor<dist_t> |
| | Computes the distance of its arguments.
|
| |
| constexpr callable_div_ | div = {} |
| | Computes the division of multiple values.
|
| |
| constexpr auto | dot = functor<dot_t> |
| | Computes elementwise the dot product of the two parameters.
|
| |
| constexpr auto | epsilon = functor<epsilon_t> |
| | Computes The distance of abs(x) to the next representable element of type T.
|
| |
| constexpr auto | exponent = functor<exponent_t> |
| | Computes the IEEE exponent of the floating value.
|
| |
| constexpr auto | fam = functor<fam_t> |
| | Computes the fused add multiply of its three parameters.
|
| |
| constexpr auto | fanm = functor<fanm_t> |
| | Computes the fused add negate multiply of its three parameters.
|
| |
| constexpr auto | fdim = functor<fdim_t> |
| | Computes 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> |
| | Computes the largest integer not greater than the input.
|
| |
| constexpr auto | fma = functor<fma_t> |
| | Computes the fused multiply add of its three parameters.
|
| |
|
constexpr callable_fmod_ | fmod = {} |
| | Alias of eve::pedantic(eve::rem).
|
| |
| constexpr auto | fms = functor<fms_t> |
| | Computes the fused multiply substract of its three parameters.
|
| |
| constexpr auto | fnma = functor<fnma_t> |
| | Computes the fused negate multiply add of its three parameters.
|
| |
| constexpr auto | fnms = functor<fnms_t> |
| | Computes the fused negate multiply substract of its three parameters.
|
| |
| constexpr auto | frac = functor<frac_t> |
| | Computes the fractional part of the input.
|
| |
| constexpr callable_fracscale_ | fracscale = {} |
| | Computes the reduced part of the scaled input.
|
| |
| constexpr auto | frexp = functor<frexp_t> |
| | Computes the elementwise ieee pair of mantissa and exponent of the floating value,.
|
| |
| constexpr auto | fsm = functor<fsm_t> |
| | Computes the fused negate add multiply of its three parameters.
|
| |
| constexpr auto | fsnm = functor<fsnm_t> |
| | Computes the fused negate substact 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 | hi = functor<hi_t> |
| | Computes the most significant half of each lane.
|
| |
| constexpr callable_if_else_ | if_else = {} |
| | Computes the results of a choice under condition.
|
| |
| constexpr callable_ifnot_else_ | ifnot_else = {} |
| | eve::ifnot_else(x, y, z)syntaxic sugar for eve::if_else(x, z, y)
|
| |
| constexpr auto | ifrexp = functor<ifrexp_t> |
| | Computes the elementwise ieee pair of mantissa and exponent of the floating value,.
|
| |
| constexpr auto | inc = functor<inc_t> |
| | return the input incremented by one.
|
| |
| constexpr auto | is_denormal = functor<is_denormal_t> |
| | Returns a logical true if and only if the element value is denormal.
|
| |
| constexpr auto | is_equal = functor<is_equal_t> |
| | Returns a logical true if and only if the element value are equal.
|
| |
| constexpr auto | is_eqz = functor<is_eqz_t> |
| | Returns a logical true if and only if the element value is zero.
|
| |
| constexpr auto | is_even = functor<is_even_t> |
| | Returns a logical true if and only if the element value is even.
|
| |
| constexpr auto | is_finite = functor<is_finite_t> |
| | Returns a logical true if and only if the element is a finite value.
|
| |
| constexpr auto | is_flint = functor<is_flint_t> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is greater or equal to 0.
|
| |
| constexpr auto | is_greater = functor<is_greater_t> |
| | Returns 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> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is greater than 0.
|
| |
| constexpr auto | is_imag = functor<is_imag_t> |
| | Returns a logical true if and only if the element value is imaginary.
|
| |
| constexpr auto | is_infinite = functor<is_infinite_t> |
| | Returns a logical true if and only if the element is an infinite value.
|
| |
| constexpr auto | is_less = functor<is_less_t> |
| | Returns 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> |
| | Returns 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> |
| | Returns a logical true if and only if the elements pair are not equal or unordered.
|
| |
| constexpr auto | is_lez = functor<is_lez_t> |
| | Returns a logical true if and only if the element value is less or equal to 0.
|
| |
| constexpr auto | is_ltz = functor<is_ltz_t> |
| | Returns a logical true if and only if the element value is less than 0.
|
| |
| constexpr auto | is_nan = functor<is_nan_t> |
| | Returns a logical true if and only if the element value is NaN.
|
| |
| constexpr auto | is_negative = functor<is_negative_t> |
| | Returns a logical true if and only if the element value is signed and has its sign bit set.
|
| |
| constexpr auto | is_nez = functor<is_nez_t> |
| | Returns a logical true if and only if the element value is not zero.
|
| |
| constexpr auto | is_ngez = functor<is_ngez_t> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is not greater than zero.
|
| |
| constexpr auto | is_nlez = functor<is_nlez_t> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is not less than zero.
|
| |
| constexpr auto | is_normal = functor<is_normal_t> |
| | Returns a logical true if and only if the element value is normal.
|
| |
| constexpr auto | is_not_denormal = functor<is_not_denormal_t> |
| | Returns a logical true if and only if the element value is not denormal.
|
| |
| constexpr auto | is_not_equal = functor<is_not_equal_t> |
| | Returns a logical true if and only if the element value are not equal.
|
| |
| constexpr auto | is_not_finite = functor<is_not_finite_t> |
| | Returns a logical true if and only if the element is not a finite value.
|
| |
| constexpr auto | is_not_flint = functor<is_not_flint_t> |
| | Returns 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> |
| | Returns 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> |
| | Returns 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_imag = functor<is_not_imag_t> |
| | Returns a logical true if and only if the element value is not imaginary.
|
| |
| constexpr auto | is_not_infinite = functor<is_not_infinite_t> |
| | Returns a logical true if and only if the element is not an infinite value.
|
| |
| constexpr auto | is_not_less = functor<is_not_less_t> |
| | Returns 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> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is not NaN.
|
| |
| constexpr auto | is_not_real = functor<is_not_real_t> |
| | Returns a logical true if and only if the element value is not real (never).
|
| |
| constexpr auto | is_odd = functor<is_odd_t> |
| | Returns a logical true if and only if the element value is odd.
|
| |
| constexpr auto | is_ordered = functor<is_ordered_t> |
| | Returns a logical true if and only no parameter is NaN.
|
| |
| constexpr auto | is_positive = functor<is_positive_t> |
| | Returns 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> |
| | Returns a logical true if and only if the element value is a power of 2.
|
| |
| constexpr auto | is_real = functor<is_real_t> |
| | Returns a logical true.
|
| |
| constexpr auto | is_unit = functor<is_unit_t> |
| | Returns a logical true if and only if the element value is zero.
|
| |
| constexpr auto | is_unordered = functor<is_unordered_t> |
| | Returns 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> |
| | Computes \(\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> |
| | Computes 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 callable_logical_notand_ | logical_notand = {} |
| | Computes the logical NOTAND of its arguments.
|
| |
| constexpr callable_logical_notor_ | logical_notor = {} |
| | Computes the logical NOTOR of its arguments.
|
| |
| constexpr auto | logical_or = functor<logical_or_t> |
| | Computes the logical OR of its arguments.
|
| |
| constexpr callable_logical_ornot_ | logical_ornot = {} |
| | 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> |
| | Computes the the lohi pair of values.
|
| |
| constexpr auto | manhattan = functor<manhattan_t> |
| | Computes the manhattan norm ( \(l_1\)) of its arguments.
|
| |
| constexpr auto | mantissa = functor<mantissa_t> |
| | Computes 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 of its arguments.
|
| |
| constexpr callable_maximum_ | maximum = {} |
| | Computes the maximal value of an simd vector.
|
| |
| constexpr auto | maxmag = functor<maxmag_t> |
| | Computes the maximum of the absolute value of its arguments.
|
| |
| 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 maximal value of an simd vector.
|
| |
| constexpr auto | minmag = functor<minmag_t> |
| | Computes the maximum of the absolute value of its arguments.
|
| |
| 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> |
| | Computes the elementwise pair of fractional and integral parts of the value,.
|
| |
| constexpr callable_mul_ | mul = {} |
| | Computes the sum of its arguments.
|
| |
| constexpr auto | nb_values = functor<nb_values_t> |
| | Computes the number of values representable in the type between the arguments.
|
| |
| constexpr auto | nearest = functor<nearest_t> |
| | Computes the nearest integer to the input.
|
| |
| constexpr auto | negabsmax = functor<negabsmax_t> |
| | Computes the negated absolute value of the maximal element.
|
| |
| constexpr auto | negabsmin = functor<negabsmin_t> |
| | Computes the negated absolute value of the minimal element.
|
| |
| constexpr auto | negate = functor<negate_t> |
| | Computes the elementwise product of the first parameter by the sign of the second.
|
| |
| constexpr auto | negatenz = functor<negatenz_t> |
| | Computes the elementwise product of the first parameter by the never zero sign of the second.
|
| |
| constexpr auto | negmaxabs = functor<negmaxabs_t> |
| | Computes the negated value of the element of the maximal absolute value.
|
| |
| constexpr auto | negminabs = functor<negminabs_t> |
| | Computes the negated value of the element of the minimal absolute value.
|
| |
| constexpr auto | next = functor<next_t> |
| | Computes the nth next representable element.
|
| |
| constexpr auto | nextafter = functor<nextafter_t> |
| | Computes the nth next representable element.
|
| |
| constexpr callable_none_ | none = {} |
| | Computes a bool value which is true if and only if all elements of x are 0.
|
| |
| constexpr auto | oneminus = functor<oneminus_t> |
| | Computes the value of one minus the input.
|
| |
| constexpr callable_plus_ | plus = {} |
| | Computes the opposite of the parameter that must be signed.
|
| |
| constexpr callable_popcount_ | popcount = {} |
| | Computes 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> |
| | Computes a rational approximation.
|
| |
| constexpr callable_read_ | read = {} |
| | Callable object reading single value from memory.
|
| |
| constexpr callable_rec_ | rec = {} |
| | Computes the inverse of the parameter.
|
| |
| constexpr callable_reduce_ | reduce = {} |
| | Computes the TODO.
|
| |
| constexpr auto | reldist = functor<reldist_t> |
| | Computes the relative distance of its arguments.
|
| |
| constexpr callable_rem_ | rem = {} |
| | Computes the remainder after division.
|
| |
| constexpr callable_replace_ignored_ | replace_ignored = {} |
| | A small helper tto replace ignored values.
|
| |
| constexpr callable_rotate_ | rotate = {} |
| | rotates two halves of the register by a chosen number of elements.
|
| |
| constexpr callable_round_ | round = {} |
| | Computes the integer nearest to the input.
|
| |
| constexpr callable_roundscale_ | roundscale = {} |
| | Computes the scaled input rounding.
|
| |
| constexpr callable_rshl_ | rshl = {} |
| | Computes the arithmetic left/right shift operation according to shift sign.
|
| |
| constexpr callable_rshr_ | rshr = {} |
| | Computes the arithmetic right/left shift operation according to shift sign.
|
| |
| constexpr callable_rsqrt_ | rsqrt = {} |
| | Computes the inverse of the square root of the parameter.
|
| |
| constexpr callable_saturate_ | saturate = {} |
| | Computes 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 callable_shl_ | shl = {} |
| | Computes the arithmetic left shift operation.
|
| |
| constexpr callable_shr_ | shr = {} |
| | Computes the arithmetic right shift operation.
|
| |
| constexpr callable_sign_ | sign = {} |
| | Computes the sign of the parameter.
|
| |
| constexpr callable_sign_alternate_ | sign_alternate = {} |
| | Computes \((-1)^n\).
|
| |
| constexpr auto | signnz = functor<signnz_t> |
| | Computes the never zero sign of the parameter.
|
| |
| 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 callable_sort_ | sort = {} |
| | 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 callable_sqrt_ | sqrt = {} |
| | 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 callable_sub_ | sub = {} |
| | Computes the sum of its arguments.
|
| |
| constexpr auto | sum_of_prod = functor<sum_of_prod_t> |
| | Computes 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 | trunc = functor<trunc_t> |
| | Computes 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. Defined in Header
|
| |
| constexpr callable_unalign_ | unalign = {} |
| | Callable object for computing an unaligned version of a relaxed iterator.
|
| |
| constexpr callable_write_ | write = {} |
| | Callable object writing single value from memory.
|
| |
| constexpr callable_zip_ | zip = {} |
| | lable object constructing a SoA value.
|
| |
| constexpr auto | ellint_1 = functor<ellint_1_t> |
| | Computes the elliptic integrals of the first kind : \(\mathbf{F}(\phi, k) = \int_0^{\phi} \frac{\mathrm{d}t}{\sqrt{1-k^2\sin^2 t}}\) and \(\mathbf{K}(k) = \int_0^{\pi/2} \frac{\mathrm{d}t}{\sqrt{1-k^2\sin^2 t}}\).
|
| |
| constexpr auto | ellint_2 = functor<ellint_2_t> |
| | Computes the elliptic integrals of the second kind : \( \mathbf{E}(\phi, k) = \int_0^{\phi} \scriptstyle \sqrt{1-k^2\sin^2 t}
\scriptstyle\;\mathrm{d}t\) and \(\mathbf{E}(k) = \int_0^{\pi/2} \scriptstyle \sqrt{1-k^2\sin^2 t}
\scriptstyle\;\mathrm{d}t\).
|
| |
| constexpr auto | ellint_d = functor<ellint_d_t> |
| | Computes the \(\mbox{D}\) elliptic integrals : \( \mathbf{D}(\phi, k) = \int_0^{\phi} \frac{\sin^2 t}{\sqrt{1-k^2\sin^2 t}}
\scriptstyle\;\mathrm{d}t\) and \( \mathbf{D}(k) = \int_0^{\pi/2} \frac{\sin^2 t}{\sqrt{1-k^2\sin^2 t}}
\scriptstyle\;\mathrm{d}t\).
|
| |
| constexpr auto | ellint_rc = functor<ellint_rc_t> |
| | computes 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> |
| | Computes the Carlson's elliptic integral.
|
| |
| constexpr auto | ellint_rf = functor<ellint_rf_t> |
| | Computes the Carlson's elliptic integral \( \mathbf{R}_\mathbf{F}(x, y) = \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_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^1\).
|
| |
| 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 full_circle_type const | full_circle = {} |
| | Higher-order Callable Object imbuing a limited range semantic onto other Callable Objects.
|
| |
| constexpr quarter_circle_type const | quarter_circle = {} |
| | Higher-order Callable Object imbuing a limited range semantic onto other Callable Objects.
|
| |
| constexpr half_circle_type const | half_circle = {} |
| | Higher-order Callable Object imbuing a limited range standard semantic onto other Callable Objects.
|
| |
| constexpr auto | acos = functor<acos_t> |
| | Callable object computing the arc cosine.
|
| |
| constexpr auto | acosd = functor<acosd_t> |
| | Callable object computing the arc cosine from input in degree.
|
| |
| constexpr auto | acosh = functor<acosh_t> |
| | Callable object computing \(\log(x+\sqrt{x^2-1})\).
|
| |
| constexpr auto | acospi = functor<acospi_t> |
| | Callable object computing the arc cosine in \(\pi\) multiples.
|
| |
| constexpr auto | acot = functor<acot_t> |
| | Callable object computing the arc cotangent.
|
| |
| constexpr auto | acotd = functor<acotd_t> |
| | Callable object computing arc cotangent in degree.
|
| |
| constexpr auto | acoth = functor<acoth_t> |
| | Callable object computing \(\frac{1}{2}\log((x+1)/(x-1))\).
|
| |
| constexpr auto | acotpi = functor<acotpi_t> |
| | Callable object computing in \(\pi\) multiples.
|
| |
| constexpr auto | acsc = functor<acsc_t> |
| | Callable object computing the arc cosecant.
|
| |
| constexpr auto | acscd = functor<acscd_t> |
| | Callable object computing the arc cosecant rom an input in degrees.
|
| |
| constexpr auto | acsch = functor<acsch_t> |
| | Callable object computing \(\log(1/x+\sqrt{1/x^2+1})\).
|
| |
| constexpr auto | acscpi = functor<acscpi_t> |
| | Callable object computing he arc cosecant in \(\pi\) multiples.
|
| |
| constexpr auto | agd = functor<agd_t> |
| | Callable object computing the inverse gudermanian, i.e. \(2\tanh(\tan(x/2))\).
|
| |
| constexpr auto | arg = functor<arg_t> |
| | Callable object computing the phase angle (in radians).
|
| |
| constexpr auto | asec = functor<asec_t> |
| | Callable object computing the arc secant.
|
| |
| constexpr auto | asecd = functor<asecd_t> |
| | Callable object computing the arc secant in degrees.
|
| |
| constexpr auto | asech = functor<asech_t> |
| | Callable object computing \(\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> |
| | Callable object computing the arc sine.
|
| |
| constexpr auto | asind = functor<asind_t> |
| | Callable object computing the arc sine in degrees.
|
| |
| constexpr auto | asinh = functor<asinh_t> |
| | Callable object computing \(\log(x+\sqrt{x^2+1})\).
|
| |
| constexpr auto | asinpi = functor<asinpi_t> |
| | Callable object computing computing the arc sine in \(\pi\) multiples.
|
| |
| constexpr auto | atan = functor<atan_t> |
| | Callable object computing the arc tangent.
|
| |
| constexpr auto | atan2 = functor<atan2_t> |
| | Callable object computing the arc tangent using the signs of arguments to determine the correct quadrant.
|
| |
| constexpr auto | atan2d = functor<atan2d_t> |
| | Callable object computing the arc tangent in degrees using the signs of arguments to determine the correct quadrant.
|
| |
| constexpr auto | atan2pi = functor<atan2pi_t> |
| | Callable object computing the arc tangent in \(\pi\) multiples using the signs of arguments to determine the correct quadrant.
|
| |
| constexpr auto | atand = functor<atand_t> |
| | Callable object computing arc tangent in degrees.
|
| |
| constexpr auto | atanh = functor<atanh_t> |
| | Callable object computing \(\frac{1}{2}\log((1+x)/(1-x))\).
|
| |
| constexpr auto | atanpi = functor<atanpi_t> |
| | Callable object computing arc tangent in \(\pi\) multiples.
|
| |
| constexpr auto | cbrt = functor<cbrt_t> |
| | Callable object computing the cubic root.
|
| |
| constexpr auto | cos = functor<cos_t> |
| | Callable object computing the cosine.
|
| |
| constexpr auto | cosd = functor<cosd_t> |
| | Callable object computing cosine from an input in degrees.
|
| |
| constexpr auto | cosh = functor<cosh_t> |
| | Callable object computing \(\frac{e^x+e^{-x}}2\).
|
| |
| constexpr auto | cospi = functor<cospi_t> |
| | Callable object computing the cosine from an input in \(\pi\) multiples.
|
| |
| constexpr auto | cot = functor<cot_t> |
| | Callable object computing th cotangent.
|
| |
| constexpr auto | cotd = functor<cotd_t> |
| | Callable object computing cotangent from an input in degrees.
|
| |
| constexpr auto | coth = functor<coth_t> |
| | Callable object computing \(\frac{e^x+e^{-x}}{e^x-e^{-x}}\).
|
| |
| constexpr auto | cotpi = functor<cotpi_t> |
| | Callable object computing the arc cotangent from an input in \(\pi\) multiples.
|
| |
| constexpr auto | csc = functor<csc_t> |
| | Callable object computing the cosecant of the input.
|
| |
| constexpr auto | cscd = functor<cscd_t> |
| | Callable object computing the cosecant from an input in degree.
|
| |
| constexpr auto | csch = functor<csch_t> |
| | Callable object computing \(\frac2{e^x+e^{-x}}\).
|
| |
| constexpr auto | cscpi = functor<cscpi_t> |
| | Callable object computing the cosecant in \(\pi\) multiples.
|
| |
| constexpr auto | deginrad = functor<deginrad_t> |
| | Callable object multiplying the input by \(\pi/180\).
|
| |
| constexpr auto | exp = functor<exp_t> |
| | Callable object computing \(e^x\).
|
| |
| constexpr auto | exp10 = functor<exp10_t> |
| | Callable object computing \(10^x\).
|
| |
| constexpr auto | exp2 = functor<exp2_t> |
| | Callable object computing \(2^x\).
|
| |
| constexpr auto | expm1 = functor<expm1_t> |
| | Callable object computing \(e^x-1\).
|
| |
| constexpr auto | expmx2 = functor<expmx2_t> |
| | Callable object computing \(e^{-x^2}\).
|
| |
| constexpr auto | expx2 = functor<expx2_t> |
| | Callable object computing \(e^{x^2}\).
|
| |
| constexpr auto | gd = functor<gd_t> |
| | 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/.
|
| |
| constexpr auto | hypot = functor<hypot_t> |
| | Callable object 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> |
| | Callable object computing the natural logarithm: \(\log x\).
|
| |
| constexpr auto | log10 = functor<log10_t> |
| | Callable object computing the base 10 logarithm: \(\log_{10} x\).
|
| |
| constexpr auto | log1p = functor<log1p_t> |
| | Callable object computing the natural logarithm of \(1+x\): \(\log(1+x)\).
|
| |
| constexpr auto | log2 = functor<log2_t> |
| | 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> |
| | Callable object computing the logspace_add operation: \(\log\left(\sum_{i = 0}^n
e^{x_i}\right)\).
|
| |
| constexpr auto | logspace_sub = functor<logspace_sub_t> |
| | Callable object computing the logspace_sub operation: \(\log\left(e^{x_0}-\sum_{i = 1}^n e^{x_i}\right)\).
|
| |
| constexpr auto | lpnorm = functor<lpnorm_t> |
| | 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> |
| | Callable object multiplying the input by \(180/\pi\).
|
| |
| constexpr auto | radinpi = functor<radinpi_t> |
| | Callable object multiplying the input by \(1/\pi\).
|
| |
| constexpr auto | rempio2 = functor<rempio2_t> |
| | 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> |
| | Callable object computing the secant of the input.
|
| |
| constexpr auto | secd = functor<secd_t> |
| | Callable object computing the secant from an input in degree.
|
| |
| constexpr auto | sech = functor<sech_t> |
| | Callable object computing \(\frac2{e^x-e^{-x}}\).
|
| |
| constexpr auto | secpi = functor<secpi_t> |
| | Callable object computing secant from an input in \(\pi\) multiples.
|
| |
| constexpr auto | significants = functor<significants_t> |
| | Computes the rounding to n significants digits of the first input.
|
| |
| constexpr auto | sin = functor<sin_t> |
| | Callable object computing the sine.
|
| |
| constexpr auto | sinc = functor<sinc_t> |
| | Callable object computing the sine cardinal.
|
| |
| constexpr auto | sincos = functor<sincos_t> |
| | Callable object computing the simultaneous computation of sine an cosine.
|
| |
| constexpr auto | sind = functor<sind_t> |
| | Callable object computing the sine from an input in degrees.
|
| |
| constexpr auto | sindcosd = functor<sindcosd_t> |
| | Callable object computing the simultaneous computation of sine an cosine from an argument in degrees.
|
| |
| constexpr auto | sinh = functor<sinh_t> |
| | Callable object computing \(\frac{e^x-e^{-x}}2\).
|
| |
| constexpr auto | sinhc = functor<sinhc_t> |
| | 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> |
| | Callable object computing the sine rom an input in \(\pi\) multiples.
|
| |
| constexpr auto | sinpic = functor<sinpic_t> |
| | Callable object computing the normalized cardinal sine.
|
| |
| constexpr auto | sinpicospi = functor<sinpicospi_t> |
| | Callable object computing the simultaneous computation of sin an cos from an argument in \(\pi\) multiples.
|
| |
| constexpr auto | tan = functor<tan_t> |
| | Callable object computing the tangent.
|
| |
| constexpr auto | tand = functor<tand_t> |
| | Callable object computing the tangent from an input in degrees.
|
| |
| constexpr auto | tanh = functor<tanh_t> |
| | Callable object computing \(\frac{e^x-e^{-x}}{e^x+e^{-x}}\).
|
| |
| constexpr auto | tanpi = functor<tanpi_t> |
| | Callable object computing the tangent from an input in \(\pi\) multiples.
|
| |
| constexpr auto | gegenbauer = functor<gegenbauer_t> |
| | Computes the value of a gegenbauer polynomial \( \mathbf{C}_n^\lambda(x)\).
|
| |
| constexpr auto | hermite = functor<hermite_t> |
| | Computes the value of the 'physicists' Hermite polynomial of order n at x:
|
| |
| constexpr auto | jacobi = functor<jacobi_t> |
| | Computes the value of the Jacobi polynomials \(P^{\alpha, \beta}_n(x)\).
|
| |
| constexpr auto | laguerre = functor<laguerre_t> |
| | Computes 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> |
| | Computes the beta function: \(\displaystyle \mathbf{B}(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\) is returned.
|
| |
| constexpr auto | betainc_inv = functor<betainc_inv_t> |
| | Computes the inverse relative to the first parameter of the beta incomplete function.
|
| |
| constexpr auto | dawson = functor<dawson_t> |
| | Computes the Dawson function \(\displaystyle D_+(x)=e^{-x^2}\int_0^{x}
e^{t^2} \mbox{d}t\).
|
| |
| constexpr auto | digamma = functor<digamma_t> |
| | Computes the Digamma function i.e. the logarithmic derivative of the \(\Gamma\) function.
|
| |
| constexpr auto | double_factorial = functor<double_factorial_t> |
| | Computes the double factorial of n
|
| |
| constexpr auto | erf = functor<erf_t> |
| | Computes 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> |
| | Computes the inverse of the error function.
|
| |
| constexpr auto | erfc = functor<erfc_t> |
| | Computes the complementar 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 complementar error function \( \displaystyle
\mbox{erf}(x)=1-\frac{2}{\sqrt\pi}\int_0^{x} e^{-t^2}\mbox{d}t\).
|
| |
| 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> |
| | Computes 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> |
| | Computes \(\displaystyle n! = \prod_{i=1}^n i\).
|
| |
| constexpr auto | gamma_p = functor<gamma_p_t> |
| | Computes the normalized lower incomplete \(\Gamma\) function.
|
| |
| constexpr auto | gamma_p_inv = functor<gamma_p_inv_t> |
| | Computes 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> |
| | Computes the natural logarithm of the beta function.
|
| |
| constexpr auto | lfactorial = functor<lfactorial_t> |
| | Computes 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> |
| | Computes the natural logarithm of the absolute value of the \(\Gamma\) function.
|
| |
| constexpr auto | log_gamma = functor<log_gamma_t> |
| | Computes the natural logarithm of the \(\Gamma\) function.
|
| |
| constexpr auto | lrising_factorial = functor<lrising_factorial_t> |
| | Computes 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 the Wright \(\omega\) the inverse function of \( x \rightarrow \log
x+x\).
|
| |
| constexpr auto | rising_factorial = functor<rising_factorial_t> |
| | Computes the Rising Factorial function i.e. \(\frac{\Gamma(x+a)}{\Gamma(x)}\).
|
| |
| constexpr auto | signgam = functor<signgam_t> |
| | Computes the sign of the \(\Gamma\) function.
|
| |
| constexpr auto | stirling = functor<stirling_t> |
| | Computes the Stirling approximation of the \(\Gamma\) function.
|
| |
| constexpr auto | tgamma = functor<tgamma_t> |
| | Computes \(\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<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.
|
| |
