|
| constexpr auto | abs = eve::functor<abs_t> |
| | Computes the absolute value of the parameter.
|
| constexpr auto | acos = eve::functor<acos_t> |
| | Computes the arc cosine of the argument.
|
| constexpr auto | acosh = eve::functor<acosh_t> |
| | Computes the inverse hyperbolic cosine of the argument.
|
| constexpr auto | acot = eve::functor<acot_t> |
| | Computes the arc cotangent of the argument.
|
| constexpr auto | acoth = eve::functor<acoth_t> |
| | Computes the inverse hyperbolic cotangent of the argument.
|
| constexpr auto | acsc = eve::functor<acsc_t> |
| | Computes the arccosecant of the argument.
|
| constexpr auto | acsch = eve::functor<acsch_t> |
| | Computes the inverse hyperbolic cosecant of the argument.
|
| constexpr auto | add = eve::functor<add_t> |
| | tuple_callable computing the sum of its arguments.
|
| constexpr auto | agd = eve::functor<agd_t> |
| | Computes the principal branch inverse gudermanian of the argument.
|
| constexpr auto | airy = eve::functor<airy_t> |
| | Computes simultaneously the airy functions \( Ai \) and \( Bi \).
|
| constexpr auto | airy_ai = eve::functor<airy_ai_t> |
| | Computes the airy function \(Ai\).
|
| constexpr auto | airy_bi = eve::functor<airy_bi_t> |
| | Computes the airy function \(Bi\).
|
| constexpr auto | align = eve::functor<align_t> |
| | Callable object computing an unitary quaternion value representing a rotation that align v0 to v1.
|
| constexpr auto | am = eve::functor<am_t> |
| | Computes Jacobi's Amplitude function.
|
| constexpr auto | arg = eve::functor<arg_t> |
| | argument.
|
| constexpr auto | asec = eve::functor<asec_t> |
| | Computes the arcsecant of the argument.
|
| constexpr auto | asech = eve::functor<asech_t> |
| | Computes the inverse hyperbolic secant of the argument.
|
| constexpr auto | asin = eve::functor<asin_t> |
| | Computes the arcsine of the argument.
|
| constexpr auto | asinh = eve::functor<asinh_t> |
| | Computes the inverse hyperbolic sine of the argument.
|
| constexpr auto | associator = eve::functor<associator_t> |
| | Computes the associator of the three parameters.
|
| constexpr auto | atan = eve::functor<atan_t> |
| | Computes the arctangent of the argument.
|
| constexpr auto | atanh = eve::functor<atanh_t> |
| | Computes the inverse hyperbolic tangent of the argument.
|
| constexpr auto | bessel_h = eve::functor<bessel_h_t> |
| | Computes the spherical or cylindrical Hankel functions, extended to the complex plane and cayley_dickson algebras.
|
| constexpr auto | bessel_i = eve::functor<bessel_i_t> |
| | Computes the spherical or cylindrical modified Bessel functions of the second kind, extended to the complex plane and cayley_dickson algebras.
|
| constexpr auto | bessel_j = eve::functor<bessel_j_t> |
| | Computes the spherical or cylindrical Bessel functions of the first kind, extended to the complex plane and cayley_dickson algebras.
|
| constexpr auto | bessel_k = eve::functor<bessel_k_t> |
| | Computes the spherical or cylindrical modified Bessel functions of the second kind, extended to the complex plane and cayley_dickson algebras.
|
| constexpr auto | bessel_y = eve::functor<bessel_y_t> |
| | Computes the spherical or cylindrical Bessel functions of the second kind, extended to the complex plane and cayley_dickson algebras.
|
| constexpr auto | beta = eve::functor<beta_t> |
| | Computes the beta function: \(\displaystyle \mathbf{B}(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\) for real, complex or general Cayley_dickson entries.
|
| constexpr auto | cbrt = eve::functor<cbrt_t> |
| | Computes the the kth cubic root of the argument.
|
| constexpr auto | ceil = eve::functor<ceil_t> |
| | Computes the ceil value.
|
| constexpr auto | chi = eve::functor<chi_t> |
| | Computes the value of the indicatrix of a set defined by a predicate at the argument.
|
| constexpr auto | cinf = eve::functor<cinf_t> |
| | Computes the complex-infinite defined as \(\textrm{NaN} + i\, \textrm{inf}\) in the chosen type.
|
| constexpr auto | commutator = eve::functor<commutator_t> |
| | Computes the commutator of the two parameters.
|
| constexpr auto | complex = eve::functor<make_complex_t> |
| | Constructs a kyosu::complex_t instance.
|
| constexpr auto | conj = eve::functor<conj_t> |
| | Computes the conjugate value.
|
| constexpr auto | convert = eve::functor<convert_t> |
| | convert to a target type
|
| constexpr auto | cos = eve::functor<cos_t> |
| | Computes the cosine of the argument.
|
| constexpr auto | cosh = eve::functor<cosh_t> |
| | Computes the hyperbolic cosine of the argument.
|
| constexpr auto | cot = eve::functor<cot_t> |
| | Computes the cotangent of the argument.
|
| constexpr auto | coth = eve::functor<coth_t> |
| | Computes the hyperbolic cotangent of the argument.
|
| constexpr auto | csc = eve::functor<csc_t> |
| | Computes the cosecant of the argument.
|
| constexpr auto | csch = eve::functor<csch_t> |
| | Computes the hyperbolic cosecant of the argument.
|
| constexpr auto | dec = eve::functor<dec_t> |
| | decrements the argument by 1.
|
| constexpr auto | deta = eve::functor<deta_t> |
| | Computes the Dirichlet sums \( \displaystyle \sum_{n = 0}^\infty \frac{(-1)^n}{(kn+1)^z}\).
|
| constexpr auto | digamma = eve::functor<digamma_t> |
| | Computes the Digamma function i.e. the logarithmic derivative of the \(\Gamma\) function.
|
| template<typename T> |
| constexpr unsigned int | dimension_v = *implementation-defined* |
| | Obtains the number of dimensions of the algebra containing a given type.
|
| constexpr auto | dist = eve::functor<dist_t> |
| | Computes the distance between the two parameters.
|
| constexpr auto | dot = eve::functor<dot_t> |
| | object computing the elementwise dot product of the vector of the first half parameters by thevector of the last half.
|
| constexpr auto | ellint_fe = eve::functor<ellint_fe_t> |
| | Computes Jacobi's Amplitude function.
|
| constexpr auto | ellint_rc = eve::functor<ellint_rc_t> |
| | Computes the Carlson's elliptic integral \( \mathbf{R}_\mathbf{C}(x, y) =
\frac12 \int_{0}^{\infty} \scriptstyle(t+x)^{-1/2}(t+y)]^{-1}\;\mathrm{d}t\).
|
| constexpr auto | ellint_rd = eve::functor<ellint_rd_t> |
| | Computes 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}\;\mathrm{d}t\).
|
| constexpr auto | ellint_rf = eve::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)(t+z)]^{-1/2}\scriptstyle\;\mathrm{d}t\).
|
| constexpr auto | ellint_rg = eve::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 = eve::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 | erf = eve::functor<erf_t> |
| | Computes the error function: \( \displaystyle
\mbox{erf}(x)=\frac{2}{\sqrt\pi}\int_0^{x} e^{-t^2}\mbox{d}t\) or its extension to complex and general cayley-dickson values.
|
| constexpr auto | erfcx = eve::functor<erfcx_t> |
| | Computes the normalized complementary error function \( \displaystyle \mbox{erfcx}(x) = e^{x^2} \mbox{erfc}(x)\).
|
| constexpr auto | erfi = eve::functor<erfi_t> |
| | Callable object computing The imaginary error function \( \displaystyle \mathrm{erfi}(z) = -i\mathrm{erf}(iz)\).
|
| constexpr auto | eta = eve::functor<eta_t> |
| | Computes the Dirichlet sum \( \displaystyle \sum_0^\infty \frac{(-1)^n}{(n+1)^z}\). Sometimes this function is for obvious reasons called the alternative \(\zeta\) function .
|
| constexpr auto | exp = eve::functor<exp_t> |
| | Computes the exponential of the argument.
|
| constexpr auto | exp10 = eve::functor<exp10_t> |
| | Computes the base 10 exponential of the argument.
|
| constexpr auto | exp2 = eve::functor<exp2_t> |
| | Computes the base 2 exponential of the argument.
|
| constexpr auto | exp_i = eve::functor<exp_i_t> |
| | Computes the exponential of i times the argument.
|
| constexpr auto | exp_int = eve::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 | expm1 = eve::functor<expm1_t> |
| | Computes the exponential of the argument minus 1.
|
| constexpr auto | expmx2 = eve::functor<expmx2_t> |
| | Computes the exponential of the opposite of the squared argument.
|
| constexpr auto | expx2 = eve::functor<expx2_t> |
| | Computes the exponential of the squared argument.
|
| constexpr auto | faddeeva = eve::functor<faddeeva_t> |
| | Callable object computing \(e^{-z^2}\mathrm{erfc}(-iz)\) the scaled complex complementary error function.
|
| constexpr auto | fam = eve::functor<fam_t> |
| | Computes fused add multiply.
|
| constexpr auto | floor = eve::functor<floor_t> |
| | Computes the floor value.
|
| constexpr auto | fma = eve::functor<fma_t> |
| | Computes fused multiply add.
|
| constexpr auto | fms = eve::functor<fms_t> |
| | Computes fused multiply add.
|
| constexpr auto | fnan = eve::functor<fnan_t> |
| | Computes the full nan constant such that all components of the chosen type are NaN.
|
| constexpr auto | fnma = eve::functor<fnma_t> |
| | Computes fused negate multiply add.
|
| constexpr auto | fnms = eve::functor<fnms_t> |
| | Computes fused negate multiply sub.
|
| constexpr auto | frac = eve::functor<frac_t> |
| | Computes the frac value.
|
| constexpr auto | from_angle_axis = eve::functor<from_angle_axis_t> |
| | Callable object computing an an unitary quaternion from an angle value and a 3 dimensional axis vector.
|
| constexpr auto | from_cylindrical = eve::functor<from_cylindrical_t> |
| | Callable object computing a quaternion from its cylindrical representation.
|
| constexpr auto | from_cylindrospherical = eve::functor<from_cylindrospherical_t> |
| | Callable object computing a quaternion from its cylindrospherical representation.
|
| constexpr auto | from_euler = eve::functor<from_euler_t> |
| | Callable object computing a quaternion from its euler representation.
|
| constexpr auto | from_multipolar = eve::functor<from_multipolar_t> |
| | Callable object computing a quaternion from its multipolar representation.
|
| constexpr auto | from_polar = eve::functor<from_polar_t> |
| | Callable object computing a complex or a general Cayley-Dickson from a polar representation.
|
| constexpr auto | from_rotation_matrix = eve::functor<from_rotation_matrix_t> |
| | Callable object computing a quaternion from its rotation_matrix representation.
|
| constexpr auto | from_semipolar = eve::functor<from_semipolar_t> |
| | Callable object computing a quaternion from its semipolar representation.
|
| constexpr auto | fsm = eve::functor<fsm_t> |
| | Computes fused sub multiply.
|
| constexpr auto | gd = eve::functor<gd_t> |
| | Computes the gudermanian of the argument.
|
| constexpr auto | gegenbauer = eve::functor<gegenbauer_t> |
| | Computes the value of the Gegenbauer function of order \(n\).
|
| constexpr auto | horner = eve::functor<horner_t> |
| | Implement the horner scheme to evaluate polynomials.
|
| constexpr auto | hypergeometric = eve::functor<hypergeometric_t> |
| | Computes the hypergeometric function \({}_pF_q(a_1, \dots, a_p; b_1,\dots, b_p; z)\) for \( 0 \le p, q \le 2\).
|
| constexpr auto | hypot = eve::functor<hypot_t> |
| | Callable object computing the hypot operation.
|
| constexpr auto | i = eve::functor<i_t> |
| | Computes the complex number \(i\) in the chosen type.
|
| constexpr auto | if_else = eve::functor<if_else_t> |
| | Select a value between two arguments based on a logical mask.
|
|
constexpr auto | imag = extractor<1>{} |
| | Alias for kyosu::ipart.
|
| constexpr auto | inc = eve::functor<inc_t> |
| | Increments the argument.
|
| constexpr auto | inject = eve::functor<inject_t> |
| | inject a real in the complex plane a nan producing a fnan.
|
| constexpr auto | ipart = extractor<1>{} |
| | Extracts the imaginary part of a value.
|
| constexpr auto | is_cinf = eve::functor<is_cinf_t> |
| | test if the parameter is a cinf.
|
| constexpr auto | is_denormal = eve::functor<is_denormal_t> |
| | test the parameter for denormality.
|
| constexpr auto | is_equal = eve::functor<is_equal_t> |
| | retuen true if and only if the two parameters are equal.
|
| constexpr auto | is_eqz = eve::functor<is_eqz_t> |
| | test the parameter for equality to zero.
|
| constexpr auto | is_finite = eve::functor<is_finite_t> |
| | test the parameter is finite.
|
| constexpr auto | is_flint = eve::functor<is_flint_t> |
| | test the parameter is a flint.
|
| constexpr auto | is_fnan = eve::functor<is_fnan_t> |
| | test the parameter for fnan
|
| constexpr auto | is_imag = eve::functor<is_imag_t> |
| | test if the parameter real part is zero.
|
| constexpr auto | is_infinite = eve::functor<is_infinite_t> |
| | test if the parameter is infinite.
|
| constexpr auto | is_nan = eve::functor<is_nan_t> |
| | test the parameter for nan
|
| constexpr auto | is_nez = eve::functor<is_nez_t> |
| | test the parameter for non-equality to zero.
|
| constexpr auto | is_not_cinf = eve::functor<is_not_cinf_t> |
| | test if the parameter is a not cinf.
|
| constexpr auto | is_not_denormal = eve::functor<is_not_denormal_t> |
| | test if the parameter is not denormal.
|
| constexpr auto | is_not_equal = eve::functor<is_not_equal_t> |
| | return true if and only if the two parameters are not equal.
|
| constexpr auto | is_not_finite = eve::functor<is_not_finite_t> |
| | test if the parameter is not finite.
|
| constexpr auto | is_not_flint = eve::functor<is_not_flint_t> |
| | test the parameter is not a flint.
|
| constexpr auto | is_not_fnan = eve::functor<is_not_fnan_t> |
| | test the parameter for not_fnan
|
| constexpr auto | is_not_infinite = eve::functor<is_not_infinite_t> |
| | test if the parameter is not infinite.
|
| constexpr auto | is_not_nan = eve::functor<is_not_nan_t> |
| | test if the parameter is not a Nan.
|
| constexpr auto | is_not_real = eve::functor<is_not_real_t> |
| | test if the parameter is not_real.
|
| constexpr auto | is_pure = eve::functor<is_pure_t> |
| | test if the parameter is pure.
|
| constexpr auto | is_real = eve::functor<is_real_t> |
| | test if the parameter is real.
|
| constexpr auto | is_unitary = eve::functor<is_unitary_t> |
| | test if the parameter is unitary (absolute value one).
|
| constexpr auto | j = eve::functor<j_t> |
| | Computes the complex number j i.e. quaternion(0, 0, 1, 0) in the chosen type.
|
| constexpr auto | jacobi_elliptic = eve::functor<jacobi_elliptic_t> |
| | Computes Jacobi's Amplitude function.
|
| constexpr auto | jpart = extractor<2>{} |
| | Extracts the \(j\) part of a value.
|
| constexpr auto | k = eve::functor<k_t> |
| | Computes the complex number k i.e. quaternion(0, 0, 0, 1) in the chosen type.
|
| constexpr auto | kpart = extractor<3>{} |
| | Extracts the \(k\) part of a value.
|
| constexpr auto | kummer = eve::functor<kummer_t> |
| | Computes the Kummer function (confluent hypergeometric function of the first kind) \(M\) (which is an other name for the hypergeometric function \({}_1F_1\)) and it regularized version \(\mathbf{M}\).
|
| constexpr auto | lambda = eve::functor<lambda_t> |
| | Callable object computing The Dirichlet \( \displaystyle \lambda(z) = \sum_0^\infty \frac{1}{(2n+1)^z}\).
|
| constexpr auto | lbeta = eve::functor<lbeta_t> |
| | Computes the principal branch of the natural logarithm of the beta function.
|
| constexpr auto | ldiv = eve::functor<ldiv_t> |
| | Computes the left division of the product of the arguments but the first.
|
| constexpr auto | legendre = eve::functor<legendre_t> |
| | Computes the value of the Legendre and associated Legendre functions of order n ( and m) at x:
|
| constexpr auto | lerp = eve::functor<lerp_t> |
| | Computes the linear interpolation.
|
| constexpr auto | linfnorm = eve::functor<linfnorm_t> |
| | Callable object computing the linfnorm operation \( \max_{i = 0}^n |x_i| \).
|
| constexpr auto | lipart = extractor<5>{} |
| | Extracts the \(li\) part of a value.
|
| constexpr auto | ljpart = extractor<6>{} |
| | Extracts the \(lj\) part of a value.
|
| constexpr auto | lkpart = extractor<7>{} |
| | Extracts the \(lk\) part of a value.
|
| constexpr auto | log = eve::functor<log_t> |
| | Computes the principal value of the natural logarithm of the argument.
|
| constexpr auto | log10 = eve::functor<log10_t> |
| | Computes the base 10 logarithm of the argument.
|
| constexpr auto | log1p = eve::functor<log1p_t> |
| | Computes the natural logarithm of the argument plus 1.
|
| constexpr auto | log2 = eve::functor<log2_t> |
| | Computes the principal branch of the base 2 logarithm of the argument.
|
| constexpr auto | log_abs = eve::functor<log_abs_t> |
| | Computes the natural logarithm of the absolute value of the argument.
|
| constexpr auto | log_abs_gamma = eve::functor<log_abs_gamma_t> |
| | Computes the log of the modulus of the \(\Gamma\) function of the parameter.
|
| constexpr auto | log_gamma = eve::functor<log_gamma_t> |
| | Computes \(\log(\Gamma(z))\).
|
| constexpr auto | lpart = extractor<4>{} |
| | Extracts the \(l\) part of a value.
|
| constexpr auto | lrising_factorial = eve::functor<lrising_factorial_t> |
| | Computes the natural logarithm of the rising_factorial function.
|
| constexpr auto | manhattan = eve::functor<manhattan_t> |
| | Computes the sum of the absolute values of all terms of all the parameters.
|
| constexpr auto | maxabs = eve::functor<maxabs_t> |
| | Callable object computing the maxabs operation.
|
| constexpr auto | maxmag = eve::functor<maxmag_t> |
| | Callable object computing the maxmag operation.
|
| constexpr auto | mi = eve::functor<mi_t> |
| | Computes the complex number \(-i\) in the chosen type.
|
| constexpr auto | minabs = eve::functor<minabs_t> |
| | Callable object computing the minabs operation.
|
| constexpr auto | minmag = eve::functor<minmag_t> |
| | Callable object computing the minmag operation.
|
| constexpr auto | minus = eve::functor<minus_t> |
| | Computes the opposite value.
|
| constexpr auto | muli = eve::functor<muli_t> |
| | Computes the value of the parameter multiplied by i on the left or right side. For real, complex and quaternion the computation is an optimization over the call to * operator.
|
| constexpr auto | mulmi = eve::functor<mulmi_t> |
| | Computes the value of the parameter multiplied by -i on the left or right side. For real, complex and quaternion the computation is an optimization over the call to * operator.
|
| constexpr auto | nearest = eve::functor<nearest_t> |
| | Computes the nearest value.
|
| constexpr auto | negmaxabs = eve::functor<negmaxabs_t> |
| | Callable object computing the negmaxabs operation.
|
| constexpr auto | negminabs = eve::functor<negminabs_t> |
| | Callable object computing the negminabs operation.
|
| constexpr auto | nthroot = eve::functor<nthroot_t> |
| | Computes the the kth nth root of the argument.
|
| constexpr auto | omega = eve::functor<omega_t> |
| | Computes the Wright \(\omega\) the inverse function of \( x \rightarrow \log x+x\).
|
| constexpr auto | oneminus = eve::functor<oneminus_t> |
| | Computes the value one minus the argument.
|
| constexpr auto | pow = eve::functor<pow_t> |
| | Computes the pow operation \(x^y\).
|
| constexpr auto | pow1p = eve::functor<pow1p_t> |
| | Computes the pow1p operation \((x+1)^y\).
|
| constexpr auto | pow_abs = eve::functor<pow_abs_t> |
| | Computes the pow_abs operation \(|x|^y\).
|
| constexpr auto | powm1 = eve::functor<powm1_t> |
| | Computes the powm1 operation \(x^y-1\).
|
| constexpr auto | proj = eve::functor<proj_t> |
| | Callable object computing proj(x), the projection of the cayley_dickson number z onto the (hyper) Riemann sphere.
|
| constexpr auto | pure = eve::functor<pure_t> |
| | Extracts the imaginary part of a value.
|
| constexpr auto | quaternion = eve::functor<make_quaternion_t> |
| | Constructs a kyosu::quaternion_t instance.
|
| constexpr auto | radinpi = eve::functor<radinpi_t> |
| | Computes the parameter divided by \(\pi\).
|
| constexpr auto | real = extractor<0>{} |
| | Extracts the real part of a value.
|
| constexpr auto | rec = eve::functor<rec_t> |
| | Computes the inverse of the argument.
|
| constexpr auto | reldist = eve::functor<reldist_t> |
| | Computes the relative distance between the two parameters.
|
| constexpr auto | reverse_horner = eve::functor<reverse_horner_t> |
| | Implement the reverse_horner scheme to evaluate polynomials.
|
| constexpr auto | rising_factorial = eve::functor<rising_factorial_t> |
| | Computes the rising_factorial function: \(\displaystyle \frac{\Gamma(a+x)}{\Gamma(a)}\).
|
| constexpr auto | rot_angle = eve::functor<rot_angle_t> |
| | Callable object computing the normalized angle of rotation defined by a quaternion.
|
| constexpr auto | rot_axis = eve::functor<rot_axis_t> |
| | Callable object computing the normalized axis of rotation defined by a quaternion.
|
| constexpr auto | rotate_vec = eve::functor<rotate_vec_t> |
| | Callable object rotating an \(\mathbb{R}^3\) vector using a quaternion.
|
| constexpr auto | rsqrt = eve::functor<rsqrt_t> |
| | Computes a inverse square root value.
|
| constexpr auto | sec = eve::functor<sec_t> |
| | Computes the secant of the argument.
|
| constexpr auto | sech = eve::functor<sech_t> |
| | Computes the hyperbolic secant of the argument.
|
| constexpr auto | sign = eve::functor<sign_t> |
| | Computes tne normalized value z/abs(z) if z is not zero else 0.
|
| constexpr auto | signnz = eve::functor<signnz_t> |
| | Computes tne normalized value z/abs(z) if z is not zero else the sign of the real part as a cayley_dickson.
|
| constexpr auto | sin = eve::functor<sin_t> |
| | Computes the sine of the argument.
|
| constexpr auto | sinc = eve::functor<sinc_t> |
| | Computes the sine cardinal of the argument.
|
| constexpr auto | sincos = eve::functor<sincos_t> |
| | Computes simultaneously the sine and cosine of the argument.
|
| constexpr auto | sinh = eve::functor<sinh_t> |
| | Computes the hyperbolic sine of the argument.
|
| constexpr auto | sinhc = eve::functor<sinhc_t> |
| | Computes the hyperbolic sine cardinal of the argument.
|
| constexpr auto | sinhcosh = eve::functor<sinhcosh_t> |
| | Computes simultaneously the hyperbolic sine and cosine of the argument.
|
| constexpr auto | slerp = eve::functor<slerp_t> |
| | Computes the spherical interpolation between unitary quaternions.
|
| constexpr auto | sqr = eve::functor<sqr_t> |
| | Computes the square value.
|
| constexpr auto | sqr_abs = eve::functor<sqr_abs_t> |
| | Computes the squared sqr_absolute value of the parameter.
|
| constexpr auto | sqrt = eve::functor<sqrt_t> |
| | Computes a square root value.
|
| constexpr auto | tan = eve::functor<tan_t> |
| | Computes the tangent of the argument.
|
| constexpr auto | tanh = eve::functor<tanh_t> |
| | Computes the hyperbolic tangent of the argument.
|
| constexpr auto | tchebytchev = eve::functor<tchebytchev_t> |
| | Computes the value of the Tchebytchev polynomial of order n at x:
|
| constexpr auto | tgamma = eve::functor<tgamma_t> |
| | Computes \(\Gamma(z)\) the gamma function.
|
| constexpr auto | tgamma_inv = eve::functor<tgamma_inv_t> |
| | Computes \(\frac1{\Gamma(z)}\).
|
| constexpr auto | to_angle_axis = eve::functor<to_angle_axis_t> |
| | Callable object computing the angle and axis coordinates from a quaternion.
|
| constexpr auto | to_cylindrical = eve::functor<to_cylindrical_t> |
| | Callable object computing the cylindrical coordinates to a quaternion.
|
| constexpr auto | to_cylindrospherical = eve::functor<to_cylindrospherical_t> |
| | Callable object computing the cylindrospherical coordinates from a quaternion.
|
| constexpr auto | to_euler = eve::functor<to_euler_t> |
| | Callable object computing euler angles from a quaternion.
|
| constexpr auto | to_multipolar = eve::functor<to_multipolar_t> |
| | Callable object computing the multipolar coordinates to a quaternion.
|
| constexpr auto | to_polar = eve::functor<to_polar_t> |
| | returns modulus and argument of the input.
|
| constexpr auto | to_rotation_matrix = eve::functor<to_rotation_matrix_t> |
| | Callable object computing a quaternion from its to_rotation_matrix representation.
|
| constexpr auto | to_semipolar = eve::functor<to_semipolar_t> |
| | Callable object computing the semipolar coordinates from a quaternion.
|
| constexpr auto | to_spherical = eve::functor<to_spherical_t> |
| | Callable object computing the spherical coordinates from a quaternion.
|
| constexpr auto | tricomi = eve::functor<tricomi_t> |
| | Computes the tricomi function \(U\) also called confluent hypergeometric function of the second kind.
|
| constexpr auto | trunc = eve::functor<trunc_t> |
| | Computes the trunc value.
|
| constexpr auto | xi = eve::functor<xi_t> |
| | Computes the Riemann \( \displaystyle\xi(z) = \frac{1}{2}z(z-1)\pi^{-\frac{z}{2}}\Gamma(\frac{z}{2})\zeta(z)\). function or the Landau version \( \displaystyle\Xi(z) = \xi(\frac{1}{2} + i z)\).
|
| constexpr auto | zeta = eve::functor<zeta_t> |
| | Computes the Riemann \( \displaystyle\zeta(z)=\sum_0^\infty \frac{1}{(n+1)^z}\).
|
| constexpr auto | div = eve::functor<div_t> |
| | tuple_callable computing the division of its first argument with the product of the others.
|
| constexpr auto | kronecker = eve::functor<kronecker_t> |
| | tuple_callable computing the \(\delta\) (Kronecker symbol) of its arguments.
|
| constexpr auto | mul = eve::functor<mul_t> |
| | tuple_callable computing the product of its arguments.
|
| constexpr auto | sub = eve::functor<sub_t> |
| | tuple_callable computing the difference of its first argument with the sum of the others.
|
