kyosu Namespace Reference

Main KYOSU namespace. More...

Detailed Description

Main KYOSU namespace.

Classes
struct	as_real
	Lightweight type-wrapper of real value type. 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<typename T >
using	complex_t = as_cayley_dickson_n_t< 2, T >
	Type alias for complex numbers.
template<typename T >
using	octonion_t = as_cayley_dickson_n_t< 8, T >
	Type alias for octonion numbers.
template<typename T >
using	quaternion_t = as_cayley_dickson_n_t< 4, T >
	Type alias for quaternion numbers.

Functions
Deduction Guides
template<kumi::product_type Tuple>
	cayley_dickson (Tuple const &) -> cayley_dickson< kumi::element_t< 0, Tuple >, kumi::size_v< Tuple > >
	Deduction guide for constructing from product type.
template<typename T0 , std::convertible_to< T0 >... Ts>
	cayley_dickson (T0, Ts...) -> cayley_dickson< T0, 1+sizeof...(Ts)>
	Deduction guide for constructing from sequence of values.
Compound Assignment Operators
constexpr auto &	operator+= (concepts::cayley_dickson auto &self, eve::ordered_value auto other) noexcept
	Adds the real value other to self and returns the new value of self.
template<concepts::cayley_dickson Self, concepts::cayley_dickson Other> requires (dimension_v<Other> <= dimension_v<Self>)
constexpr auto &	operator+= (Self &self, Other const &other) noexcept
	Adds the Caley-dickson value other to self and returns the new value of self.
constexpr auto &	operator-= (concepts::cayley_dickson auto &self, eve::ordered_value auto other) noexcept
	Substracts the real value other from self and returns the new value of self.
template<concepts::cayley_dickson Self, concepts::cayley_dickson Other> requires (dimension_v<Other> <= dimension_v<Self>)
constexpr auto &	operator-= (Self &self, Other const &other) noexcept
	Substracts the Caley-dickson value other from self and returns the new value of self.
constexpr auto &	operator*= (concepts::cayley_dickson auto &self, eve::ordered_value auto other) noexcept
	Multiplies self by the real value other and returns the new value of self.
template<concepts::cayley_dickson Self, concepts::cayley_dickson Other> requires (dimension_v<Other> <= dimension_v<Self>)
constexpr Self &	operator*= (Self &self, Other const &other) noexcept
	Multiplies self by the Caley-dickson value other and returns the new value of self.
constexpr auto &	operator/= (concepts::cayley_dickson auto &self, eve::ordered_value auto other) noexcept
	Divides self by the real value other and returns the new value of self.
template<concepts::cayley_dickson Self, concepts::cayley_dickson Other> requires (dimension_v<Other> <= dimension_v<Self>)
constexpr Self &	operator/= (Self &self, Other const &other) noexcept
	Divides self by the Caley-dickson value other and returns the new value of self.
Streaming Operators
template<concepts::cayley_dickson CD>
std::ostream &	operator<< (std::ostream &os, CD const &z)
	Stream insertion for Caley-dickson based types.
Unary Operators
template<concepts::cayley_dickson Z>
constexpr auto	operator+ (Z const &z) noexcept
	Identity for Caley-dickson value.
template<concepts::cayley_dickson Z>
constexpr auto	operator- (Z const &z) noexcept
	Compute the negation of a given Caley-dickson value.
Binary Operators
template<eve::value T1, eve::value T2> requires (concepts::cayley_dickson<T1> || concepts::cayley_dickson<T2>)
auto	operator+ (T1 const &a, T2 const &b) noexcept -> as_cayley_dickson_t< T1, T2 >
	Returns the sum of a Caley-dickson value and a real value in any order.
template<eve::value T1, eve::value T2> requires (concepts::cayley_dickson<T1> || concepts::cayley_dickson<T2>)
as_cayley_dickson_t< T1, T2 >	operator- (T1 const &a, T2 const &b) noexcept
	Returns the difference of two Caley-dickson values.
template<eve::value T1, eve::value T2> requires (concepts::cayley_dickson<T1> && concepts::cayley_dickson<T2>)
as_cayley_dickson_t< T1, T2 >	operator* (T1 const &a, T2 const &b) noexcept
	Returns the product of two Caley-dickson values.
template<eve::value T1, eve::value T2> requires (concepts::cayley_dickson<T1> != concepts::cayley_dickson<T2>)
as_cayley_dickson_t< T1, T2 >	operator* (T1 const &a, T2 const &b) noexcept
template<eve::value T1, eve::value T2> requires (concepts::cayley_dickson<T1> || concepts::cayley_dickson<T2>)
as_cayley_dickson_t< T1, T2 >	operator/ (T1 const &a, T2 const &b) noexcept
	Returns the ration of two Caley-dickson values.

Variables
constexpr tags::callable_abs	abs = {}
	Computes the absolute value of the parameter.
constexpr tags::callable_acos	acos = {}
	Computes the acosine of the argument.
constexpr tags::callable_acosh	acosh = {}
	Computes the inverse hyperbolic cosine of the argument.
constexpr tags::callable_acospi	acospi = {}
	Computes the arc cosine of the argument in \(\pi\) multiples.
constexpr tags::callable_acot	acot = {}
	Computes the arc cotangent of the argument.
constexpr tags::callable_acoth	acoth = {}
	Computes the inverse hyperbolic cotangent of the argument.
constexpr tags::callable_acotpi	acotpi = {}
	Computes the arc cotangent of the argument in \(\pi\) multiples.
constexpr tags::callable_acsc	acsc = {}
	Computes the arccosecant of the argument.
constexpr tags::callable_acsch	acsch = {}
	Computes the inverse hyperbolic cosecant of the argument.
constexpr tags::callable_acscpi	acscpi = {}
	Computes the arc cosecant of the argume!nt in \(\pi\) multiples.
constexpr tags::callable_align	align = {}
	Callable object computing a quaternion from its angle_axis representation.
constexpr tags::callable_arg	arg = {}
	argument.
constexpr tags::callable_asec	asec = {}
	Computes the arcsecant of the argument.
constexpr tags::callable_asech	asech = {}
	Computes the inverse hyperbolic secant of the argument.
constexpr tags::callable_asecpi	asecpi = {}
	Computes the arc secant of the argument in \(\pi\) multiples.
constexpr tags::callable_asin	asin = {}
	Computes the arcsine of the argument.
constexpr tags::callable_asinh	asinh = {}
	Computes the inverse hyperbolic sine of the argument.
constexpr tags::callable_asinpi	asinpi = {}
	Computes the arc sine of the argument in \(\pi\) multiples.
constexpr tags::callable_associator	associator = {}
	Computes the associator of the three parameters.
constexpr tags::callable_atan	atan = {}
	Computes the arctangent of the argument.
constexpr tags::callable_atanh	atanh = {}
	Computes the inverse hyperbolic tangent of the argument.
constexpr tags::callable_atanpi	atanpi = {}
	Computes the arc tangent of the argument in \(\pi\) multiples.
constexpr tags::callable_average	average = {}
	Computes the average of the parameters.
constexpr tags::callable_beta	beta = {}
	Computes the beta function: \(\displaystyle \mathbf{B}(x, y) = \frac{\Gamma(x)\Gamma(y)}{\Gamma(x+y)}\) for real or complex entries.
constexpr tags::callable_ceil	ceil = {}
	Computes the ceil value.
constexpr tags::callable_commutator	commutator = {}
	Computes the commutator of the two parameters.
constexpr tags::callable_complex	complex = {}
	Constructs a kyosu::complex.
constexpr tags::callable_conj	conj = {}
	Computes the conjugate value.
constexpr tags::callable_convert	convert = {}
	convert to a target typek
constexpr tags::callable_cos	cos = {}
	Computes the cosine of the argument.
constexpr tags::callable_cosh	cosh = {}
	Computes the hyperbolic cosine of the argument.
constexpr tags::callable_cospi	cospi = {}
	Computes the cosine from the argument in \(\pi\) multiples.
constexpr tags::callable_cot	cot = {}
	Computes the cotangent of the argument.
constexpr tags::callable_coth	coth = {}
	Computes the hyperbolic cotangent of the argument.
constexpr tags::callable_cotpi	cotpi = {}
	Computes the cotangent from the argument in \(\pi\) multiples.
constexpr tags::callable_csc	csc = {}
	Computes the cosecant of the argument.
constexpr tags::callable_csch	csch = {}
	Computes the hyperbolic cosecant of the argument.
constexpr tags::callable_cscpi	cscpi = {}
	Computes the cosecant from the argument in \(\pi\) multiples.
constexpr tags::callable_cyl_bessel_h1	cyl_bessel_h1 = {}
	Computes the Bessel functions of the third kind \(H^{(1)}\),.
constexpr tags::callable_cyl_bessel_h12	cyl_bessel_h12 = {}
	Computes the Bessel functions of the third kind \( H^{(1)} \) and \( H^{(2)} \),.
constexpr tags::callable_cyl_bessel_h1_0	cyl_bessel_h1_0 = {}
	Computes the Bessel function of the third kind, \( H^{(1)}_0(x)\),.
constexpr tags::callable_cyl_bessel_h1_1	cyl_bessel_h1_1 = {}
	Computes the Bessel function of the third kind, \( H^{(1)}_1(x)\),.
constexpr tags::callable_cyl_bessel_h1n	cyl_bessel_h1n = {}
	Computes the Bessel/Hankel functions of the third kind, \( H_n^{(1)}(z) = J_n(z)+iY_n(z)\).
constexpr tags::callable_cyl_bessel_h2	cyl_bessel_h2 = {}
	Computes the Bessel functions of the third kind \( H^{(2)}_\nu \),.
constexpr tags::callable_cyl_bessel_h2_0	cyl_bessel_h2_0 = {}
	Computes the Bessel function of the third kind, \( H^{(2)}_0(x)\).
constexpr tags::callable_cyl_bessel_h2_1	cyl_bessel_h2_1 = {}
	Computes the Bessel function of the third kind, \( H^{(2)}_1(x)\),.
constexpr tags::callable_cyl_bessel_h2n	cyl_bessel_h2n = {}
	Computes the Bessel/Hankel functions of the third kind , \( H_n^{(2)} = J_n(z)-iY_n(z)\).
constexpr tags::callable_cyl_bessel_i	cyl_bessel_i = {}
	Computes the Modified Bessel functions of the first kind.
constexpr tags::callable_cyl_bessel_i0	cyl_bessel_i0 = {}
	Computes the modified Bessel function of the first kind \(I_{0}(x)=J_{0}(ix)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_i1	cyl_bessel_i1 = {}
	Computes the modified Bessel function of the first kind, \( I_1(x)= iJ_1(ix) \) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_ik	cyl_bessel_ik = {}
	Computes the modified Bessel functions \(I\) and \(K\),.
constexpr tags::callable_cyl_bessel_ikn	cyl_bessel_ikn = {}
	Computes the Bessel functions of the second kind \(I\) and \(K \)of integral order,.
constexpr tags::callable_cyl_bessel_in	cyl_bessel_in = {}
	Computes the modified Bessel functions of the first kind \(I_{n}(x)=i^{-n}J_{n }(ix)\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_j	cyl_bessel_j = {}
	Computes the Bessel functions of the first kind, \( J_{\nu}(x)=\sum_{p=0}^{\infty}{\frac{(-1)^p}{p!\,\Gamma (p+\nu +1)}} {\left({x \over 2}\right)}^{2p+\nu }\) extended to the complex plane and cayley_dickson values.
constexpr tags::callable_cyl_bessel_j0	cyl_bessel_j0 = {}
	Computes the Bessel function of the first kind, \( J_0(x)=\frac1{\pi }\int _{0}^{\pi}\cos(x\sin \tau) \,\mathrm {d} \tau \) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_j1	cyl_bessel_j1 = {}
	Computes the Bessel function of the first kind, \( J_1\).
constexpr tags::callable_cyl_bessel_jn	cyl_bessel_jn = {}
	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 }\) extended to the complex plane and cayley_dickson values.
constexpr tags::callable_cyl_bessel_k	cyl_bessel_k = {}
	Computes the Modified Bessel functions of the second kind.
constexpr tags::callable_cyl_bessel_k0	cyl_bessel_k0 = {}
	Computes the modified Bessel function of the second kind, \( K_0(x)=\lim_{\alpha\to 0}{\frac {\pi }{2}}{\frac {I_{-\alpha }(x)-I_{\alpha }(x)}{\sin \alpha \pi }}\). extended to the complex plane and cayley_dickson values.
constexpr tags::callable_cyl_bessel_k1	cyl_bessel_k1 = {}
	Computes the Bessel function of the second kind, \( K_1(x)\lim_{\alpha\to 1}{\frac {\pi }{2}}{\frac {I_{-\alpha }(x)-I_{\alpha }(x)}{\sin \alpha \pi }}\) extended to the complex plane and cayley_dickson values.
constexpr tags::callable_cyl_bessel_kn	cyl_bessel_kn = {}
	Computes the modified Bessel functions of the second kind, \( K_{n}(x)=\lim_{\alpha\to n}{\frac {\pi }{2}}{\frac {I_{-\alpha }(x)-I_{\alpha }(x)}{\sin \alpha \pi }}\). extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_y	cyl_bessel_y = {}
	Computes the Bessel functions of the second kind,.
constexpr tags::callable_cyl_bessel_y0	cyl_bessel_y0 = {}
	Computes the Bessel function of the second kind, \( Y_0(x)=\lim_{\alpha\to 0}{{\frac {J_{\alpha }(x)\cos(\alpha\pi)-J_{-\alpha }(x)}{\sin(\alpha\pi)}}}\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_y1	cyl_bessel_y1 = {}
	Computes the Bessel function of the second kind, \( Y_1(x)=\lim_{\alpha\to 1}{{\frac {J_{\alpha }(x)\cos(\alpha\pi)-J_{-\alpha }(x)}{\sin(\alpha\pi)}}}\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_cyl_bessel_yn	cyl_bessel_yn = {}
	Computes the modified Bessel functions of the second kind, \( Y_n(x)=\lim_{\alpha\to n}{{\frac {J_{\alpha }(x)\cos(\alpha\pi)-J_{-\alpha }(x)}{\sin(\alpha\pi)}}}\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_dec	dec = {}
	decrements the argument by 1.
constexpr tags::callable_deta	deta = {}
	Computes the Dirichlet sums \( \displaystyle \sum_{n = 0}^\infty \frac{(-1)^n}{(kn+1)^z}\).
constexpr tags::callable_digamma	digamma = {}
	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 tags::callable_dist	dist = {}
	Computes the distance between the two parameters.
constexpr tags::callable_dot	dot = {}
	Computes elementwise the dot product of the coordinates of the corresponding element.
constexpr tags::callable_erf	erf = {}
	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 tags::callable_erfcx	erfcx = {}
	Computes the normalized complementary error function \( \displaystyle \mbox{erfcx}(x) = e^{x^2} \mbox{erfc}(x)\).
constexpr tags::callable_erfi	erfi = {}
	Callable object computing The imaginary error function \( \displaystyle \mathrm{erfi}(z) = -i\mathrm{erf}(iz)\).
constexpr tags::callable_eta	eta = {}
	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 tags::callable_exp	exp = {}
	Computes the exponential of the argument.
constexpr tags::callable_exp10	exp10 = {}
	Computes the base 10 exponential of the argument.
constexpr tags::callable_exp2	exp2 = {}
	Computes the base 2 exponential of the argument.
constexpr tags::callable_exp_i	exp_i = {}
	Computes the exponential of i times the argument.
constexpr tags::callable_exp_ipi	exp_ipi = {}
	Computes the exponential of \(i\pi\) times the argument.
constexpr tags::callable_expm1	expm1 = {}
	Computes the exponential of the argument minus 1.
constexpr tags::callable_expmx2	expmx2 = {}
	Computes the exponential of the opposite of the squared argument.
constexpr tags::callable_expx2	expx2 = {}
	Computes the exponential of the squared argument.
constexpr tags::callable_faddeeva	faddeeva = {}
	Callable object computing \(e^{-z^2}\mathrm{erfc}(-iz)\) the scaled complex error func.
constexpr tags::callable_fam	fam = {}
	Computes fused add multiply.
constexpr tags::callable_floor	floor = {}
	Computes the floor value.
constexpr tags::callable_fma	fma = {}
	Computes fused multiply add.
constexpr tags::callable_fms	fms = {}
	Computes fused multiply add.
constexpr tags::callable_fnma	fnma = {}
	Computes fused negate multiply add.
constexpr tags::callable_fnms	fnms = {}
	Computes fused negate multiply sub.
constexpr tags::callable_frac	frac = {}
	Computes the frac value.
constexpr tags::callable_from_angle_axis	from_angle_axis = {}
	Callable object computing an an unitary quaternion from an angle value and a 3 dimensionnal axis vector.
constexpr tags::callable_from_cylindrical	from_cylindrical = {}
	Callable object computing a quaternion from its cylindrical representation.
constexpr tags::callable_from_cylindrospherical	from_cylindrospherical = {}
	Callable object computing a quaternion from its cylindrospherical representation.
constexpr tags::callable_from_euler	from_euler = {}
	Callable object computing a quaternion from its euler representation.
constexpr tags::callable_from_multipolar	from_multipolar = {}
	Callable object computing a quaternion from its multipolar representation.
constexpr tags::callable_from_polar	from_polar = {}
	Callable object computing a complex or a general Cayley-Dickson from a polar representation.
constexpr tags::callable_from_rotation_matrix	from_rotation_matrix = {}
	Callable object computing a quaternion from its rotation_matrix representation.
constexpr tags::callable_from_semipolar	from_semipolar = {}
	Callable object computing a quaternion from its semipolar representation.
constexpr tags::callable_from_spherical	from_spherical = {}
	Callable object computing a quaternion from its spherical representation.
constexpr tags::callable_fsm	fsm = {}
	Computes fused sub multiply.
constexpr tags::callable_horner	horner = {}
	Implement the horner scheme to evaluate polynomials.
constexpr tags::callable_hypot	hypot = {}
	Callable object computing the hypot operation.
constexpr tags::callable_i	i = {}
	Computes the complex number cinf i.e. complex(nan, inf) in the chosen type.
constexpr tags::callable_if_else	if_else = {}
	Select a value between two arguments based on a logical mask.
constexpr tags::callable_ipart	imag = {}
	Alias for ipart.
constexpr tags::callable_inc	inc = {}
	Increments the argument.
constexpr tags::callable_ipart	ipart = {}
	Extracts the imaginary part of a value.
constexpr tags::callable_is_denormal	is_denormal = {}
	test if the parameter is denormal.
constexpr tags::callable_is_equal	is_equal = {}
	retuen true if and only if the two parameters are equal.
constexpr tags::callable_is_eqz	is_eqz = {}
	test the parameter for equality to zero.
constexpr tags::callable_is_finite	is_finite = {}
	test if the parameter is finite.
constexpr tags::callable_is_pure	is_imag = {}
	alias of is_pure
constexpr tags::callable_is_infinite	is_infinite = {}
	test if the parameter is infinite.
constexpr tags::callable_is_nan	is_nan = {}
	test if the parameter is nan.
constexpr tags::callable_is_nez	is_nez = {}
	test the parameter for non zero equality.
constexpr tags::callable_is_not_denormal	is_not_denormal = {}
	test if the parameter is not denormal.
constexpr tags::callable_is_not_equal	is_not_equal = {}
	return true if and only if the two parameters are not equal.
constexpr tags::callable_is_not_finite	is_not_finite = {}
	test if the parameter is not finite.
constexpr tags::callable_is_not_infinite	is_not_infinite = {}
	test if the parameter is not infinite.
constexpr tags::callable_is_not_nan	is_not_nan = {}
	test if the parameter is not a Nan.
constexpr tags::callable_is_not_real	is_not_real = {}
	test if the parameter is not_real.
constexpr tags::callable_is_pure	is_pure = {}
	test if the parameter is pure.
constexpr tags::callable_is_real	is_real = {}
	test if the parameter is real.
constexpr tags::callable_is_unitary	is_unitary = {}
	test if the parameter is unitary (absolute value one).
constexpr tags::callable_jpart	jpart = {}
	Extracts the \(j\) part of a value.
constexpr tags::callable_kpart	kpart = {}
	Extracts the \(k\) part of a value.
constexpr tags::callable_lambda	lambda = {}
	Callable object computing The Dirichlet \( \displaystyle \lambda(z) = \sum_0^\infty \frac{1}{(2n+1)^z}\).
constexpr tags::callable_lbeta	lbeta = {}
	Computes the natural logarithm of the lbeta function.
constexpr tags::callable_ldiv	ldiv = {}
	Computes the left division of the two parameters.
constexpr tags::callable_lerp	lerp = {}
	Computes the linear interpolation.
constexpr tags::callable_lipart	lipart = {}
	Extracts the li (sixth) part of a value.
constexpr tags::callable_ljpart	ljpart = {}
	Extracts the lj (seventh) part of a value.
constexpr tags::callable_lkpart	lkpart = {}
	Extracts the lk (eighth) part of a value.
constexpr tags::callable_log	log = {}
	Computes the natural logarithm of the argument.
constexpr tags::callable_log10	log10 = {}
	Computes the base 10 logarithm of the argument.
constexpr tags::callable_log1p	log1p = {}
	Computes the natural logarithm of the argument plus 1.
constexpr tags::callable_log2	log2 = {}
	Computes the base 2 logarithm of the argument.
constexpr tags::callable_log_abs	log_abs = {}
	Computes the natural logarithm of the absolute value of the argument.
constexpr tags::callable_log_abs_gamma	log_abs_gamma = {}
	Computes the log of the modulus of the \(\Gamma\) function of the parameter.
constexpr tags::callable_log_gamma	log_gamma = {}
	Computes the log of the \(\Gamma\) function.
constexpr tags::callable_lpart	lpart = {}
	Extracts the l (fifth) part of a value.
constexpr tags::callable_lpnorm	lpnorm = {}
	Callable object computing the lpnorm operation \( \left(\sum_{i = 0}^n |x_i|^p\right)^{\frac1p} \).
constexpr tags::callable_lrising_factorial	lrising_factorial = {}
	Computes the lrising_factorial function: \(\log\frac{\Gamma(x+y)}{\Gamma(x)}\).
constexpr tags::callable_manhattan	manhattan = {}
	Callable object computing the manhattan operation.
constexpr tags::callable_maxabs	maxabs = {}
	Callable object computing the maxabs operation.
constexpr tags::callable_maxmag	maxmag = {}
	Callable object computing the maxmag operation.
constexpr tags::callable_minabs	minabs = {}
	Callable object computing the minabs operation.
constexpr tags::callable_minmag	minmag = {}
	Callable object computing the minmag operation.
constexpr tags::callable_minus	minus = {}
	Computes the opposite value.
constexpr tags::callable_muli	muli = {}
	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 tags::callable_mulmi	mulmi = {}
	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 tags::callable_nearest	nearest = {}
	Computes the nearest value.
constexpr tags::callable_negmaxabs	negmaxabs = {}
	Callable object computing the negmaxabs operation.
constexpr tags::callable_negminabs	negminabs = {}
	Callable object computing the negminabs operation.
constexpr tags::callable_oneminus	oneminus = {}
	Computes the value one minus the argument.
constexpr tags::callable_pow	pow = {}
	Computes the computing the pow operation \(x^y\).
constexpr tags::callable_pow1p	pow1p = {}
	Computes the computing the pow1p operation \((x+1)^y\).
constexpr tags::callable_pow_abs	pow_abs = {}
	Computes the computing the pow_abs operation \(|x|^y\).
constexpr tags::callable_powm1	powm1 = {}
	Computes the computing the powm1 operation \(x^y-1\).
constexpr tags::callable_proj	proj = {}
	Callable object computing proj(x), the projection of the cayley_dickson number z onto the (hyper) Riemann sphere.
constexpr tags::callable_pure	pure = {}
	Extracts the imaginary part of a value.
constexpr tags::callable_quaternion	quaternion = {}
	Constructs a kyosu::quaternion.
constexpr tags::callable_radinpi	radinpi = {}
	Computes the parameter divided by \(\pi\).
constexpr tags::callable_real	real = {}
	Extracts the real part of a value.
constexpr tags::callable_rec	rec = {}
	Computes the inverse of the argument.
constexpr tags::callable_reldist	reldist = {}
	Computes the relative distance between the two parameters.
constexpr tags::callable_reverse_horner	reverse_horner = {}
	Implement the reverse_horner scheme to evaluate polynomials.
constexpr tags::callable_right_horner	right_horner = {}
	Implement the right_horner scheme to evaluate polynomials.
constexpr tags::callable_right_reverse_horner	right_reverse_horner = {}
	Implement the right_reverse_horner scheme to evaluate polynomials.
constexpr tags::callable_rising_factorial	rising_factorial = {}
	Computes the rising_factorial function: \(\frac{\Gamma(x+y)}{\Gamma(x)}\).
constexpr tags::callable_rot_angle	rot_angle = {}
	Callable object computing the normalized angle of rotation defined by a quaternion.
constexpr tags::callable_rot_axis	rot_axis = {}
	Callable object computing the normalized axis of rotation defined by a quaternion.
constexpr tags::callable_rotate_vec	rotate_vec = {}
	Callable object rotating an \(\mathbb{R}^3\) vector using a quaternion.
constexpr tags::callable_sec	sec = {}
	Computes the secant of the argument.
constexpr tags::callable_sech	sech = {}
	Computes the hyperbolic secant of the argument.
constexpr tags::callable_secpi	secpi = {}
	Computes the secant of the argument in \(\pi\) multiples.
constexpr tags::callable_sign	sign = {}
	Computes tne normalized value z/abs(z) if z is not zero else 0.
constexpr tags::callable_sin	sin = {}
	Computes the sine of the argument.
constexpr tags::callable_sinc	sinc = {}
	Computes the sine cardinal of the argument.
constexpr tags::callable_sincos	sincos = {}
	Computes simultaneously the sine and cosine of the argument.
constexpr tags::callable_sinh	sinh = {}
	Computes the hyperbolic sine of the argument.
constexpr tags::callable_sinhc	sinhc = {}
	Computes the hyperbolic sine cardinal of the argument.
constexpr tags::callable_sinhcosh	sinhcosh = {}
	Computes simultaneously the hyperbolic sine and cosine of the argument.
constexpr tags::callable_sinpi	sinpi = {}
	Computes the sine of the argument in \(\pi\) multiples.
constexpr tags::callable_sinpicospi	sinpicospi = {}
	Computes simultaneously the sine and cosine of the argument in \(\pi\) multiples.
constexpr tags::callable_slerp	slerp = {}
	Computes the spherical interpolation between unitary quaternions.
constexpr tags::callable_sph_bessel_h1_0	sph_bessel_h1_0 = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_0^{(1)}(z) = j_1(z)+iy_1(z)\).
constexpr tags::callable_sph_bessel_h1_1	sph_bessel_h1_1 = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_1^{(1)}(z) = j_1(z)+iy_1(z)\).
constexpr tags::callable_sph_bessel_h1n	sph_bessel_h1n = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_n^{(1)}(z) = j_n(z)+iy_n(z)\).
constexpr tags::callable_sph_bessel_h2_0	sph_bessel_h2_0 = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_0^{(2)}(z) = j_0(z)-iy_0(z)\).
constexpr tags::callable_sph_bessel_h2_1	sph_bessel_h2_1 = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_1^{(2)}(z) = j_1(z)-iy_1(z)\).
constexpr tags::callable_sph_bessel_h2n	sph_bessel_h2n = {}
	Computes the spherical Bessel/hankel functions of the third kind, \( h_n^{(2)}(z) = j_n(z)-iy_n(z)\).
constexpr tags::callable_sph_bessel_i1_0	sph_bessel_i1_0 = {}
	Computes the Bessel function, \( i_0^{(1)}(z) = j_n(iz)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_i1_1	sph_bessel_i1_1 = {}
	Computes the Bessel function, \( i_1^{(1)}(z) = -i j_1(iz)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_i1n	sph_bessel_i1n = {}
	Computes the spherical Bessel functions \( i_n^{(1)}(z) = i^{-n}j_n(iz)\).
constexpr tags::callable_sph_bessel_i2_0	sph_bessel_i2_0 = {}
	Computes the Bessel function, \( i_0^{(2)}(z) = -i y_n(iz)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_i2_1	sph_bessel_i2_1 = {}
	Computes the Bessel function, \( i_1^{(2)}(z) = -y_1(iz)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_i2n	sph_bessel_i2n = {}
	Computes the spherical Bessel functions \( i_n^{(2)}(z) = i^{-n-1}y_n(iz)\).
constexpr tags::callable_sph_bessel_j0	sph_bessel_j0 = {}
	Computes the Bessel function of the first kind, \( j_0(x)=\sin z/z \) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_jn	sph_bessel_jn = {}
	Computes the spherical Bessel functions of the first kind \(j_{n}(x)\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_k0	sph_bessel_k0 = {}
	Computes the spherical Bessel function of the first kind, \( k_0(x)= \pi e^{-z}/(2z) \) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_k1	sph_bessel_k1 = {}
	Computes the spherical Bessel function of the first kind, \( k_1(x)= (\pi/2) e^{-z}(1/z+1/z^2)\) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_kn	sph_bessel_kn = {}
	Computes the spherical Bessel functions \(k_{n}(x)\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_y0	sph_bessel_y0 = {}
	Computes the spherical Bessel function of the first kind, \( y_0(x)=\cos z/z \) extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sph_bessel_yn	sph_bessel_yn = {}
	Computes the spherical Bessel functions of the first kind \(y_{n}(x)\), extended to the complex plane and cayley_dickson algebras.
constexpr tags::callable_sqr	sqr = {}
	Computes the square value.
constexpr tags::callable_sqr_abs	sqr_abs = {}
	Computes the squared absolute value of the parameter.
constexpr tags::callable_sqrt	sqrt = {}
	Computes a square root value.
constexpr tags::callable_tan	tan = {}
	Computes the tangent of the argument.
constexpr tags::callable_tanh	tanh = {}
	Computes the hyperbolic tangent of the argument.
constexpr tags::callable_tanpi	tanpi = {}
	Computes the tangent of the argument in \(\pi\) multiples.
constexpr tags::callable_tgamma	tgamma = {}
	Computes \(\Gamma(z)\)r.
constexpr tags::callable_to_angle_axis	to_angle_axis = {}
	Callable object computing the angle and axis coordinates from a quaternion.
constexpr tags::callable_to_cylindrical	to_cylindrical = {}
	Callable object computing the cylindrical coordinates from a quaternion.
constexpr tags::callable_to_cylindrospherical	to_cylindrospherical = {}
	Callable object computing the cylindrospherical coordinates from a quaternion.
constexpr tags::callable_to_euler	to_euler = {}
	Callable object computing euler angles from a quaternion.
constexpr tags::callable_to_multipolar	to_multipolar = {}
	Callable object computing the multipolar coordinates from a quaternion.
constexpr tags::callable_to_polar	to_polar = {}
	Callable object computing the polar coordinates from a complex.
constexpr tags::callable_to_rotation_matrix	to_rotation_matrix = {}
	Callable object computing a quaternion from its to_rotation_matrix representation.
constexpr tags::callable_to_semipolar	to_semipolar = {}
	Callable object computing the semipolar coordinates from a quaternion.
constexpr tags::callable_to_spherical	to_spherical = {}
	Callable object computing the spherical coordinates from a quaternion.
constexpr tags::callable_trunc	trunc = {}
	Computes the trunc value.
constexpr tags::callable_zeta	zeta = {}
	Computes the Riemann \( \displaystyle\zeta(z)=\sum_0^\infty \frac{1}{(n+1)^z}\).
constexpr tags::callable_airy	airy = {}
	Computes simultaneously the airy functions \(Ai\) and \(Bi\).