tlfloat Namespace Reference

TLFloat library defines all C++ classes and functions in tlfloat namespace. More...

Classes
class	BigInt
class	BigUInt
class	BigUInt< 6 >
class	TLFloat
struct	xpair

Typedefs
typedef TLFloat< detail::UnpackedFloat< uint16_t, uint32_t, 8, 7 > >	BFloat16
	This class represents a BFloat16 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.
typedef TLFloat< detail::UnpackedFloat< uint16_t, uint32_t, 5, 10 > >	Half
	This class represents a half-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.
typedef TLFloat< detail::UnpackedFloat< uint32_t, uint64_t, 8, 23 > >	Float
	This class represents a single-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.
typedef TLFloat< detail::UnpackedFloat< uint64_t, BigUInt< 7 >, 11, 52 > >	Double
	This class represents a double-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.
typedef TLFloat< detail::UnpackedFloat< BigUInt< 7 >, BigUInt< 8 >, 15, 112 > >	Quad
	This class represents a quadruple-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.
typedef TLFloat< detail::UnpackedFloat< BigUInt< 8 >, BigUInt< 9 >, 19, 236 > >	Octuple
	This class represents a octuple-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Functions
std::ostream &	operator<< (std::ostream &os, const BigUInt< 6 > &u)
template<int N>
std::string	to_string (const BigUInt< N > &u)
template<int N>
static std::ostream &	operator<< (std::ostream &os, const BigUInt< N > &u)
template<int N>
std::string	to_string (const BigInt< N > &i)
template<int N>
static std::ostream &	operator<< (std::ostream &os, const BigInt< N > &d)
static std::string	to_string (const float a, int d=6)
static std::string	to_string (const double a, int d=6)
static std::string	to_string (const tlfloat_quad &a, int d=6)
static std::string	to_string (const tlfloat_octuple &a, int d=6)
static std::string	to_string (const tlfloat_int128_t &a)
static std::string	to_string (const tlfloat_uint128_t &a)
static float	add_ (const float &x, const float &y)
static double	add_ (const double &x, const double &y)
static tlfloat_quad	add_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	add_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	sub_ (const float &x, const float &y)
static double	sub_ (const double &x, const double &y)
static tlfloat_quad	sub_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	sub_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	mul_ (const float &x, const float &y)
static double	mul_ (const double &x, const double &y)
static tlfloat_quad	mul_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	mul_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	div_ (const float &x, const float &y)
static double	div_ (const double &x, const double &y)
static tlfloat_quad	div_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	div_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	neg_ (const float &x)
static double	neg_ (const double &x)
static tlfloat_quad	neg_ (const tlfloat_quad &x)
static tlfloat_octuple	neg_ (const tlfloat_octuple &x)
static float	fma_ (const float &x, const float &y, const float &z)
static double	fma_ (const double &x, const double &y, const double &z)
static tlfloat_quad	fma_ (const tlfloat_quad &x, const tlfloat_quad &y, const tlfloat_quad &z)
static tlfloat_octuple	fma_ (const tlfloat_octuple &x, const tlfloat_octuple &y, const tlfloat_octuple &z)
static float	sqrt_ (const float &x)
static double	sqrt_ (const double &x)
static tlfloat_quad	sqrt_ (const tlfloat_quad &x)
static tlfloat_octuple	sqrt_ (const tlfloat_octuple &x)
static float	cbrt_ (const float &x)
static double	cbrt_ (const double &x)
static tlfloat_quad	cbrt_ (const tlfloat_quad &x)
static tlfloat_octuple	cbrt_ (const tlfloat_octuple &x)
static float	fabs_ (const float &x)
static double	fabs_ (const double &x)
static tlfloat_quad	fabs_ (const tlfloat_quad &x)
static tlfloat_octuple	fabs_ (const tlfloat_octuple &x)
static float	copysign_ (const float &x, const float &y)
static double	copysign_ (const double &x, const double &y)
static tlfloat_quad	copysign_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	copysign_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	fmax_ (const float &x, const float &y)
static double	fmax_ (const double &x, const double &y)
static tlfloat_quad	fmax_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	fmax_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	fmin_ (const float &x, const float &y)
static double	fmin_ (const double &x, const double &y)
static tlfloat_quad	fmin_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	fmin_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	fdim_ (const float &x, const float &y)
static double	fdim_ (const double &x, const double &y)
static tlfloat_quad	fdim_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	fdim_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	ldexp_ (const float &x, const int &y)
static double	ldexp_ (const double &x, const int &y)
static tlfloat_quad	ldexp_ (const tlfloat_quad &x, const int &y)
static tlfloat_octuple	ldexp_ (const tlfloat_octuple &x, const int &y)
static float	frexp_ (const float &x, int *y)
static double	frexp_ (const double &x, int *y)
static tlfloat_quad	frexp_ (const tlfloat_quad &x, int *y)
static tlfloat_octuple	frexp_ (const tlfloat_octuple &x, int *y)
static float	modf_ (const float &x, float *y)
static double	modf_ (const double &x, double *y)
static tlfloat_quad	modf_ (const tlfloat_quad &x, tlfloat_quad *y)
static tlfloat_octuple	modf_ (const tlfloat_octuple &x, tlfloat_octuple *y)
static float	nextafter_ (const float &x, const float &y)
static double	nextafter_ (const double &x, const double &y)
static tlfloat_quad	nextafter_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	nextafter_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static int	ilogb_ (const float &x)
static int	ilogb_ (const double &x)
static int	ilogb_ (const tlfloat_quad &x)
static int	ilogb_ (const tlfloat_octuple &x)
static int	isnan_ (const float &x)
static int	isnan_ (const double &x)
static int	isnan_ (const tlfloat_quad &x)
static int	isnan_ (const tlfloat_octuple &x)
static int	isinf_ (const float &x)
static int	isinf_ (const double &x)
static int	isinf_ (const tlfloat_quad &x)
static int	isinf_ (const tlfloat_octuple &x)
static int	finite_ (const float &x)
static int	finite_ (const double &x)
static int	finite_ (const tlfloat_quad &x)
static int	finite_ (const tlfloat_octuple &x)
static int	fpclassify_ (const float &x)
static int	fpclassify_ (const double &x)
static int	fpclassify_ (const tlfloat_quad &x)
static int	fpclassify_ (const tlfloat_octuple &x)
static int	signbit_ (const float &x)
static int	signbit_ (const double &x)
static int	signbit_ (const tlfloat_quad &x)
static int	signbit_ (const tlfloat_octuple &x)
static float	hypot_ (const float &x, const float &y)
static double	hypot_ (const double &x, const double &y)
static tlfloat_quad	hypot_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	hypot_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	trunc_ (const float &x)
static double	trunc_ (const double &x)
static tlfloat_quad	trunc_ (const tlfloat_quad &x)
static tlfloat_octuple	trunc_ (const tlfloat_octuple &x)
static float	floor_ (const float &x)
static double	floor_ (const double &x)
static tlfloat_quad	floor_ (const tlfloat_quad &x)
static tlfloat_octuple	floor_ (const tlfloat_octuple &x)
static float	ceil_ (const float &x)
static double	ceil_ (const double &x)
static tlfloat_quad	ceil_ (const tlfloat_quad &x)
static tlfloat_octuple	ceil_ (const tlfloat_octuple &x)
static float	round_ (const float &x)
static double	round_ (const double &x)
static tlfloat_quad	round_ (const tlfloat_quad &x)
static tlfloat_octuple	round_ (const tlfloat_octuple &x)
static float	rint_ (const float &x)
static double	rint_ (const double &x)
static tlfloat_quad	rint_ (const tlfloat_quad &x)
static tlfloat_octuple	rint_ (const tlfloat_octuple &x)
static float	sin_ (const float &x)
static double	sin_ (const double &x)
static tlfloat_quad	sin_ (const tlfloat_quad &x)
static tlfloat_octuple	sin_ (const tlfloat_octuple &x)
static float	cos_ (const float &x)
static double	cos_ (const double &x)
static tlfloat_quad	cos_ (const tlfloat_quad &x)
static tlfloat_octuple	cos_ (const tlfloat_octuple &x)
static float	tan_ (const float &x)
static double	tan_ (const double &x)
static tlfloat_quad	tan_ (const tlfloat_quad &x)
static tlfloat_octuple	tan_ (const tlfloat_octuple &x)
static float	sinpi_ (const float &x)
static double	sinpi_ (const double &x)
static tlfloat_quad	sinpi_ (const tlfloat_quad &x)
static tlfloat_octuple	sinpi_ (const tlfloat_octuple &x)
static float	cospi_ (const float &x)
static double	cospi_ (const double &x)
static tlfloat_quad	cospi_ (const tlfloat_quad &x)
static tlfloat_octuple	cospi_ (const tlfloat_octuple &x)
static float	tanpi_ (const float &x)
static double	tanpi_ (const double &x)
static tlfloat_quad	tanpi_ (const tlfloat_quad &x)
static tlfloat_octuple	tanpi_ (const tlfloat_octuple &x)
static float	asin_ (const float &x)
static double	asin_ (const double &x)
static tlfloat_quad	asin_ (const tlfloat_quad &x)
static tlfloat_octuple	asin_ (const tlfloat_octuple &x)
static float	acos_ (const float &x)
static double	acos_ (const double &x)
static tlfloat_quad	acos_ (const tlfloat_quad &x)
static tlfloat_octuple	acos_ (const tlfloat_octuple &x)
static float	atan_ (const float &x)
static double	atan_ (const double &x)
static tlfloat_quad	atan_ (const tlfloat_quad &x)
static tlfloat_octuple	atan_ (const tlfloat_octuple &x)
static float	atan2_ (const float &x, const float &y)
static double	atan2_ (const double &x, const double &y)
static tlfloat_quad	atan2_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	atan2_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	exp_ (const float &x)
static double	exp_ (const double &x)
static tlfloat_quad	exp_ (const tlfloat_quad &x)
static tlfloat_octuple	exp_ (const tlfloat_octuple &x)
static float	expm1_ (const float &x)
static double	expm1_ (const double &x)
static tlfloat_quad	expm1_ (const tlfloat_quad &x)
static tlfloat_octuple	expm1_ (const tlfloat_octuple &x)
static float	exp2_ (const float &x)
static double	exp2_ (const double &x)
static tlfloat_quad	exp2_ (const tlfloat_quad &x)
static tlfloat_octuple	exp2_ (const tlfloat_octuple &x)
static float	exp10_ (const float &x)
static double	exp10_ (const double &x)
static tlfloat_quad	exp10_ (const tlfloat_quad &x)
static tlfloat_octuple	exp10_ (const tlfloat_octuple &x)
static float	log_ (const float &x)
static double	log_ (const double &x)
static tlfloat_quad	log_ (const tlfloat_quad &x)
static tlfloat_octuple	log_ (const tlfloat_octuple &x)
static float	log1p_ (const float &x)
static double	log1p_ (const double &x)
static tlfloat_quad	log1p_ (const tlfloat_quad &x)
static tlfloat_octuple	log1p_ (const tlfloat_octuple &x)
static float	log2_ (const float &x)
static double	log2_ (const double &x)
static tlfloat_quad	log2_ (const tlfloat_quad &x)
static tlfloat_octuple	log2_ (const tlfloat_octuple &x)
static float	log10_ (const float &x)
static double	log10_ (const double &x)
static tlfloat_quad	log10_ (const tlfloat_quad &x)
static tlfloat_octuple	log10_ (const tlfloat_octuple &x)
static float	pow_ (const float &x, const float &y)
static double	pow_ (const double &x, const double &y)
static tlfloat_quad	pow_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	pow_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	sinh_ (const float &x)
static double	sinh_ (const double &x)
static tlfloat_quad	sinh_ (const tlfloat_quad &x)
static tlfloat_octuple	sinh_ (const tlfloat_octuple &x)
static float	cosh_ (const float &x)
static double	cosh_ (const double &x)
static tlfloat_quad	cosh_ (const tlfloat_quad &x)
static tlfloat_octuple	cosh_ (const tlfloat_octuple &x)
static float	tanh_ (const float &x)
static double	tanh_ (const double &x)
static tlfloat_quad	tanh_ (const tlfloat_quad &x)
static tlfloat_octuple	tanh_ (const tlfloat_octuple &x)
static float	asinh_ (const float &x)
static double	asinh_ (const double &x)
static tlfloat_quad	asinh_ (const tlfloat_quad &x)
static tlfloat_octuple	asinh_ (const tlfloat_octuple &x)
static float	acosh_ (const float &x)
static double	acosh_ (const double &x)
static tlfloat_quad	acosh_ (const tlfloat_quad &x)
static tlfloat_octuple	acosh_ (const tlfloat_octuple &x)
static float	atanh_ (const float &x)
static double	atanh_ (const double &x)
static tlfloat_quad	atanh_ (const tlfloat_quad &x)
static tlfloat_octuple	atanh_ (const tlfloat_octuple &x)
static float	fmod_ (const float &x, const float &y)
static double	fmod_ (const double &x, const double &y)
static tlfloat_quad	fmod_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	fmod_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	remainder_ (const float &x, const float &y)
static double	remainder_ (const double &x, const double &y)
static tlfloat_quad	remainder_ (const tlfloat_quad &x, const tlfloat_quad &y)
static tlfloat_octuple	remainder_ (const tlfloat_octuple &x, const tlfloat_octuple &y)
static float	remquo_ (const float &x, const float &y, int *z)
static double	remquo_ (const double &x, const double &y, int *z)
static tlfloat_quad	remquo_ (const tlfloat_quad &x, const tlfloat_quad &y, int *z)
static tlfloat_octuple	remquo_ (const tlfloat_octuple &x, const tlfloat_octuple &y, int *z)
static float	erf_ (const float &x)
static double	erf_ (const double &x)
static tlfloat_quad	erf_ (const tlfloat_quad &x)
static tlfloat_octuple	erf_ (const tlfloat_octuple &x)
static float	erfc_ (const float &x)
static double	erfc_ (const double &x)
static tlfloat_quad	erfc_ (const tlfloat_quad &x)
static tlfloat_octuple	erfc_ (const tlfloat_octuple &x)
static float	tgamma_ (const float &x)
static double	tgamma_ (const double &x)
static tlfloat_quad	tgamma_ (const tlfloat_quad &x)
static tlfloat_octuple	tgamma_ (const tlfloat_octuple &x)
static float	lgamma_ (const float &x)
static double	lgamma_ (const double &x)
static tlfloat_quad	lgamma_ (const tlfloat_quad &x)
static tlfloat_octuple	lgamma_ (const tlfloat_octuple &x)
template<typename Unpacked_t >
static std::string	to_string (TLFloat< Unpacked_t > a, int d=6)
template<typename Unpacked_t >
static std::ostream &	operator<< (std::ostream &os, const TLFloat< Unpacked_t > &a)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_PI (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_LOG2E (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_LOG10E (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_LN2 (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_LN10 (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_1_PI (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_1_SQRTPI (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_M_E (int exp=0)
template<typename tlfloat_t >
static consteval tlfloat_t	const_Euler ()
static constexpr Half	sin (const Half &a)
static constexpr Float	sin (const Float &a)
static constexpr Double	sin (const Double &a)
static constexpr Quad	sin (const Quad &a)
static constexpr Octuple	sin (const Octuple &a)
static constexpr Half	cos (const Half &a)
static constexpr Float	cos (const Float &a)
static constexpr Double	cos (const Double &a)
static constexpr Quad	cos (const Quad &a)
static constexpr Octuple	cos (const Octuple &a)
static constexpr Half	tan (const Half &a)
static constexpr Float	tan (const Float &a)
static constexpr Double	tan (const Double &a)
static constexpr Quad	tan (const Quad &a)
static constexpr Octuple	tan (const Octuple &a)
static constexpr Half	atan2 (const Half &y, const Half &x)
static constexpr Float	atan2 (const Float &y, const Float &x)
static constexpr Double	atan2 (const Double &y, const Double &x)
static constexpr Quad	atan2 (const Quad &y, const Quad &x)
static constexpr Octuple	atan2 (const Octuple &y, const Octuple &x)
static constexpr Half	asin (const Half &a)
static constexpr Float	asin (const Float &a)
static constexpr Double	asin (const Double &a)
static constexpr Quad	asin (const Quad &a)
static constexpr Octuple	asin (const Octuple &a)
static constexpr Half	acos (const Half &a)
static constexpr Float	acos (const Float &a)
static constexpr Double	acos (const Double &a)
static constexpr Quad	acos (const Quad &a)
static constexpr Octuple	acos (const Octuple &a)
static constexpr Half	atan (const Half &a)
static constexpr Float	atan (const Float &a)
static constexpr Double	atan (const Double &a)
static constexpr Quad	atan (const Quad &a)
static constexpr Octuple	atan (const Octuple &a)
static constexpr Half	exp (const Half &a)
static constexpr Float	exp (const Float &a)
static constexpr Double	exp (const Double &a)
static constexpr Quad	exp (const Quad &a)
static constexpr Octuple	exp (const Octuple &a)
static constexpr Half	expm1 (const Half &a)
static constexpr Float	expm1 (const Float &a)
static constexpr Double	expm1 (const Double &a)
static constexpr Quad	expm1 (const Quad &a)
static constexpr Octuple	expm1 (const Octuple &a)
static constexpr Half	exp2 (const Half &a)
static constexpr Float	exp2 (const Float &a)
static constexpr Double	exp2 (const Double &a)
static constexpr Quad	exp2 (const Quad &a)
static constexpr Octuple	exp2 (const Octuple &a)
static constexpr Half	exp10 (const Half &a)
static constexpr Float	exp10 (const Float &a)
static constexpr Double	exp10 (const Double &a)
static constexpr Quad	exp10 (const Quad &a)
static constexpr Octuple	exp10 (const Octuple &a)
static constexpr Half	log (const Half &a)
static constexpr Float	log (const Float &a)
static constexpr Double	log (const Double &a)
static constexpr Quad	log (const Quad &a)
static constexpr Octuple	log (const Octuple &a)
static constexpr Half	log1p (const Half &a)
static constexpr Float	log1p (const Float &a)
static constexpr Double	log1p (const Double &a)
static constexpr Quad	log1p (const Quad &a)
static constexpr Octuple	log1p (const Octuple &a)
static constexpr Half	log2 (const Half &a)
static constexpr Float	log2 (const Float &a)
static constexpr Double	log2 (const Double &a)
static constexpr Quad	log2 (const Quad &a)
static constexpr Octuple	log2 (const Octuple &a)
static constexpr Half	log10 (const Half &a)
static constexpr Float	log10 (const Float &a)
static constexpr Double	log10 (const Double &a)
static constexpr Quad	log10 (const Quad &a)
static constexpr Octuple	log10 (const Octuple &a)
static constexpr Half	pow (const Half &x, const Half &y)
static constexpr Float	pow (const Float &x, const Float &y)
static constexpr Double	pow (const Double &x, const Double &y)
static constexpr Quad	pow (const Quad &x, const Quad &y)
static constexpr Octuple	pow (const Octuple &x, const Octuple &y)
static constexpr Half	cbrt (const Half &a)
static constexpr Float	cbrt (const Float &a)
static constexpr Double	cbrt (const Double &a)
static constexpr Quad	cbrt (const Quad &a)
static constexpr Octuple	cbrt (const Octuple &a)
static constexpr Half	sinh (const Half &a)
static constexpr Float	sinh (const Float &a)
static constexpr Double	sinh (const Double &a)
static constexpr Quad	sinh (const Quad &a)
static constexpr Octuple	sinh (const Octuple &a)
static constexpr Half	cosh (const Half &a)
static constexpr Float	cosh (const Float &a)
static constexpr Double	cosh (const Double &a)
static constexpr Quad	cosh (const Quad &a)
static constexpr Octuple	cosh (const Octuple &a)
static constexpr Half	tanh (const Half &a)
static constexpr Float	tanh (const Float &a)
static constexpr Double	tanh (const Double &a)
static constexpr Quad	tanh (const Quad &a)
static constexpr Octuple	tanh (const Octuple &a)
static constexpr Half	asinh (const Half &a)
static constexpr Float	asinh (const Float &a)
static constexpr Double	asinh (const Double &a)
static constexpr Quad	asinh (const Quad &a)
static constexpr Octuple	asinh (const Octuple &a)
static constexpr Half	acosh (const Half &a)
static constexpr Float	acosh (const Float &a)
static constexpr Double	acosh (const Double &a)
static constexpr Quad	acosh (const Quad &a)
static constexpr Octuple	acosh (const Octuple &a)
static constexpr Half	atanh (const Half &a)
static constexpr Float	atanh (const Float &a)
static constexpr Double	atanh (const Double &a)
static constexpr Quad	atanh (const Quad &a)
static constexpr Octuple	atanh (const Octuple &a)
static constexpr Half	fmod (const Half &y, const Half &x)
static constexpr Float	fmod (const Float &y, const Float &x)
static constexpr Double	fmod (const Double &y, const Double &x)
static constexpr Quad	fmod (const Quad &y, const Quad &x)
static constexpr Octuple	fmod (const Octuple &y, const Octuple &x)
static constexpr Half	remainder (const Half &y, const Half &x)
static constexpr Float	remainder (const Float &y, const Float &x)
static constexpr Double	remainder (const Double &y, const Double &x)
static constexpr Quad	remainder (const Quad &y, const Quad &x)
static constexpr Octuple	remainder (const Octuple &y, const Octuple &x)
static constexpr xpair< Half, int64_t >	remquo (const Half &y, const Half &x)
static constexpr xpair< Float, int64_t >	remquo (const Float &y, const Float &x)
static constexpr xpair< Double, int64_t >	remquo (const Double &y, const Double &x)
static constexpr xpair< Quad, int64_t >	remquo (const Quad &y, const Quad &x)
static constexpr xpair< Octuple, int64_t >	remquo (const Octuple &y, const Octuple &x)
static constexpr Half	erf (const Half &x)
static constexpr Float	erf (const Float &x)
static constexpr Double	erf (const Double &x)
static constexpr Quad	erf (const Quad &x)
static constexpr Octuple	erf (const Octuple &x)
static constexpr Half	erfc (const Half &x)
static constexpr Float	erfc (const Float &x)
static constexpr Double	erfc (const Double &x)
static constexpr Quad	erfc (const Quad &x)
static constexpr Octuple	erfc (const Octuple &x)
static constexpr Half	tgamma (const Half &x)
static constexpr Float	tgamma (const Float &x)
static constexpr Double	tgamma (const Double &x)
static constexpr Quad	tgamma (const Quad &x)
static constexpr Octuple	tgamma (const Octuple &x)
static constexpr Half	lgamma (const Half &x, bool *sign=0)
static constexpr Float	lgamma (const Float &x, bool *sign=0)
static constexpr Double	lgamma (const Double &x, bool *sign=0)
static constexpr Quad	lgamma (const Quad &x, bool *sign=0)
static constexpr Octuple	lgamma (const Octuple &x, bool *sign=0)
static constexpr Half	sinpi (const Half &a)
static constexpr Float	sinpi (const Float &a)
static constexpr Double	sinpi (const Double &a)
static constexpr Quad	sinpi (const Quad &a)
static constexpr Octuple	sinpi (const Octuple &a)
static constexpr Half	cospi (const Half &a)
static constexpr Float	cospi (const Float &a)
static constexpr Double	cospi (const Double &a)
static constexpr Quad	cospi (const Quad &a)
static constexpr Octuple	cospi (const Octuple &a)
static constexpr Half	tanpi (const Half &a)
static constexpr Float	tanpi (const Float &a)
static constexpr Double	tanpi (const Double &a)
static constexpr Quad	tanpi (const Quad &a)
static constexpr Octuple	tanpi (const Octuple &a)

Detailed Description

TLFloat library defines all C++ classes and functions in tlfloat namespace.

Typedef Documentation

BFloat16

typedef TLFloat<detail::UnpackedFloat<uint16_t, uint32_t, 8, 7> > tlfloat::BFloat16

This class represents a BFloat16 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Double

typedef TLFloat<detail::UnpackedFloat<uint64_t, BigUInt<7>, 11, 52> > tlfloat::Double

This class represents a double-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Float

typedef TLFloat<detail::UnpackedFloat<uint32_t, uint64_t, 8, 23> > tlfloat::Float

This class represents a single-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Half

typedef TLFloat<detail::UnpackedFloat<uint16_t, uint32_t, 5, 10> > tlfloat::Half

This class represents a half-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Octuple

typedef TLFloat<detail::UnpackedFloat<BigUInt<8>, BigUInt<9>, 19, 236> > tlfloat::Octuple

This class represents a octuple-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Quad

typedef TLFloat<detail::UnpackedFloat<BigUInt<7>, BigUInt<8>, 15, 112> > tlfloat::Quad

This class represents a quadruple-precision IEEE 754 floating-point number. The data size and data structure of the objects are the same as the corresponding floating-point number.

Function Documentation

acos() [1/5]

static constexpr Double tlfloat::acos ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acos() [2/5]

static constexpr Float tlfloat::acos ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acos() [3/5]

static constexpr Half tlfloat::acos ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acos() [4/5]

static constexpr Octuple tlfloat::acos ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acos() [5/5]

static constexpr Quad tlfloat::acos ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acos_() [1/4]

static double tlfloat::acos_ ( const double &  x )

inlinestatic

acos_() [2/4]

static float tlfloat::acos_ ( const float &  x )

inlinestatic

acos_() [3/4]

static tlfloat_octuple tlfloat::acos_ ( const tlfloat_octuple &  x )

inlinestatic

acos_() [4/4]

static tlfloat_quad tlfloat::acos_ ( const tlfloat_quad &  x )

inlinestatic

acosh() [1/5]

static constexpr Double tlfloat::acosh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acosh() [2/5]

static constexpr Float tlfloat::acosh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acosh() [3/5]

static constexpr Half tlfloat::acosh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acosh() [4/5]

static constexpr Octuple tlfloat::acosh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acosh() [5/5]

static constexpr Quad tlfloat::acosh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

acosh_() [1/4]

static double tlfloat::acosh_ ( const double &  x )

inlinestatic

acosh_() [2/4]

static float tlfloat::acosh_ ( const float &  x )

inlinestatic

acosh_() [3/4]

static tlfloat_octuple tlfloat::acosh_ ( const tlfloat_octuple &  x )

inlinestatic

acosh_() [4/4]

static tlfloat_quad tlfloat::acosh_ ( const tlfloat_quad &  x )

inlinestatic

add_() [1/4]

static double tlfloat::add_ ( const double &  x, const double &  y  )

inlinestatic

add_() [2/4]

static float tlfloat::add_ ( const float &  x, const float &  y  )

inlinestatic

add_() [3/4]

static tlfloat_octuple tlfloat::add_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

add_() [4/4]

static tlfloat_quad tlfloat::add_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

asin() [1/5]

static constexpr Double tlfloat::asin ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asin() [2/5]

static constexpr Float tlfloat::asin ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asin() [3/5]

static constexpr Half tlfloat::asin ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asin() [4/5]

static constexpr Octuple tlfloat::asin ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asin() [5/5]

static constexpr Quad tlfloat::asin ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asin_() [1/4]

static double tlfloat::asin_ ( const double &  x )

inlinestatic

asin_() [2/4]

static float tlfloat::asin_ ( const float &  x )

inlinestatic

asin_() [3/4]

static tlfloat_octuple tlfloat::asin_ ( const tlfloat_octuple &  x )

inlinestatic

asin_() [4/4]

static tlfloat_quad tlfloat::asin_ ( const tlfloat_quad &  x )

inlinestatic

asinh() [1/5]

static constexpr Double tlfloat::asinh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asinh() [2/5]

static constexpr Float tlfloat::asinh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asinh() [3/5]

static constexpr Half tlfloat::asinh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asinh() [4/5]

static constexpr Octuple tlfloat::asinh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asinh() [5/5]

static constexpr Quad tlfloat::asinh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

asinh_() [1/4]

static double tlfloat::asinh_ ( const double &  x )

inlinestatic

asinh_() [2/4]

static float tlfloat::asinh_ ( const float &  x )

inlinestatic

asinh_() [3/4]

static tlfloat_octuple tlfloat::asinh_ ( const tlfloat_octuple &  x )

inlinestatic

asinh_() [4/4]

static tlfloat_quad tlfloat::asinh_ ( const tlfloat_quad &  x )

inlinestatic

atan() [1/5]

static constexpr Double tlfloat::atan ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan() [2/5]

static constexpr Float tlfloat::atan ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan() [3/5]

static constexpr Half tlfloat::atan ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan() [4/5]

static constexpr Octuple tlfloat::atan ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan() [5/5]

static constexpr Quad tlfloat::atan ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2() [1/5]

static constexpr Double tlfloat::atan2 ( const Double &  y, const Double &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2() [2/5]

static constexpr Float tlfloat::atan2 ( const Float &  y, const Float &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2() [3/5]

static constexpr Half tlfloat::atan2 ( const Half &  y, const Half &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2() [4/5]

static constexpr Octuple tlfloat::atan2 ( const Octuple &  y, const Octuple &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2() [5/5]

static constexpr Quad tlfloat::atan2 ( const Quad &  y, const Quad &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atan2_() [1/4]

static double tlfloat::atan2_ ( const double &  x, const double &  y  )

inlinestatic

atan2_() [2/4]

static float tlfloat::atan2_ ( const float &  x, const float &  y  )

inlinestatic

atan2_() [3/4]

static tlfloat_octuple tlfloat::atan2_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

atan2_() [4/4]

static tlfloat_quad tlfloat::atan2_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

atan_() [1/4]

static double tlfloat::atan_ ( const double &  x )

inlinestatic

atan_() [2/4]

static float tlfloat::atan_ ( const float &  x )

inlinestatic

atan_() [3/4]

static tlfloat_octuple tlfloat::atan_ ( const tlfloat_octuple &  x )

inlinestatic

atan_() [4/4]

static tlfloat_quad tlfloat::atan_ ( const tlfloat_quad &  x )

inlinestatic

atanh() [1/5]

static constexpr Double tlfloat::atanh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atanh() [2/5]

static constexpr Float tlfloat::atanh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atanh() [3/5]

static constexpr Half tlfloat::atanh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atanh() [4/5]

static constexpr Octuple tlfloat::atanh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atanh() [5/5]

static constexpr Quad tlfloat::atanh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

atanh_() [1/4]

static double tlfloat::atanh_ ( const double &  x )

inlinestatic

atanh_() [2/4]

static float tlfloat::atanh_ ( const float &  x )

inlinestatic

atanh_() [3/4]

static tlfloat_octuple tlfloat::atanh_ ( const tlfloat_octuple &  x )

inlinestatic

atanh_() [4/4]

static tlfloat_quad tlfloat::atanh_ ( const tlfloat_quad &  x )

inlinestatic

cbrt() [1/5]

static constexpr Double tlfloat::cbrt ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cbrt() [2/5]

static constexpr Float tlfloat::cbrt ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cbrt() [3/5]

static constexpr Half tlfloat::cbrt ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cbrt() [4/5]

static constexpr Octuple tlfloat::cbrt ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cbrt() [5/5]

static constexpr Quad tlfloat::cbrt ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cbrt_() [1/4]

static double tlfloat::cbrt_ ( const double &  x )

inlinestatic

cbrt_() [2/4]

static float tlfloat::cbrt_ ( const float &  x )

inlinestatic

cbrt_() [3/4]

static tlfloat_octuple tlfloat::cbrt_ ( const tlfloat_octuple &  x )

inlinestatic

cbrt_() [4/4]

static tlfloat_quad tlfloat::cbrt_ ( const tlfloat_quad &  x )

inlinestatic

ceil_() [1/4]

static double tlfloat::ceil_ ( const double &  x )

inlinestatic

ceil_() [2/4]

static float tlfloat::ceil_ ( const float &  x )

inlinestatic

ceil_() [3/4]

static tlfloat_octuple tlfloat::ceil_ ( const tlfloat_octuple &  x )

inlinestatic

ceil_() [4/4]

static tlfloat_quad tlfloat::ceil_ ( const tlfloat_quad &  x )

inlinestatic

const_Euler()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_Euler ( )

inlinestatic

Returns the Euler–Mascheroni constant

const_M_1_PI()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_1_PI ( int  exp = 0 )

inlinestatic

Returns 2^exp / PI

const_M_1_SQRTPI()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_1_SQRTPI ( int  exp = 0 )

inlinestatic

Returns 2^exp / sqrt(PI)

const_M_E()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_E ( int  exp = 0 )

inlinestatic

Returns 2^exp * E

const_M_LN10()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_LN10 ( int  exp = 0 )

inlinestatic

Returns 2^exp * log 10

const_M_LN2()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_LN2 ( int  exp = 0 )

inlinestatic

Returns 2^exp * log 2

const_M_LOG10E()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_LOG10E ( int  exp = 0 )

inlinestatic

Returns 2^exp * log_10 (e)

const_M_LOG2E()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_LOG2E ( int  exp = 0 )

inlinestatic

Returns 2^exp * log_2 (e)

const_M_PI()

template<typename tlfloat_t >

static consteval tlfloat_t tlfloat::const_M_PI ( int  exp = 0 )

inlinestatic

Returns 2^exp * PI

copysign_() [1/4]

static double tlfloat::copysign_ ( const double &  x, const double &  y  )

inlinestatic

copysign_() [2/4]

static float tlfloat::copysign_ ( const float &  x, const float &  y  )

inlinestatic

copysign_() [3/4]

static tlfloat_octuple tlfloat::copysign_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

copysign_() [4/4]

static tlfloat_quad tlfloat::copysign_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

cos() [1/5]

static constexpr Double tlfloat::cos ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cos() [2/5]

static constexpr Float tlfloat::cos ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cos() [3/5]

static constexpr Half tlfloat::cos ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cos() [4/5]

static constexpr Octuple tlfloat::cos ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cos() [5/5]

static constexpr Quad tlfloat::cos ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cos_() [1/4]

static double tlfloat::cos_ ( const double &  x )

inlinestatic

cos_() [2/4]

static float tlfloat::cos_ ( const float &  x )

inlinestatic

cos_() [3/4]

static tlfloat_octuple tlfloat::cos_ ( const tlfloat_octuple &  x )

inlinestatic

cos_() [4/4]

static tlfloat_quad tlfloat::cos_ ( const tlfloat_quad &  x )

inlinestatic

cosh() [1/5]

static constexpr Double tlfloat::cosh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cosh() [2/5]

static constexpr Float tlfloat::cosh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cosh() [3/5]

static constexpr Half tlfloat::cosh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cosh() [4/5]

static constexpr Octuple tlfloat::cosh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cosh() [5/5]

static constexpr Quad tlfloat::cosh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

cosh_() [1/4]

static double tlfloat::cosh_ ( const double &  x )

inlinestatic

cosh_() [2/4]

static float tlfloat::cosh_ ( const float &  x )

inlinestatic

cosh_() [3/4]

static tlfloat_octuple tlfloat::cosh_ ( const tlfloat_octuple &  x )

inlinestatic

cosh_() [4/4]

static tlfloat_quad tlfloat::cosh_ ( const tlfloat_quad &  x )

inlinestatic

cospi() [1/5]

static constexpr Double tlfloat::cospi ( const Double &  a )

inlinestaticconstexpr

This function returns cos(PI * x). The accuracy of the return value is 1ULP.

cospi() [2/5]

static constexpr Float tlfloat::cospi ( const Float &  a )

inlinestaticconstexpr

This function returns cos(PI * x). The accuracy of the return value is 1ULP.

cospi() [3/5]

static constexpr Half tlfloat::cospi ( const Half &  a )

inlinestaticconstexpr

This function returns cos(PI * x). The accuracy of the return value is 1ULP.

cospi() [4/5]

static constexpr Octuple tlfloat::cospi ( const Octuple &  a )

inlinestaticconstexpr

This function returns cos(PI * x). The accuracy of the return value is 1ULP.

cospi() [5/5]

static constexpr Quad tlfloat::cospi ( const Quad &  a )

inlinestaticconstexpr

This function returns cos(PI * x). The accuracy of the return value is 1ULP.

cospi_() [1/4]

static double tlfloat::cospi_ ( const double &  x )

inlinestatic

cospi_() [2/4]

static float tlfloat::cospi_ ( const float &  x )

inlinestatic

cospi_() [3/4]

static tlfloat_octuple tlfloat::cospi_ ( const tlfloat_octuple &  x )

inlinestatic

cospi_() [4/4]

static tlfloat_quad tlfloat::cospi_ ( const tlfloat_quad &  x )

inlinestatic

div_() [1/4]

static double tlfloat::div_ ( const double &  x, const double &  y  )

inlinestatic

div_() [2/4]

static float tlfloat::div_ ( const float &  x, const float &  y  )

inlinestatic

div_() [3/4]

static tlfloat_octuple tlfloat::div_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

div_() [4/4]

static tlfloat_quad tlfloat::div_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

erf() [1/5]

static constexpr Double tlfloat::erf ( const Double &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erf() [2/5]

static constexpr Float tlfloat::erf ( const Float &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erf() [3/5]

static constexpr Half tlfloat::erf ( const Half &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erf() [4/5]

static constexpr Octuple tlfloat::erf ( const Octuple &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erf() [5/5]

static constexpr Quad tlfloat::erf ( const Quad &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erf_() [1/4]

static double tlfloat::erf_ ( const double &  x )

inlinestatic

erf_() [2/4]

static float tlfloat::erf_ ( const float &  x )

inlinestatic

erf_() [3/4]

static tlfloat_octuple tlfloat::erf_ ( const tlfloat_octuple &  x )

inlinestatic

erf_() [4/4]

static tlfloat_quad tlfloat::erf_ ( const tlfloat_quad &  x )

inlinestatic

erfc() [1/5]

static constexpr Double tlfloat::erfc ( const Double &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erfc() [2/5]

static constexpr Float tlfloat::erfc ( const Float &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erfc() [3/5]

static constexpr Half tlfloat::erfc ( const Half &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erfc() [4/5]

static constexpr Octuple tlfloat::erfc ( const Octuple &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erfc() [5/5]

static constexpr Quad tlfloat::erfc ( const Quad &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

erfc_() [1/4]

static double tlfloat::erfc_ ( const double &  x )

inlinestatic

erfc_() [2/4]

static float tlfloat::erfc_ ( const float &  x )

inlinestatic

erfc_() [3/4]

static tlfloat_octuple tlfloat::erfc_ ( const tlfloat_octuple &  x )

inlinestatic

erfc_() [4/4]

static tlfloat_quad tlfloat::erfc_ ( const tlfloat_quad &  x )

inlinestatic

exp() [1/5]

static constexpr Double tlfloat::exp ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp() [2/5]

static constexpr Float tlfloat::exp ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp() [3/5]

static constexpr Half tlfloat::exp ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp() [4/5]

static constexpr Octuple tlfloat::exp ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp() [5/5]

static constexpr Quad tlfloat::exp ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10() [1/5]

static constexpr Double tlfloat::exp10 ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10() [2/5]

static constexpr Float tlfloat::exp10 ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10() [3/5]

static constexpr Half tlfloat::exp10 ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10() [4/5]

static constexpr Octuple tlfloat::exp10 ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10() [5/5]

static constexpr Quad tlfloat::exp10 ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp10_() [1/4]

static double tlfloat::exp10_ ( const double &  x )

inlinestatic

exp10_() [2/4]

static float tlfloat::exp10_ ( const float &  x )

inlinestatic

exp10_() [3/4]

static tlfloat_octuple tlfloat::exp10_ ( const tlfloat_octuple &  x )

inlinestatic

exp10_() [4/4]

static tlfloat_quad tlfloat::exp10_ ( const tlfloat_quad &  x )

inlinestatic

exp2() [1/5]

static constexpr Double tlfloat::exp2 ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp2() [2/5]

static constexpr Float tlfloat::exp2 ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp2() [3/5]

static constexpr Half tlfloat::exp2 ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp2() [4/5]

static constexpr Octuple tlfloat::exp2 ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp2() [5/5]

static constexpr Quad tlfloat::exp2 ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

exp2_() [1/4]

static double tlfloat::exp2_ ( const double &  x )

inlinestatic

exp2_() [2/4]

static float tlfloat::exp2_ ( const float &  x )

inlinestatic

exp2_() [3/4]

static tlfloat_octuple tlfloat::exp2_ ( const tlfloat_octuple &  x )

inlinestatic

exp2_() [4/4]

static tlfloat_quad tlfloat::exp2_ ( const tlfloat_quad &  x )

inlinestatic

exp_() [1/4]

static double tlfloat::exp_ ( const double &  x )

inlinestatic

exp_() [2/4]

static float tlfloat::exp_ ( const float &  x )

inlinestatic

exp_() [3/4]

static tlfloat_octuple tlfloat::exp_ ( const tlfloat_octuple &  x )

inlinestatic

exp_() [4/4]

static tlfloat_quad tlfloat::exp_ ( const tlfloat_quad &  x )

inlinestatic

expm1() [1/5]

static constexpr Double tlfloat::expm1 ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

expm1() [2/5]

static constexpr Float tlfloat::expm1 ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

expm1() [3/5]

static constexpr Half tlfloat::expm1 ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

expm1() [4/5]

static constexpr Octuple tlfloat::expm1 ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

expm1() [5/5]

static constexpr Quad tlfloat::expm1 ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

expm1_() [1/4]

static double tlfloat::expm1_ ( const double &  x )

inlinestatic

expm1_() [2/4]

static float tlfloat::expm1_ ( const float &  x )

inlinestatic

expm1_() [3/4]

static tlfloat_octuple tlfloat::expm1_ ( const tlfloat_octuple &  x )

inlinestatic

expm1_() [4/4]

static tlfloat_quad tlfloat::expm1_ ( const tlfloat_quad &  x )

inlinestatic

fabs_() [1/4]

static double tlfloat::fabs_ ( const double &  x )

inlinestatic

fabs_() [2/4]

static float tlfloat::fabs_ ( const float &  x )

inlinestatic

fabs_() [3/4]

static tlfloat_octuple tlfloat::fabs_ ( const tlfloat_octuple &  x )

inlinestatic

fabs_() [4/4]

static tlfloat_quad tlfloat::fabs_ ( const tlfloat_quad &  x )

inlinestatic

fdim_() [1/4]

static double tlfloat::fdim_ ( const double &  x, const double &  y  )

inlinestatic

fdim_() [2/4]

static float tlfloat::fdim_ ( const float &  x, const float &  y  )

inlinestatic

fdim_() [3/4]

static tlfloat_octuple tlfloat::fdim_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

fdim_() [4/4]

static tlfloat_quad tlfloat::fdim_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

finite_() [1/4]

static int tlfloat::finite_ ( const double &  x )

inlinestatic

finite_() [2/4]

static int tlfloat::finite_ ( const float &  x )

inlinestatic

finite_() [3/4]

static int tlfloat::finite_ ( const tlfloat_octuple &  x )

inlinestatic

finite_() [4/4]

static int tlfloat::finite_ ( const tlfloat_quad &  x )

inlinestatic

floor_() [1/4]

static double tlfloat::floor_ ( const double &  x )

inlinestatic

floor_() [2/4]

static float tlfloat::floor_ ( const float &  x )

inlinestatic

floor_() [3/4]

static tlfloat_octuple tlfloat::floor_ ( const tlfloat_octuple &  x )

inlinestatic

floor_() [4/4]

static tlfloat_quad tlfloat::floor_ ( const tlfloat_quad &  x )

inlinestatic

fma_() [1/4]

static double tlfloat::fma_ ( const double &  x, const double &  y, const double &  z  )

inlinestatic

fma_() [2/4]

static float tlfloat::fma_ ( const float &  x, const float &  y, const float &  z  )

inlinestatic

fma_() [3/4]

static tlfloat_octuple tlfloat::fma_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y, const tlfloat_octuple &  z  )

inlinestatic

fma_() [4/4]

static tlfloat_quad tlfloat::fma_ ( const tlfloat_quad &  x, const tlfloat_quad &  y, const tlfloat_quad &  z  )

inlinestatic

fmax_() [1/4]

static double tlfloat::fmax_ ( const double &  x, const double &  y  )

inlinestatic

fmax_() [2/4]

static float tlfloat::fmax_ ( const float &  x, const float &  y  )

inlinestatic

fmax_() [3/4]

static tlfloat_octuple tlfloat::fmax_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

fmax_() [4/4]

static tlfloat_quad tlfloat::fmax_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

fmin_() [1/4]

static double tlfloat::fmin_ ( const double &  x, const double &  y  )

inlinestatic

fmin_() [2/4]

static float tlfloat::fmin_ ( const float &  x, const float &  y  )

inlinestatic

fmin_() [3/4]

static tlfloat_octuple tlfloat::fmin_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

fmin_() [4/4]

static tlfloat_quad tlfloat::fmin_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

fmod() [1/5]

static constexpr Double tlfloat::fmod ( const Double &  y, const Double &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

fmod() [2/5]

static constexpr Float tlfloat::fmod ( const Float &  y, const Float &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

fmod() [3/5]

static constexpr Half tlfloat::fmod ( const Half &  y, const Half &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

fmod() [4/5]

static constexpr Octuple tlfloat::fmod ( const Octuple &  y, const Octuple &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

fmod() [5/5]

static constexpr Quad tlfloat::fmod ( const Quad &  y, const Quad &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

fmod_() [1/4]

static double tlfloat::fmod_ ( const double &  x, const double &  y  )

inlinestatic

fmod_() [2/4]

static float tlfloat::fmod_ ( const float &  x, const float &  y  )

inlinestatic

fmod_() [3/4]

static tlfloat_octuple tlfloat::fmod_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

fmod_() [4/4]

static tlfloat_quad tlfloat::fmod_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

fpclassify_() [1/4]

static int tlfloat::fpclassify_ ( const double &  x )

inlinestatic

fpclassify_() [2/4]

static int tlfloat::fpclassify_ ( const float &  x )

inlinestatic

fpclassify_() [3/4]

static int tlfloat::fpclassify_ ( const tlfloat_octuple &  x )

inlinestatic

fpclassify_() [4/4]

static int tlfloat::fpclassify_ ( const tlfloat_quad &  x )

inlinestatic

frexp_() [1/4]

static double tlfloat::frexp_ ( const double &  x, int *  y  )

inlinestatic

frexp_() [2/4]

static float tlfloat::frexp_ ( const float &  x, int *  y  )

inlinestatic

frexp_() [3/4]

static tlfloat_octuple tlfloat::frexp_ ( const tlfloat_octuple &  x, int *  y  )

inlinestatic

frexp_() [4/4]

static tlfloat_quad tlfloat::frexp_ ( const tlfloat_quad &  x, int *  y  )

inlinestatic

hypot_() [1/4]

static double tlfloat::hypot_ ( const double &  x, const double &  y  )

inlinestatic

hypot_() [2/4]

static float tlfloat::hypot_ ( const float &  x, const float &  y  )

inlinestatic

hypot_() [3/4]

static tlfloat_octuple tlfloat::hypot_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

hypot_() [4/4]

static tlfloat_quad tlfloat::hypot_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

ilogb_() [1/4]

static int tlfloat::ilogb_ ( const double &  x )

inlinestatic

ilogb_() [2/4]

static int tlfloat::ilogb_ ( const float &  x )

inlinestatic

ilogb_() [3/4]

static int tlfloat::ilogb_ ( const tlfloat_octuple &  x )

inlinestatic

ilogb_() [4/4]

static int tlfloat::ilogb_ ( const tlfloat_quad &  x )

inlinestatic

isinf_() [1/4]

static int tlfloat::isinf_ ( const double &  x )

inlinestatic

isinf_() [2/4]

static int tlfloat::isinf_ ( const float &  x )

inlinestatic

isinf_() [3/4]

static int tlfloat::isinf_ ( const tlfloat_octuple &  x )

inlinestatic

isinf_() [4/4]

static int tlfloat::isinf_ ( const tlfloat_quad &  x )

inlinestatic

isnan_() [1/4]

static int tlfloat::isnan_ ( const double &  x )

inlinestatic

isnan_() [2/4]

static int tlfloat::isnan_ ( const float &  x )

inlinestatic

isnan_() [3/4]

static int tlfloat::isnan_ ( const tlfloat_octuple &  x )

inlinestatic

isnan_() [4/4]

static int tlfloat::isnan_ ( const tlfloat_quad &  x )

inlinestatic

ldexp_() [1/4]

static double tlfloat::ldexp_ ( const double &  x, const int &  y  )

inlinestatic

ldexp_() [2/4]

static float tlfloat::ldexp_ ( const float &  x, const int &  y  )

inlinestatic

ldexp_() [3/4]

static tlfloat_octuple tlfloat::ldexp_ ( const tlfloat_octuple &  x, const int &  y  )

inlinestatic

ldexp_() [4/4]

static tlfloat_quad tlfloat::ldexp_ ( const tlfloat_quad &  x, const int &  y  )

inlinestatic

lgamma() [1/5]

static constexpr Double tlfloat::lgamma ( const Double &  x, bool *  sign = 0  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This implementation is experimental and has no error bound.

lgamma() [2/5]

static constexpr Float tlfloat::lgamma ( const Float &  x, bool *  sign = 0  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This implementation is experimental and has no error bound.

lgamma() [3/5]

static constexpr Half tlfloat::lgamma ( const Half &  x, bool *  sign = 0  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This implementation is experimental and has no error bound.

lgamma() [4/5]

static constexpr Octuple tlfloat::lgamma ( const Octuple &  x, bool *  sign = 0  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This implementation is experimental and has no error bound.

lgamma() [5/5]

static constexpr Quad tlfloat::lgamma ( const Quad &  x, bool *  sign = 0  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This implementation is experimental and has no error bound.

lgamma_() [1/4]

static double tlfloat::lgamma_ ( const double &  x )

inlinestatic

lgamma_() [2/4]

static float tlfloat::lgamma_ ( const float &  x )

inlinestatic

lgamma_() [3/4]

static tlfloat_octuple tlfloat::lgamma_ ( const tlfloat_octuple &  x )

inlinestatic

lgamma_() [4/4]

static tlfloat_quad tlfloat::lgamma_ ( const tlfloat_quad &  x )

inlinestatic

log() [1/5]

static constexpr Double tlfloat::log ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log() [2/5]

static constexpr Float tlfloat::log ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log() [3/5]

static constexpr Half tlfloat::log ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log() [4/5]

static constexpr Octuple tlfloat::log ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log() [5/5]

static constexpr Quad tlfloat::log ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10() [1/5]

static constexpr Double tlfloat::log10 ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10() [2/5]

static constexpr Float tlfloat::log10 ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10() [3/5]

static constexpr Half tlfloat::log10 ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10() [4/5]

static constexpr Octuple tlfloat::log10 ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10() [5/5]

static constexpr Quad tlfloat::log10 ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log10_() [1/4]

static double tlfloat::log10_ ( const double &  x )

inlinestatic

log10_() [2/4]

static float tlfloat::log10_ ( const float &  x )

inlinestatic

log10_() [3/4]

static tlfloat_octuple tlfloat::log10_ ( const tlfloat_octuple &  x )

inlinestatic

log10_() [4/4]

static tlfloat_quad tlfloat::log10_ ( const tlfloat_quad &  x )

inlinestatic

log1p() [1/5]

static constexpr Double tlfloat::log1p ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log1p() [2/5]

static constexpr Float tlfloat::log1p ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log1p() [3/5]

static constexpr Half tlfloat::log1p ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log1p() [4/5]

static constexpr Octuple tlfloat::log1p ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log1p() [5/5]

static constexpr Quad tlfloat::log1p ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log1p_() [1/4]

static double tlfloat::log1p_ ( const double &  x )

inlinestatic

log1p_() [2/4]

static float tlfloat::log1p_ ( const float &  x )

inlinestatic

log1p_() [3/4]

static tlfloat_octuple tlfloat::log1p_ ( const tlfloat_octuple &  x )

inlinestatic

log1p_() [4/4]

static tlfloat_quad tlfloat::log1p_ ( const tlfloat_quad &  x )

inlinestatic

log2() [1/5]

static constexpr Double tlfloat::log2 ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log2() [2/5]

static constexpr Float tlfloat::log2 ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log2() [3/5]

static constexpr Half tlfloat::log2 ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log2() [4/5]

static constexpr Octuple tlfloat::log2 ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log2() [5/5]

static constexpr Quad tlfloat::log2 ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

log2_() [1/4]

static double tlfloat::log2_ ( const double &  x )

inlinestatic

log2_() [2/4]

static float tlfloat::log2_ ( const float &  x )

inlinestatic

log2_() [3/4]

static tlfloat_octuple tlfloat::log2_ ( const tlfloat_octuple &  x )

inlinestatic

log2_() [4/4]

static tlfloat_quad tlfloat::log2_ ( const tlfloat_quad &  x )

inlinestatic

log_() [1/4]

static double tlfloat::log_ ( const double &  x )

inlinestatic

log_() [2/4]

static float tlfloat::log_ ( const float &  x )

inlinestatic

log_() [3/4]

static tlfloat_octuple tlfloat::log_ ( const tlfloat_octuple &  x )

inlinestatic

log_() [4/4]

static tlfloat_quad tlfloat::log_ ( const tlfloat_quad &  x )

inlinestatic

modf_() [1/4]

static double tlfloat::modf_ ( const double &  x, double *  y  )

inlinestatic

modf_() [2/4]

static float tlfloat::modf_ ( const float &  x, float *  y  )

inlinestatic

modf_() [3/4]

static tlfloat_octuple tlfloat::modf_ ( const tlfloat_octuple &  x, tlfloat_octuple *  y  )

inlinestatic

modf_() [4/4]

static tlfloat_quad tlfloat::modf_ ( const tlfloat_quad &  x, tlfloat_quad *  y  )

inlinestatic

mul_() [1/4]

static double tlfloat::mul_ ( const double &  x, const double &  y  )

inlinestatic

mul_() [2/4]

static float tlfloat::mul_ ( const float &  x, const float &  y  )

inlinestatic

mul_() [3/4]

static tlfloat_octuple tlfloat::mul_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

mul_() [4/4]

static tlfloat_quad tlfloat::mul_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

neg_() [1/4]

static double tlfloat::neg_ ( const double &  x )

inlinestatic

neg_() [2/4]

static float tlfloat::neg_ ( const float &  x )

inlinestatic

neg_() [3/4]

static tlfloat_octuple tlfloat::neg_ ( const tlfloat_octuple &  x )

inlinestatic

neg_() [4/4]

static tlfloat_quad tlfloat::neg_ ( const tlfloat_quad &  x )

inlinestatic

nextafter_() [1/4]

static double tlfloat::nextafter_ ( const double &  x, const double &  y  )

inlinestatic

nextafter_() [2/4]

static float tlfloat::nextafter_ ( const float &  x, const float &  y  )

inlinestatic

nextafter_() [3/4]

static tlfloat_octuple tlfloat::nextafter_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

nextafter_() [4/4]

static tlfloat_quad tlfloat::nextafter_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

operator<<() [1/4]

template<int N>

static std::ostream & tlfloat::operator<< ( std::ostream &  os, const BigInt< N > &  d  )

static

operator<<() [2/4]

std::ostream & tlfloat::operator<< ( std::ostream &  os, const BigUInt< 6 > &  u  )

inline

operator<<() [3/4]

template<int N>

static std::ostream & tlfloat::operator<< ( std::ostream &  os, const BigUInt< N > &  u  )

static

operator<<() [4/4]

template<typename Unpacked_t >

static std::ostream & tlfloat::operator<< ( std::ostream &  os, const TLFloat< Unpacked_t > &  a  )

static

pow() [1/5]

static constexpr Double tlfloat::pow ( const Double &  x, const Double &  y  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

pow() [2/5]

static constexpr Float tlfloat::pow ( const Float &  x, const Float &  y  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

pow() [3/5]

static constexpr Half tlfloat::pow ( const Half &  x, const Half &  y  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

pow() [4/5]

static constexpr Octuple tlfloat::pow ( const Octuple &  x, const Octuple &  y  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

pow() [5/5]

static constexpr Quad tlfloat::pow ( const Quad &  x, const Quad &  y  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

pow_() [1/4]

static double tlfloat::pow_ ( const double &  x, const double &  y  )

inlinestatic

pow_() [2/4]

static float tlfloat::pow_ ( const float &  x, const float &  y  )

inlinestatic

pow_() [3/4]

static tlfloat_octuple tlfloat::pow_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

pow_() [4/4]

static tlfloat_quad tlfloat::pow_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

remainder() [1/5]

static constexpr Double tlfloat::remainder ( const Double &  y, const Double &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remainder() [2/5]

static constexpr Float tlfloat::remainder ( const Float &  y, const Float &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remainder() [3/5]

static constexpr Half tlfloat::remainder ( const Half &  y, const Half &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remainder() [4/5]

static constexpr Octuple tlfloat::remainder ( const Octuple &  y, const Octuple &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remainder() [5/5]

static constexpr Quad tlfloat::remainder ( const Quad &  y, const Quad &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remainder_() [1/4]

static double tlfloat::remainder_ ( const double &  x, const double &  y  )

inlinestatic

remainder_() [2/4]

static float tlfloat::remainder_ ( const float &  x, const float &  y  )

inlinestatic

remainder_() [3/4]

static tlfloat_octuple tlfloat::remainder_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

remainder_() [4/4]

static tlfloat_quad tlfloat::remainder_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

remquo() [1/5]

static constexpr xpair< Double, int64_t > tlfloat::remquo ( const Double &  y, const Double &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remquo() [2/5]

static constexpr xpair< Float, int64_t > tlfloat::remquo ( const Float &  y, const Float &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remquo() [3/5]

static constexpr xpair< Half, int64_t > tlfloat::remquo ( const Half &  y, const Half &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remquo() [4/5]

static constexpr xpair< Octuple, int64_t > tlfloat::remquo ( const Octuple &  y, const Octuple &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remquo() [5/5]

static constexpr xpair< Quad, int64_t > tlfloat::remquo ( const Quad &  y, const Quad &  x  )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. This function returns correctly rounded results.

remquo_() [1/4]

static double tlfloat::remquo_ ( const double &  x, const double &  y, int *  z  )

inlinestatic

remquo_() [2/4]

static float tlfloat::remquo_ ( const float &  x, const float &  y, int *  z  )

inlinestatic

remquo_() [3/4]

static tlfloat_octuple tlfloat::remquo_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y, int *  z  )

inlinestatic

remquo_() [4/4]

static tlfloat_quad tlfloat::remquo_ ( const tlfloat_quad &  x, const tlfloat_quad &  y, int *  z  )

inlinestatic

rint_() [1/4]

static double tlfloat::rint_ ( const double &  x )

inlinestatic

rint_() [2/4]

static float tlfloat::rint_ ( const float &  x )

inlinestatic

rint_() [3/4]

static tlfloat_octuple tlfloat::rint_ ( const tlfloat_octuple &  x )

inlinestatic

rint_() [4/4]

static tlfloat_quad tlfloat::rint_ ( const tlfloat_quad &  x )

inlinestatic

round_() [1/4]

static double tlfloat::round_ ( const double &  x )

inlinestatic

round_() [2/4]

static float tlfloat::round_ ( const float &  x )

inlinestatic

round_() [3/4]

static tlfloat_octuple tlfloat::round_ ( const tlfloat_octuple &  x )

inlinestatic

round_() [4/4]

static tlfloat_quad tlfloat::round_ ( const tlfloat_quad &  x )

inlinestatic

signbit_() [1/4]

static int tlfloat::signbit_ ( const double &  x )

inlinestatic

signbit_() [2/4]

static int tlfloat::signbit_ ( const float &  x )

inlinestatic

signbit_() [3/4]

static int tlfloat::signbit_ ( const tlfloat_octuple &  x )

inlinestatic

signbit_() [4/4]

static int tlfloat::signbit_ ( const tlfloat_quad &  x )

inlinestatic

sin() [1/5]

static constexpr Double tlfloat::sin ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sin() [2/5]

static constexpr Float tlfloat::sin ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sin() [3/5]

static constexpr Half tlfloat::sin ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sin() [4/5]

static constexpr Octuple tlfloat::sin ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sin() [5/5]

static constexpr Quad tlfloat::sin ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sin_() [1/4]

static double tlfloat::sin_ ( const double &  x )

inlinestatic

sin_() [2/4]

static float tlfloat::sin_ ( const float &  x )

inlinestatic

sin_() [3/4]

static tlfloat_octuple tlfloat::sin_ ( const tlfloat_octuple &  x )

inlinestatic

sin_() [4/4]

static tlfloat_quad tlfloat::sin_ ( const tlfloat_quad &  x )

inlinestatic

sinh() [1/5]

static constexpr Double tlfloat::sinh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sinh() [2/5]

static constexpr Float tlfloat::sinh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sinh() [3/5]

static constexpr Half tlfloat::sinh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sinh() [4/5]

static constexpr Octuple tlfloat::sinh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sinh() [5/5]

static constexpr Quad tlfloat::sinh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

sinh_() [1/4]

static double tlfloat::sinh_ ( const double &  x )

inlinestatic

sinh_() [2/4]

static float tlfloat::sinh_ ( const float &  x )

inlinestatic

sinh_() [3/4]

static tlfloat_octuple tlfloat::sinh_ ( const tlfloat_octuple &  x )

inlinestatic

sinh_() [4/4]

static tlfloat_quad tlfloat::sinh_ ( const tlfloat_quad &  x )

inlinestatic

sinpi() [1/5]

static constexpr Double tlfloat::sinpi ( const Double &  a )

inlinestaticconstexpr

This function returns sin(PI * x). The accuracy of the return value is 1ULP.

sinpi() [2/5]

static constexpr Float tlfloat::sinpi ( const Float &  a )

inlinestaticconstexpr

This function returns sin(PI * x). The accuracy of the return value is 1ULP.

sinpi() [3/5]

static constexpr Half tlfloat::sinpi ( const Half &  a )

inlinestaticconstexpr

This function returns sin(PI * x). The accuracy of the return value is 1ULP.

sinpi() [4/5]

static constexpr Octuple tlfloat::sinpi ( const Octuple &  a )

inlinestaticconstexpr

This function returns sin(PI * x). The accuracy of the return value is 1ULP.

sinpi() [5/5]

static constexpr Quad tlfloat::sinpi ( const Quad &  a )

inlinestaticconstexpr

This function returns sin(PI * x). The accuracy of the return value is 1ULP.

sinpi_() [1/4]

static double tlfloat::sinpi_ ( const double &  x )

inlinestatic

sinpi_() [2/4]

static float tlfloat::sinpi_ ( const float &  x )

inlinestatic

sinpi_() [3/4]

static tlfloat_octuple tlfloat::sinpi_ ( const tlfloat_octuple &  x )

inlinestatic

sinpi_() [4/4]

static tlfloat_quad tlfloat::sinpi_ ( const tlfloat_quad &  x )

inlinestatic

sqrt_() [1/4]

static double tlfloat::sqrt_ ( const double &  x )

inlinestatic

sqrt_() [2/4]

static float tlfloat::sqrt_ ( const float &  x )

inlinestatic

sqrt_() [3/4]

static tlfloat_octuple tlfloat::sqrt_ ( const tlfloat_octuple &  x )

inlinestatic

sqrt_() [4/4]

static tlfloat_quad tlfloat::sqrt_ ( const tlfloat_quad &  x )

inlinestatic

sub_() [1/4]

static double tlfloat::sub_ ( const double &  x, const double &  y  )

inlinestatic

sub_() [2/4]

static float tlfloat::sub_ ( const float &  x, const float &  y  )

inlinestatic

sub_() [3/4]

static tlfloat_octuple tlfloat::sub_ ( const tlfloat_octuple &  x, const tlfloat_octuple &  y  )

inlinestatic

sub_() [4/4]

static tlfloat_quad tlfloat::sub_ ( const tlfloat_quad &  x, const tlfloat_quad &  y  )

inlinestatic

tan() [1/5]

static constexpr Double tlfloat::tan ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tan() [2/5]

static constexpr Float tlfloat::tan ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tan() [3/5]

static constexpr Half tlfloat::tan ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tan() [4/5]

static constexpr Octuple tlfloat::tan ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tan() [5/5]

static constexpr Quad tlfloat::tan ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tan_() [1/4]

static double tlfloat::tan_ ( const double &  x )

inlinestatic

tan_() [2/4]

static float tlfloat::tan_ ( const float &  x )

inlinestatic

tan_() [3/4]

static tlfloat_octuple tlfloat::tan_ ( const tlfloat_octuple &  x )

inlinestatic

tan_() [4/4]

static tlfloat_quad tlfloat::tan_ ( const tlfloat_quad &  x )

inlinestatic

tanh() [1/5]

static constexpr Double tlfloat::tanh ( const Double &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tanh() [2/5]

static constexpr Float tlfloat::tanh ( const Float &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tanh() [3/5]

static constexpr Half tlfloat::tanh ( const Half &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tanh() [4/5]

static constexpr Octuple tlfloat::tanh ( const Octuple &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tanh() [5/5]

static constexpr Quad tlfloat::tanh ( const Quad &  a )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tanh_() [1/4]

static double tlfloat::tanh_ ( const double &  x )

inlinestatic

tanh_() [2/4]

static float tlfloat::tanh_ ( const float &  x )

inlinestatic

tanh_() [3/4]

static tlfloat_octuple tlfloat::tanh_ ( const tlfloat_octuple &  x )

inlinestatic

tanh_() [4/4]

static tlfloat_quad tlfloat::tanh_ ( const tlfloat_quad &  x )

inlinestatic

tanpi() [1/5]

static constexpr Double tlfloat::tanpi ( const Double &  a )

inlinestaticconstexpr

This function returns tan(PI * x). The accuracy of the return value is 1ULP.

tanpi() [2/5]

static constexpr Float tlfloat::tanpi ( const Float &  a )

inlinestaticconstexpr

This function returns tan(PI * x). The accuracy of the return value is 1ULP.

tanpi() [3/5]

static constexpr Half tlfloat::tanpi ( const Half &  a )

inlinestaticconstexpr

This function returns tan(PI * x). The accuracy of the return value is 1ULP.

tanpi() [4/5]

static constexpr Octuple tlfloat::tanpi ( const Octuple &  a )

inlinestaticconstexpr

This function returns tan(PI * x). The accuracy of the return value is 1ULP.

tanpi() [5/5]

static constexpr Quad tlfloat::tanpi ( const Quad &  a )

inlinestaticconstexpr

This function returns tan(PI * x). The accuracy of the return value is 1ULP.

tanpi_() [1/4]

static double tlfloat::tanpi_ ( const double &  x )

inlinestatic

tanpi_() [2/4]

static float tlfloat::tanpi_ ( const float &  x )

inlinestatic

tanpi_() [3/4]

static tlfloat_octuple tlfloat::tanpi_ ( const tlfloat_octuple &  x )

inlinestatic

tanpi_() [4/4]

static tlfloat_quad tlfloat::tanpi_ ( const tlfloat_quad &  x )

inlinestatic

tgamma() [1/5]

static constexpr Double tlfloat::tgamma ( const Double &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tgamma() [2/5]

static constexpr Float tlfloat::tgamma ( const Float &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tgamma() [3/5]

static constexpr Half tlfloat::tgamma ( const Half &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tgamma() [4/5]

static constexpr Octuple tlfloat::tgamma ( const Octuple &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tgamma() [5/5]

static constexpr Quad tlfloat::tgamma ( const Quad &  x )

inlinestaticconstexpr

This function has the same functionality as the corresponding function in math.h. The accuracy of the return value is 1ULP.

tgamma_() [1/4]

static double tlfloat::tgamma_ ( const double &  x )

inlinestatic

tgamma_() [2/4]

static float tlfloat::tgamma_ ( const float &  x )

inlinestatic

tgamma_() [3/4]

static tlfloat_octuple tlfloat::tgamma_ ( const tlfloat_octuple &  x )

inlinestatic

tgamma_() [4/4]

static tlfloat_quad tlfloat::tgamma_ ( const tlfloat_quad &  x )

inlinestatic

to_string() [1/9]

template<int N>

std::string tlfloat::to_string

(

const BigInt< N > &

i

)

to_string() [2/9]

template<int N>

std::string tlfloat::to_string

(

const BigUInt< N > &

u

)

to_string() [3/9]

static std::string tlfloat::to_string ( const double  a, int  d = 6  )

inlinestatic

to_string() [4/9]

static std::string tlfloat::to_string ( const float  a, int  d = 6  )

inlinestatic

to_string() [5/9]

static std::string tlfloat::to_string ( const tlfloat_int128_t &  a )

inlinestatic

to_string() [6/9]

static std::string tlfloat::to_string ( const tlfloat_octuple &  a, int  d = 6  )

inlinestatic

to_string() [7/9]

static std::string tlfloat::to_string ( const tlfloat_quad &  a, int  d = 6  )

inlinestatic

to_string() [8/9]

static std::string tlfloat::to_string ( const tlfloat_uint128_t &  a )

inlinestatic

to_string() [9/9]

template<typename Unpacked_t >

static std::string tlfloat::to_string ( TLFloat< Unpacked_t >  a, int  d = 6  )

static

This works like sprintf(str, "%.6g", *this) where the precision can be specified with d

trunc_() [1/4]

static double tlfloat::trunc_ ( const double &  x )

inlinestatic

trunc_() [2/4]

static float tlfloat::trunc_ ( const float &  x )

inlinestatic

trunc_() [3/4]

static tlfloat_octuple tlfloat::trunc_ ( const tlfloat_octuple &  x )

inlinestatic

trunc_() [4/4]

static tlfloat_quad tlfloat::trunc_ ( const tlfloat_quad &  x )

inlinestatic