kyosu Namespace Reference

Main KYOSU namespace. More...

Detailed Description

Main KYOSU namespace.

Classes
struct	as_real
	Lightweight type-wrapper of real value type. More...
class	cayley_dickson
	Cayley-Dickson algebra main abstraction It is built so that all operation over C, Q and other such algebra can be done in a streamlined fashion based on the Cayley–Dickson construction. More...

Typedefs
template<unsigned int Dim, typename... Ts>
using	as_cayley_dickson_n_t = typename as_cayley_dickson_n< Dim, Ts... >::type
	Computes a Cayley-Dickson type of a given dimension.
template<typename... Ts>
using	as_cayley_dickson_t = typename as_cayley_dickson< Ts... >::type
	Computes the best fitting Cayley-Dickson type from a series of types.
template<typename T >
using	as_real_type_t = typename as_real_type< T >::type
	Compute the real type associated to a Cayley-Dickson-like type.
template<eve::floating_value T>
using	complex_t = as_cayley_dickson_n_t< 2, T >
	Type alias for complex numbers.
template<eve::floating_value T>
using	octonion_t = as_cayley_dickson_n_t< 8, T >
	Type alias for octonion numbers.
template<eve::floating_value T>
using	quaternion_t = as_cayley_dickson_n_t< 4, T >
	Type alias for quaternion numbers.

Functions
User-defined Literals
constexpr kyosu::complex_t< double >	operator""_i (unsigned long long d) noexcept
constexpr kyosu::complex_t< float >	operator""_if (unsigned long long d) noexcept
constexpr kyosu::quaternion_t< double >	operator""_j (unsigned long long d) noexcept
constexpr kyosu::quaternion_t< float >	operator""_jf (unsigned long long d) noexcept
constexpr kyosu::quaternion_t< double >	operator""_k (unsigned long long d) noexcept
constexpr kyosu::quaternion_t< float >	operator""_kf (unsigned long long d) noexcept
Binary Operators

Variables
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	acospi = eve::functor<acospi_t>
	Computes the arc cosine of the argument in \(\pi\) multiples.
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	acotpi = eve::functor<acotpi_t>
	Computes the arc cotangent of the argument in \(\pi\) multiples.
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	acscpi = eve::functor<acscpi_t>
	Computes the arc cosecant of the argume!nt in \(\pi\) multiples.
constexpr auto	agd = eve::functor<agd_t>
	Computes the 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	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	asecpi = eve::functor<asecpi_t>
	Computes the arc secant of the argument in \(\pi\) multiples.
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	asinpi = eve::functor<asinpi_t>
	Computes the arc sine of the argument in \(\pi\) multiples.
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	atanpi = eve::functor<atanpi_t>
	Computes the arc tangent of the argument in \(\pi\) multiples.
constexpr auto	average = eve::functor<average_t>
	Computes the average of the parameters.
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 or complex entries.
constexpr auto	ceil = eve::functor<ceil_t>
	Computes the ceil value.
constexpr auto	chi = eve::functor<chi_t>
	Computes the gudermanian of 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	cospi = eve::functor<cospi_t>
	Computes the cosine from the argument in \(\pi\) multiples.
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	cotpi = eve::functor<cotpi_t>
	Computes the cotangent from the argument in \(\pi\) multiples.
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	cscpi = eve::functor<cscpi_t>
	Computes the cosecant from the argument in \(\pi\) multiples.
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>
	Computes elementwise the dot product of the coordinates of the corresponding element.
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_ipi = eve::functor<exp_ipi_t>
	Computes the exponential of \(i\pi\) times the argument.
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	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	from_spherical = eve::functor<from_spherical_t>
	Callable object computing a quaternion from its spherical 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	horner = eve::functor<horner_t>
	Implement the horner scheme to evaluate polynomials.
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	ipart = extractor<1>{}
	Extracts the imaginary part of a value.
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_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_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_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	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	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 natural logarithm of the beta function.
constexpr auto	ldiv = eve::functor<ldiv_t>
	Computes the left division of the two parameters.
constexpr auto	lerp = eve::functor<lerp_t>
	Computes the linear interpolation.
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 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 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 the log of the \(\Gamma\) function.
constexpr auto	lpart = extractor<4>{}
	Extracts the \(l\) part of a value.
constexpr auto	lpnorm = eve::functor<lpnorm_t>
	Callable object computing the lpnorm operation \( \left(\sum_{i = 0}^n |x_i|^p\right)^{\frac1p} \).
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 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 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	oneminus = eve::functor<oneminus_t>
	Computes the value one minus the argument.
constexpr auto	pow = eve::functor<pow_t>
	Computes the computing the pow operation \(x^y\).
constexpr auto	pow1p = eve::functor<pow1p_t>
	Computes the computing the pow1p operation \((x+1)^y\).
constexpr auto	pow_abs = eve::functor<pow_abs_t>
	Computes the computing the pow_abs operation \(|x|^y\).
constexpr auto	powm1 = eve::functor<powm1_t>
	Computes the computing 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	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	secpi = eve::functor<secpi_t>
	Computes the secant of the argument in \(\pi\) multiples.
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	sinpi = eve::functor<sinpi_t>
	Computes the sine of the argument in \(\pi\) multiples.
constexpr auto	sinpicospi = eve::functor<sinpicospi_t>
	Computes simultaneously the sine and cosine of the argument in \(\pi\) multiples.
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	tanpi = eve::functor<tanpi_t>
	Computes the tangent of the argument in \(\pi\) multiples.
constexpr auto	tgamma = eve::functor<tgamma_t>
	Computes \(\Gamma(z)\)r.
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>
	To_Polarrements the argument.
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	trunc = eve::functor<trunc_t>
	Computes the trunc value.
constexpr auto	zeta = eve::functor<zeta_t>
	Computes the Riemann \( \displaystyle\zeta(z)=\sum_0^\infty \frac{1}{(n+1)^z}\).