 |
kyosu v0.1.0
Complex Without Complexes
|
| |
|
kyosu v0.1.0
Complex Without Complexes
|
|
| |
Functions performing computations over all Cayley-Dickson types complex, quaternions, octonions... More...
Variables | |
| constexpr auto | kyosu::abs = eve::functor<abs_t> |
| Computes the absolute value of the parameter. | |
| constexpr auto | kyosu::acos = eve::functor<acos_t> |
| Computes the arc cosine of the argument. | |
| constexpr auto | kyosu::acosh = eve::functor<acosh_t> |
| Computes the inverse hyperbolic cosine of the argument. | |
| constexpr auto | kyosu::acospi = eve::functor<acospi_t> |
| Computes the arc cosine of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::acot = eve::functor<acot_t> |
| Computes the arc cotangent of the argument. | |
| constexpr auto | kyosu::acoth = eve::functor<acoth_t> |
| Computes the inverse hyperbolic cotangent of the argument. | |
| constexpr auto | kyosu::acotpi = eve::functor<acotpi_t> |
| Computes the arc cotangent of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::acsc = eve::functor<acsc_t> |
| Computes the arccosecant of the argument. | |
| constexpr auto | kyosu::acsch = eve::functor<acsch_t> |
| Computes the inverse hyperbolic cosecant of the argument. | |
| constexpr auto | kyosu::acscpi = eve::functor<acscpi_t> |
| Computes the arc cosecant of the argume!nt in \(\pi\) multiples. | |
| constexpr auto | kyosu::agd = eve::functor<agd_t> |
| Computes the gudermanian of the argument. | |
| constexpr auto | kyosu::airy = eve::functor<airy_t> |
| Computes simultaneously the airy functions \( Ai \) and \( Bi \). | |
| constexpr auto | kyosu::airy_ai = eve::functor<airy_ai_t> |
| Computes the airy function \(Ai\). | |
| constexpr auto | kyosu::airy_bi = eve::functor<airy_bi_t> |
| Computes the airy function \(Bi\). | |
| constexpr auto | kyosu::arg = eve::functor<arg_t> |
| argument. | |
| constexpr auto | kyosu::asec = eve::functor<asec_t> |
| Computes the arcsecant of the argument. | |
| constexpr auto | kyosu::asech = eve::functor<asech_t> |
| Computes the inverse hyperbolic secant of the argument. | |
| constexpr auto | kyosu::asecpi = eve::functor<asecpi_t> |
| Computes the arc secant of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::asin = eve::functor<asin_t> |
| Computes the arcsine of the argument. | |
| constexpr auto | kyosu::asinh = eve::functor<asinh_t> |
| Computes the inverse hyperbolic sine of the argument. | |
| constexpr auto | kyosu::asinpi = eve::functor<asinpi_t> |
| Computes the arc sine of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::associator = eve::functor<associator_t> |
| Computes the associator of the three parameters. | |
| constexpr auto | kyosu::atan = eve::functor<atan_t> |
| Computes the arctangent of the argument. | |
| constexpr auto | kyosu::atanh = eve::functor<atanh_t> |
| Computes the inverse hyperbolic tangent of the argument. | |
| constexpr auto | kyosu::atanpi = eve::functor<atanpi_t> |
| Computes the arc tangent of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::average = eve::functor<average_t> |
| Computes the average of the parameters. | |
| constexpr auto | kyosu::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 | kyosu::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 | kyosu::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 | kyosu::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 | kyosu::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 | kyosu::beta = eve::functor<beta_t> |
| Computes the beta function: \(\displaystyle \mathbf{B}(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\) for real or complex entries. | |
| constexpr auto | kyosu::ceil = eve::functor<ceil_t> |
| Computes the ceil value. | |
| constexpr auto | kyosu::chi = eve::functor<chi_t> |
| Computes the gudermanian of the argument. | |
| constexpr auto | kyosu::commutator = eve::functor<commutator_t> |
| Computes the commutator of the two parameters. | |
| constexpr auto | kyosu::complex = eve::functor<make_complex_t> |
| Constructs a kyosu::complex_t instance. | |
| constexpr auto | kyosu::conj = eve::functor<conj_t> |
| Computes the conjugate value. | |
| constexpr auto | kyosu::convert = eve::functor<convert_t> |
| convert to a target type | |
| constexpr auto | kyosu::cos = eve::functor<cos_t> |
| Computes the cosine of the argument. | |
| constexpr auto | kyosu::cosh = eve::functor<cosh_t> |
| Computes the hyperbolic cosine of the argument. | |
| constexpr auto | kyosu::cospi = eve::functor<cospi_t> |
| Computes the cosine from the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::cot = eve::functor<cot_t> |
| Computes the cotangent of the argument. | |
| constexpr auto | kyosu::coth = eve::functor<coth_t> |
| Computes the hyperbolic cotangent of the argument. | |
| constexpr auto | kyosu::cotpi = eve::functor<cotpi_t> |
| Computes the cotangent from the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::csc = eve::functor<csc_t> |
| Computes the cosecant of the argument. | |
| constexpr auto | kyosu::csch = eve::functor<csch_t> |
| Computes the hyperbolic cosecant of the argument. | |
| constexpr auto | kyosu::cscpi = eve::functor<cscpi_t> |
| Computes the cosecant from the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::dec = eve::functor<dec_t> |
| decrements the argument by 1. | |
| constexpr auto | kyosu::deta = eve::functor<deta_t> |
| Computes the Dirichlet sums \( \displaystyle \sum_{n = 0}^\infty \frac{(-1)^n}{(kn+1)^z}\). | |
| constexpr auto | kyosu::digamma = eve::functor<digamma_t> |
| Computes the Digamma function i.e. the logarithmic derivative of the \(\Gamma\) function. | |
| constexpr auto | kyosu::dist = eve::functor<dist_t> |
| Computes the distance between the two parameters. | |
| constexpr auto | kyosu::dot = eve::functor<dot_t> |
| Computes elementwise the dot product of the coordinates of the corresponding element. | |
| constexpr auto | kyosu::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 | kyosu::erfcx = eve::functor<erfcx_t> |
| Computes the normalized complementary error function \( \displaystyle \mbox{erfcx}(x) = e^{x^2} \mbox{erfc}(x)\). | |
| constexpr auto | kyosu::erfi = eve::functor<erfi_t> |
| Callable object computing The imaginary error function \( \displaystyle \mathrm{erfi}(z) = -i\mathrm{erf}(iz)\). | |
| constexpr auto | kyosu::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 | kyosu::exp = eve::functor<exp_t> |
| Computes the exponential of the argument. | |
| constexpr auto | kyosu::exp10 = eve::functor<exp10_t> |
| Computes the base 10 exponential of the argument. | |
| constexpr auto | kyosu::exp2 = eve::functor<exp2_t> |
| Computes the base 2 exponential of the argument. | |
| constexpr auto | kyosu::exp_i = eve::functor<exp_i_t> |
| Computes the exponential of i times the argument. | |
| constexpr auto | kyosu::exp_ipi = eve::functor<exp_ipi_t> |
| Computes the exponential of \(i\pi\) times the argument. | |
| constexpr auto | kyosu::expm1 = eve::functor<expm1_t> |
| Computes the exponential of the argument minus 1. | |
| constexpr auto | kyosu::expmx2 = eve::functor<expmx2_t> |
| Computes the exponential of the opposite of the squared argument. | |
| constexpr auto | kyosu::expx2 = eve::functor<expx2_t> |
| Computes the exponential of the squared argument. | |
| constexpr auto | kyosu::faddeeva = eve::functor<faddeeva_t> |
| Callable object computing \(e^{-z^2}\mathrm{erfc}(-iz)\) the scaled complex complementary error function. | |
| constexpr auto | kyosu::fam = eve::functor<fam_t> |
| Computes fused add multiply. | |
| constexpr auto | kyosu::floor = eve::functor<floor_t> |
| Computes the floor value. | |
| constexpr auto | kyosu::fma = eve::functor<fma_t> |
| Computes fused multiply add. | |
| constexpr auto | kyosu::fms = eve::functor<fms_t> |
| Computes fused multiply add. | |
| constexpr auto | kyosu::fnma = eve::functor<fnma_t> |
| Computes fused negate multiply add. | |
| constexpr auto | kyosu::fnms = eve::functor<fnms_t> |
| Computes fused negate multiply sub. | |
| constexpr auto | kyosu::frac = eve::functor<frac_t> |
| Computes the frac value. | |
| constexpr auto | kyosu::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 | kyosu::fsm = eve::functor<fsm_t> |
| Computes fused sub multiply. | |
| constexpr auto | kyosu::gd = eve::functor<gd_t> |
| Computes the gudermanian of the argument. | |
| constexpr auto | kyosu::horner = eve::functor<horner_t> |
| Implement the horner scheme to evaluate polynomials. | |
| constexpr auto | kyosu::hypot = eve::functor<hypot_t> |
| Callable object computing the hypot operation. | |
| constexpr auto | kyosu::if_else = eve::functor<if_else_t> |
| Select a value between two arguments based on a logical mask. | |
| constexpr auto | kyosu::imag = extractor<1>{} |
| Alias for kyosu::ipart. | |
| constexpr auto | kyosu::inc = eve::functor<inc_t> |
| Increments the argument. | |
| constexpr auto | kyosu::ipart = extractor<1>{} |
| Extracts the imaginary part of a value. | |
| constexpr auto | kyosu::is_denormal = eve::functor<is_denormal_t> |
| test the parameter for denormality. | |
| constexpr auto | kyosu::is_equal = eve::functor<is_equal_t> |
| retuen true if and only if the two parameters are equal. | |
| constexpr auto | kyosu::is_eqz = eve::functor<is_eqz_t> |
| test the parameter for equality to zero. | |
| constexpr auto | kyosu::is_finite = eve::functor<is_finite_t> |
| test the parameter is finite. | |
| constexpr auto | kyosu::is_imag = eve::functor<is_imag_t> |
| test if the parameter real part is zero. | |
| constexpr auto | kyosu::is_infinite = eve::functor<is_infinite_t> |
| test if the parameter is infinite. | |
| constexpr auto | kyosu::is_nan = eve::functor<is_nan_t> |
| test the parameter for nan | |
| constexpr auto | kyosu::is_nez = eve::functor<is_nez_t> |
| test the parameter for non-equality to zero. | |
| constexpr auto | kyosu::is_not_denormal = eve::functor<is_not_denormal_t> |
| test if the parameter is not denormal. | |
| constexpr auto | kyosu::is_not_equal = eve::functor<is_not_equal_t> |
| return true if and only if the two parameters are not equal. | |
| constexpr auto | kyosu::is_not_finite = eve::functor<is_not_finite_t> |
| test if the parameter is not finite. | |
| constexpr auto | kyosu::is_not_infinite = eve::functor<is_not_infinite_t> |
| test if the parameter is not infinite. | |
| constexpr auto | kyosu::is_not_nan = eve::functor<is_not_nan_t> |
| test if the parameter is not a Nan. | |
| constexpr auto | kyosu::is_not_real = eve::functor<is_not_real_t> |
| test if the parameter is not_real. | |
| constexpr auto | kyosu::is_pure = eve::functor<is_pure_t> |
| test if the parameter is pure. | |
| constexpr auto | kyosu::is_real = eve::functor<is_real_t> |
| test if the parameter is real. | |
| constexpr auto | kyosu::is_unitary = eve::functor<is_unitary_t> |
| test if the parameter is unitary (absolute value one). | |
| constexpr auto | kyosu::jpart = extractor<2>{} |
| Extracts the \(j\) part of a value. | |
| constexpr auto | kyosu::kpart = extractor<3>{} |
| Extracts the \(k\) part of a value. | |
| constexpr auto | kyosu::lambda = eve::functor<lambda_t> |
| Callable object computing The Dirichlet \( \displaystyle \lambda(z) = \sum_0^\infty \frac{1}{(2n+1)^z}\). | |
| constexpr auto | kyosu::lbeta = eve::functor<lbeta_t> |
Computes the natural logarithm of the beta function. | |
| constexpr auto | kyosu::ldiv = eve::functor<ldiv_t> |
| Computes the left division of the two parameters. | |
| constexpr auto | kyosu::lerp = eve::functor<lerp_t> |
| Computes the linear interpolation. | |
| constexpr auto | kyosu::lipart = extractor<5>{} |
| Extracts the \(li\) part of a value. | |
| constexpr auto | kyosu::ljpart = extractor<6>{} |
| Extracts the \(lj\) part of a value. | |
| constexpr auto | kyosu::lkpart = extractor<7>{} |
| Extracts the \(lk\) part of a value. | |
| constexpr auto | kyosu::log = eve::functor<log_t> |
| Computes the natural logarithm of the argument. | |
| constexpr auto | kyosu::log10 = eve::functor<log10_t> |
| Computes the base 10 logarithm of the argument. | |
| constexpr auto | kyosu::log1p = eve::functor<log1p_t> |
| Computes the natural logarithm of the argument plus 1. | |
| constexpr auto | kyosu::log2 = eve::functor<log2_t> |
| Computes the base 2 logarithm of the argument. | |
| constexpr auto | kyosu::log_abs = eve::functor<log_abs_t> |
| Computes the natural logarithm of the absolute value of the argument. | |
| constexpr auto | kyosu::log_abs_gamma = eve::functor<log_abs_gamma_t> |
| Computes the log of the modulus of the \(\Gamma\) function of the parameter. | |
| constexpr auto | kyosu::log_gamma = eve::functor<log_gamma_t> |
| Computes the log of the \(\Gamma\) function. | |
| constexpr auto | kyosu::lpart = extractor<4>{} |
| Extracts the \(l\) part of a value. | |
| constexpr auto | kyosu::lpnorm = eve::functor<lpnorm_t> |
| Callable object computing the lpnorm operation \( \left(\sum_{i = 0}^n
|x_i|^p\right)^{\frac1p} \). | |
| constexpr auto | kyosu::lrising_factorial = eve::functor<lrising_factorial_t> |
| Computes the natural logarithm of the rising_factorial function. | |
| constexpr auto | kyosu::manhattan = eve::functor<manhattan_t> |
| Computes the sum of the absolute values of all terms of all the parameters. | |
| constexpr auto | kyosu::maxabs = eve::functor<maxabs_t> |
| Callable object computing the maxabs operation. | |
| constexpr auto | kyosu::maxmag = eve::functor<maxmag_t> |
| Callable object computing the maxmag operation. | |
| constexpr auto | kyosu::minabs = eve::functor<minabs_t> |
| Callable object computing the minabs operation. | |
| constexpr auto | kyosu::minmag = eve::functor<minmag_t> |
| Callable object computing the minmag operation. | |
| constexpr auto | kyosu::minus = eve::functor<minus_t> |
| Computes the opposite value. | |
| constexpr auto | kyosu::muli = eve::functor<muli_t> |
| Computes the value of the parameter multiplied by i on the left side. For real, complex and quaternion the computation is an optimization over the call to * operator. | |
| constexpr auto | kyosu::mulmi = eve::functor<mulmi_t> |
| Computes the value of the parameter multiplied by i on the left side. For real, complex and quaternion the computation is an optimization over the call to * operator. | |
| constexpr auto | kyosu::nearest = eve::functor<nearest_t> |
| Computes the nearest value. | |
| constexpr auto | kyosu::negmaxabs = eve::functor<negmaxabs_t> |
| Callable object computing the negmaxabs operation. | |
| constexpr auto | kyosu::negminabs = eve::functor<negminabs_t> |
| Callable object computing the negminabs operation. | |
| constexpr auto | kyosu::oneminus = eve::functor<oneminus_t> |
| Computes the value one minus the argument. | |
| constexpr auto | kyosu::pow = eve::functor<pow_t> |
| Computes the computing the pow operation \(x^y\). | |
| constexpr auto | kyosu::pow1p = eve::functor<pow1p_t> |
| Computes the computing the pow1p operation \((x+1)^y\). | |
| constexpr auto | kyosu::pow_abs = eve::functor<pow_abs_t> |
| Computes the computing the pow_abs operation \(|x|^y\). | |
| constexpr auto | kyosu::powm1 = eve::functor<powm1_t> |
| Computes the computing the powm1 operation \(x^y-1\). | |
| constexpr auto | kyosu::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 | kyosu::pure = eve::functor<pure_t> |
| Extracts the imaginary part of a value. | |
| constexpr auto | kyosu::quaternion = eve::functor<make_quaternion_t> |
| Constructs a kyosu::quaternion_t instance. | |
| constexpr auto | kyosu::radinpi = eve::functor<radinpi_t> |
| Computes the parameter divided by \(\pi\). | |
| constexpr auto | kyosu::real = extractor<0>{} |
| Extracts the real part of a value. | |
| constexpr auto | kyosu::rec = eve::functor<rec_t> |
| Computes the inverse of the argument. | |
| constexpr auto | kyosu::reldist = eve::functor<reldist_t> |
| Computes the relative distance between the two parameters. | |
| constexpr auto | kyosu::reverse_horner = eve::functor<reverse_horner_t> |
| Implement the reverse_horner scheme to evaluate polynomials. | |
| constexpr auto | kyosu::rising_factorial = eve::functor<rising_factorial_t> |
| Computes the rising_factorial function: \(\displaystyle \frac{\Gamma(a+x)}{\Gamma(a)}\). | |
| constexpr auto | kyosu::sec = eve::functor<sec_t> |
| Computes the secant of the argument. | |
| constexpr auto | kyosu::sech = eve::functor<sech_t> |
| Computes the hyperbolic secant of the argument. | |
| constexpr auto | kyosu::secpi = eve::functor<secpi_t> |
| Computes the secant of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::sign = eve::functor<sign_t> |
| Computes tne normalized value z/abs(z) if z is not zero else 0. | |
| constexpr auto | kyosu::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 | kyosu::sin = eve::functor<sin_t> |
| Computes the sine of the argument. | |
| constexpr auto | kyosu::sinc = eve::functor<sinc_t> |
| Computes the sine cardinal of the argument. | |
| constexpr auto | kyosu::sincos = eve::functor<sincos_t> |
| Computes simultaneously the sine and cosine of the argument. | |
| constexpr auto | kyosu::sinh = eve::functor<sinh_t> |
| Computes the hyperbolic sine of the argument. | |
| constexpr auto | kyosu::sinhc = eve::functor<sinhc_t> |
| Computes the hyperbolic sine cardinal of the argument. | |
| constexpr auto | kyosu::sinhcosh = eve::functor<sinhcosh_t> |
| Computes simultaneously the hyperbolic sine and cosine of the argument. | |
| constexpr auto | kyosu::sinpi = eve::functor<sinpi_t> |
| Computes the sine of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::sinpicospi = eve::functor<sinpicospi_t> |
| Computes simultaneously the sine and cosine of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::slerp = eve::functor<slerp_t> |
| Computes the spherical interpolation between unitary quaternions. | |
| constexpr auto | kyosu::sqr = eve::functor<sqr_t> |
| Computes the square value. | |
| constexpr auto | kyosu::sqr_abs = eve::functor<sqr_abs_t> |
| Computes the squared sqr_absolute value of the parameter. | |
| constexpr auto | kyosu::sqrt = eve::functor<sqrt_t> |
| Computes a square root value. | |
| constexpr auto | kyosu::tan = eve::functor<tan_t> |
| Computes the tangent of the argument. | |
| constexpr auto | kyosu::tanh = eve::functor<tanh_t> |
| Computes the hyperbolic tangent of the argument. | |
| constexpr auto | kyosu::tanpi = eve::functor<tanpi_t> |
| Computes the tangent of the argument in \(\pi\) multiples. | |
| constexpr auto | kyosu::tgamma = eve::functor<tgamma_t> |
| Computes \(\Gamma(z)\)r. | |
| constexpr auto | kyosu::to_polar = eve::functor<to_polar_t> |
| To_Polarrements the argument. | |
| constexpr auto | kyosu::trunc = eve::functor<trunc_t> |
| Computes the trunc value. | |
| constexpr auto | kyosu::zeta = eve::functor<zeta_t> |
| Computes the Riemann \( \displaystyle\zeta(z)=\sum_0^\infty \frac{1}{(n+1)^z}\). | |