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)

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 BFloat16	sin (const BFloat16 &a)

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 BFloat16	cos (const BFloat16 &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 BFloat16	tan (const BFloat16 &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 BFloat16	atan2 (const BFloat16 &y, const BFloat16 &x)

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 BFloat16	asin (const BFloat16 &a)

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 BFloat16	acos (const BFloat16 &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 BFloat16	atan (const BFloat16 &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 BFloat16	exp (const BFloat16 &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 BFloat16	expm1 (const BFloat16 &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 BFloat16	exp2 (const BFloat16 &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 BFloat16	exp10 (const BFloat16 &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 BFloat16	log (const BFloat16 &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 BFloat16	log1p (const BFloat16 &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 BFloat16	log2 (const BFloat16 &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 BFloat16	log10 (const BFloat16 &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 BFloat16	pow (const BFloat16 &x, const BFloat16 &y)

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 BFloat16	cbrt (const BFloat16 &a)

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 BFloat16	sinh (const BFloat16 &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 BFloat16	cosh (const BFloat16 &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 BFloat16	tanh (const BFloat16 &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 BFloat16	asinh (const BFloat16 &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 BFloat16	acosh (const BFloat16 &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 BFloat16	atanh (const BFloat16 &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 BFloat16	fmod (const BFloat16 &y, const BFloat16 &x)

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 BFloat16	remainder (const BFloat16 &y, const BFloat16 &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< BFloat16, int64_t >	remquo (const BFloat16 &y, const BFloat16 &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 BFloat16	erf (const BFloat16 &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 BFloat16	erfc (const BFloat16 &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 BFloat16	tgamma (const BFloat16 &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 BFloat16	lgamma (const BFloat16 &x, bool *sign=0)

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 BFloat16	sinpi (const BFloat16 &a)

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 BFloat16	cospi (const BFloat16 &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 BFloat16	tanpi (const BFloat16 &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/6]

static constexpr BFloat16 tlfloat::acos ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ acosh() [1/6]

static constexpr BFloat16 tlfloat::acosh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ asin() [1/6]

static constexpr BFloat16 tlfloat::asin ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ asinh() [1/6]

static constexpr BFloat16 tlfloat::asinh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ atan() [1/6]

static constexpr BFloat16 tlfloat::atan ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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/6]

static constexpr BFloat16 tlfloat::atan2	(	const BFloat16 &	y,
		const BFloat16 &	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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ atanh() [1/6]

static constexpr BFloat16 tlfloat::atanh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ cbrt() [1/6]

static constexpr BFloat16 tlfloat::cbrt ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ 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

◆ cos() [1/6]

static constexpr BFloat16 tlfloat::cos ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ cosh() [1/6]

static constexpr BFloat16 tlfloat::cosh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ cospi() [1/6]

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

inlinestaticconstexpr

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

◆ cospi() [2/6]

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

inlinestaticconstexpr

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

◆ cospi() [3/6]

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

inlinestaticconstexpr

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

◆ cospi() [4/6]

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

inlinestaticconstexpr

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

◆ cospi() [5/6]

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

inlinestaticconstexpr

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

◆ cospi() [6/6]

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

inlinestaticconstexpr

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

◆ erf() [1/6]

static constexpr BFloat16 tlfloat::erf ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ erfc() [1/6]

static constexpr BFloat16 tlfloat::erfc ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ exp() [1/6]

static constexpr BFloat16 tlfloat::exp ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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/6]

static constexpr BFloat16 tlfloat::exp10 ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ exp2() [1/6]

static constexpr BFloat16 tlfloat::exp2 ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ expm1() [1/6]

static constexpr BFloat16 tlfloat::expm1 ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ fmod() [1/6]

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

inlinestaticconstexpr

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

◆ fmod() [2/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ lgamma() [1/6]

static constexpr BFloat16 tlfloat::lgamma	(	const BFloat16 &	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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ log() [1/6]

static constexpr BFloat16 tlfloat::log ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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/6]

static constexpr BFloat16 tlfloat::log10 ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ log1p() [1/6]

static constexpr BFloat16 tlfloat::log1p ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ log2() [1/6]

static constexpr BFloat16 tlfloat::log2 ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ 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/6]

static constexpr BFloat16 tlfloat::pow	(	const BFloat16 &	x,
		const BFloat16 &	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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ remainder() [1/6]

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

inlinestaticconstexpr

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

◆ remainder() [2/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ remquo() [1/6]

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

inlinestaticconstexpr

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

◆ remquo() [2/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ sin() [1/6]

static constexpr BFloat16 tlfloat::sin ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ sinh() [1/6]

static constexpr BFloat16 tlfloat::sinh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ sinpi() [1/6]

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

inlinestaticconstexpr

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

◆ sinpi() [2/6]

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

inlinestaticconstexpr

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

◆ sinpi() [3/6]

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

inlinestaticconstexpr

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

◆ sinpi() [4/6]

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

inlinestaticconstexpr

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

◆ sinpi() [5/6]

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

inlinestaticconstexpr

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

◆ sinpi() [6/6]

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

inlinestaticconstexpr

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

◆ tan() [1/6]

static constexpr BFloat16 tlfloat::tan ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ tanh() [1/6]

static constexpr BFloat16 tlfloat::tanh ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ tanpi() [1/6]

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

inlinestaticconstexpr

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

◆ tanpi() [2/6]

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

inlinestaticconstexpr

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

◆ tanpi() [3/6]

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

inlinestaticconstexpr

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

◆ tanpi() [4/6]

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

inlinestaticconstexpr

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

◆ tanpi() [5/6]

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

inlinestaticconstexpr

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

◆ tanpi() [6/6]

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

inlinestaticconstexpr

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

◆ tgamma() [1/6]

static constexpr BFloat16 tlfloat::tgamma ( const BFloat16 & 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/6]

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() [3/6]

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() [4/6]

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() [5/6]

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() [6/6]

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.

◆ 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

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ BFloat16

◆ Double

◆ Float

◆ Half

◆ Octuple

◆ Quad

Function Documentation

◆ acos() [1/6]

◆ acos() [2/6]

◆ acos() [3/6]

◆ acos() [4/6]

◆ acos() [5/6]

◆ acos() [6/6]

◆ acosh() [1/6]

◆ acosh() [2/6]

◆ acosh() [3/6]

◆ acosh() [4/6]

◆ acosh() [5/6]

◆ acosh() [6/6]

◆ asin() [1/6]

◆ asin() [2/6]

◆ asin() [3/6]

◆ asin() [4/6]

◆ asin() [5/6]

◆ asin() [6/6]

◆ asinh() [1/6]

◆ asinh() [2/6]

◆ asinh() [3/6]

◆ asinh() [4/6]

◆ asinh() [5/6]

◆ asinh() [6/6]

◆ atan() [1/6]

◆ atan() [2/6]

◆ atan() [3/6]

◆ atan() [4/6]

◆ atan() [5/6]

◆ atan() [6/6]

◆ atan2() [1/6]

◆ atan2() [2/6]

◆ atan2() [3/6]

◆ atan2() [4/6]

◆ atan2() [5/6]

◆ atan2() [6/6]

◆ atanh() [1/6]

◆ atanh() [2/6]

◆ atanh() [3/6]

◆ atanh() [4/6]

◆ atanh() [5/6]

◆ atanh() [6/6]

◆ cbrt() [1/6]

◆ cbrt() [2/6]

◆ cbrt() [3/6]

◆ cbrt() [4/6]

◆ cbrt() [5/6]

◆ cbrt() [6/6]

◆ const_Euler()

◆ const_M_1_PI()

◆ const_M_1_SQRTPI()

◆ const_M_E()

◆ const_M_LN10()

◆ const_M_LN2()

◆ const_M_LOG10E()

◆ const_M_LOG2E()

◆ const_M_PI()

◆ cos() [1/6]

◆ cos() [2/6]

◆ cos() [3/6]

◆ cos() [4/6]

◆ cos() [5/6]

◆ cos() [6/6]

◆ cosh() [1/6]

◆ cosh() [2/6]

◆ cosh() [3/6]

◆ cosh() [4/6]

◆ cosh() [5/6]