tlfloat Namespace Reference

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

## Classes

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

## 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)
static constexpr xpair< BFloat16, BFloat16 > | sincos (const BFloat16 &a)
static constexpr xpair< Half, Half > | sincos (const Half &a)
static constexpr xpair< Float, Float > | sincos (const Float &a)
static constexpr xpair< Double, Double > | sincos (const Double &a)
static constexpr xpair< Quad, Quad > | sincos (const Quad &a)
static constexpr xpair< Octuple, Octuple > | sincos (const Octuple &a)
static constexpr xpair< BFloat16, BFloat16 > | sincospi (const BFloat16 &a)
static constexpr xpair< Half, Half > | sincospi (const Half &a)
static constexpr xpair< Float, Float > | sincospi (const Float &a)
static constexpr xpair< Double, Double > | sincospi (const Double &a)
static constexpr xpair< Quad, Quad > | sincospi (const Quad &a)
static constexpr xpair< Octuple, Octuple > | sincospi (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]

constexpr BFloat16 tlfloat::acos | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## acos() [2/6]

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

inline static constexpr

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

## acos() [3/6]

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

inline static constexpr

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

## acos() [4/6]

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

inline static constexpr

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

## acos() [5/6]

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

inline static constexpr

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

## acos() [6/6]

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

inline static constexpr

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

## acosh() [1/6]

constexpr BFloat16 tlfloat::acosh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## acosh() [2/6]

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

inline static constexpr

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

## acosh() [3/6]

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

inline static constexpr

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

## acosh() [4/6]

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

inline static constexpr

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

## acosh() [5/6]

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

inline static constexpr

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

## acosh() [6/6]

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

inline static constexpr

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

## asin() [1/6]

constexpr BFloat16 tlfloat::asin | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## asin() [2/6]

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

inline static constexpr

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

## asin() [3/6]

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

inline static constexpr

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

## asin() [4/6]

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

inline static constexpr

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

## asin() [5/6]

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

inline static constexpr

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

## asin() [6/6]

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

inline static constexpr

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

## asinh() [1/6]

constexpr BFloat16 tlfloat::asinh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## asinh() [2/6]

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

inline static constexpr

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

## asinh() [3/6]

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

inline static constexpr

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

## asinh() [4/6]

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

inline static constexpr

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

## asinh() [5/6]

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

inline static constexpr

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

## asinh() [6/6]

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

inline static constexpr

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

## atan() [1/6]

constexpr BFloat16 tlfloat::atan | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## atan() [2/6]

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

inline static constexpr

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

## atan() [3/6]

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

inline static constexpr

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

## atan() [4/6]

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

inline static constexpr

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

## atan() [5/6]

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

inline static constexpr

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

## atan() [6/6]

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

inline static constexpr

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

## atan2() [1/6]

constexpr BFloat16 tlfloat::atan2 | ( | const BFloat16 & | y,
|  | const BFloat16 & | x )

inline static constexpr

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

## atan2() [2/6]

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

inline static constexpr

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

## atan2() [3/6]

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

inline static constexpr

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

## atan2() [4/6]

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

inline static constexpr

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

## atan2() [5/6]

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

inline static constexpr

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

## atan2() [6/6]

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

inline static constexpr

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

## atanh() [1/6]

constexpr BFloat16 tlfloat::atanh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## atanh() [2/6]

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

inline static constexpr

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

## atanh() [3/6]

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

inline static constexpr

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

## atanh() [4/6]

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

inline static constexpr

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

## atanh() [5/6]

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

inline static constexpr

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

## atanh() [6/6]

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

inline static constexpr

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

## cbrt() [1/6]

constexpr BFloat16 tlfloat::cbrt | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## cbrt() [2/6]

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

inline static constexpr

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

## cbrt() [3/6]

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

inline static constexpr

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

## cbrt() [4/6]

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

inline static constexpr

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

## cbrt() [5/6]

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

inline static constexpr

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

## cbrt() [6/6]

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

inline static constexpr

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>

consteval tlfloat_t tlfloat::const_Euler | ( |  | ) |

inline static consteval

Returns the Euler–Mascheroni constant

## const_M_1_PI()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp / PI

## const_M_1_SQRTPI()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp / sqrt(PI)

## const_M_E()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * E

## const_M_LN10()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * log 10

## const_M_LN2()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * log 2

## const_M_LOG10E()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * log_10 (e)

## const_M_LOG2E()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * log_2 (e)

## const_M_PI()

template<typename tlfloat_t>

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

inline static consteval

Returns 2^exp * PI

## cos() [1/6]

constexpr BFloat16 tlfloat::cos | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## cos() [2/6]

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

inline static constexpr

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

## cos() [3/6]

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

inline static constexpr

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

## cos() [4/6]

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

inline static constexpr

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

## cos() [5/6]

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

inline static constexpr

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

## cos() [6/6]

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

inline static constexpr

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

## cosh() [1/6]

constexpr BFloat16 tlfloat::cosh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## cosh() [2/6]

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

inline static constexpr

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

## cosh() [3/6]

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

inline static constexpr

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

## cosh() [4/6]

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

inline static constexpr

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

## cosh() [5/6]

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

inline static constexpr

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

## cosh() [6/6]

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

inline static constexpr

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

## cospi() [1/6]

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

inline static constexpr

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

## cospi() [2/6]

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

inline static constexpr

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

## cospi() [3/6]

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

inline static constexpr

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

## cospi() [4/6]

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

inline static constexpr

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

## cospi() [5/6]

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

inline static constexpr

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

## cospi() [6/6]

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

inline static constexpr

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

## erf() [1/6]

constexpr BFloat16 tlfloat::erf | ( | const BFloat16 & | x | ) |

inline static constexpr

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

## erf() [2/6]

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

inline static constexpr

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

## erf() [3/6]

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

inline static constexpr

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

## erf() [4/6]

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

inline static constexpr

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

## erf() [5/6]

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

inline static constexpr

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

## erf() [6/6]

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

inline static constexpr

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

## erfc() [1/6]

constexpr BFloat16 tlfloat::erfc | ( | const BFloat16 & | x | ) |

inline static constexpr

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

## erfc() [2/6]

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

inline static constexpr

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

## erfc() [3/6]

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

inline static constexpr

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

## erfc() [4/6]

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

inline static constexpr

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

## erfc() [5/6]

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

inline static constexpr

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

## erfc() [6/6]

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

inline static constexpr

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

## exp() [1/6]

constexpr BFloat16 tlfloat::exp | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## exp() [2/6]

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

inline static constexpr

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

## exp() [3/6]

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

inline static constexpr

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

## exp() [4/6]

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

inline static constexpr

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

## exp() [5/6]

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

inline static constexpr

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

## exp() [6/6]

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

inline static constexpr

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

## exp10() [1/6]

constexpr BFloat16 tlfloat::exp10 | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## exp10() [2/6]

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

inline static constexpr

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

## exp10() [3/6]

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

inline static constexpr

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

## exp10() [4/6]

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

inline static constexpr

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

## exp10() [5/6]

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

inline static constexpr

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

## exp10() [6/6]

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

inline static constexpr

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

## exp2() [1/6]

constexpr BFloat16 tlfloat::exp2 | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## exp2() [2/6]

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

inline static constexpr

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

## exp2() [3/6]

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

inline static constexpr

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

## exp2() [4/6]

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

inline static constexpr

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

## exp2() [5/6]

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

inline static constexpr

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

## exp2() [6/6]

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

inline static constexpr

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

## expm1() [1/6]

constexpr BFloat16 tlfloat::expm1 | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## expm1() [2/6]

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

inline static constexpr

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

## expm1() [3/6]

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

inline static constexpr

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

## expm1() [4/6]

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

inline static constexpr

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

## expm1() [5/6]

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

inline static constexpr

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

## expm1() [6/6]

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

inline static constexpr

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

## fmod() [1/6]

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

inline static constexpr

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

## fmod() [2/6]

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

inline static constexpr

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

## fmod() [3/6]

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

inline static constexpr

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

## fmod() [4/6]

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

inline static constexpr

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

## fmod() [5/6]

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

inline static constexpr

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

## fmod() [6/6]

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

inline static constexpr

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

## lgamma() [1/6]

constexpr BFloat16 tlfloat::lgamma | ( | const BFloat16 & | x,
|  | bool * | sign = 0 )

inline static constexpr

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]

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

inline static constexpr

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]

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

inline static constexpr

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]

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

inline static constexpr

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]

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

inline static constexpr

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]

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

inline static constexpr

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]

constexpr BFloat16 tlfloat::log | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## log() [2/6]

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

inline static constexpr

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

## log() [3/6]

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

inline static constexpr

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

## log() [4/6]

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

inline static constexpr

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

## log() [5/6]

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

inline static constexpr

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

## log() [6/6]

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

inline static constexpr

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

## log10() [1/6]

constexpr BFloat16 tlfloat::log10 | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## log10() [2/6]

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

inline static constexpr

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

## log10() [3/6]

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

inline static constexpr

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

## log10() [4/6]

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

inline static constexpr

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

## log10() [5/6]

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

inline static constexpr

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

## log10() [6/6]

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

inline static constexpr

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

## log1p() [1/6]

constexpr BFloat16 tlfloat::log1p | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## log1p() [2/6]

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

inline static constexpr

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

## log1p() [3/6]

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

inline static constexpr

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

## log1p() [4/6]

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

inline static constexpr

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

## log1p() [5/6]

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

inline static constexpr

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

## log1p() [6/6]

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

inline static constexpr

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

## log2() [1/6]

constexpr BFloat16 tlfloat::log2 | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## log2() [2/6]

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

inline static constexpr

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

## log2() [3/6]

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

inline static constexpr

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

## log2() [4/6]

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

inline static constexpr

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

## log2() [5/6]

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

inline static constexpr

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

## log2() [6/6]

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

inline static constexpr

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>

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>

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

static

## operator<<() [4/4]

template<typename Unpacked_t>

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

static

## pow() [1/6]

constexpr BFloat16 tlfloat::pow | ( | const BFloat16 & | x,
|  | const BFloat16 & | y )

inline static constexpr

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

## pow() [2/6]

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

inline static constexpr

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

## pow() [3/6]

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

inline static constexpr

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

## pow() [4/6]

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

inline static constexpr

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

## pow() [5/6]

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

inline static constexpr

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

## pow() [6/6]

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

inline static constexpr

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

## remainder() [1/6]

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

inline static constexpr

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

## remainder() [2/6]

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

inline static constexpr

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

## remainder() [3/6]

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

inline static constexpr

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

## remainder() [4/6]

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

inline static constexpr

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

## remainder() [5/6]

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

inline static constexpr

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

## remainder() [6/6]

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

inline static constexpr

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

## remquo() [1/6]

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

inline static constexpr

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

## remquo() [2/6]

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

inline static constexpr

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

## remquo() [3/6]

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

inline static constexpr

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

## remquo() [4/6]

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

inline static constexpr

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

## remquo() [5/6]

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

inline static constexpr

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

## remquo() [6/6]

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

inline static constexpr

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

## sin() [1/6]

constexpr BFloat16 tlfloat::sin | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## sin() [2/6]

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

inline static constexpr

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

## sin() [3/6]

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

inline static constexpr

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

## sin() [4/6]

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

inline static constexpr

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

## sin() [5/6]

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

inline static constexpr

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

## sin() [6/6]

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

inline static constexpr

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

## sincos() [1/6]

constexpr xpair< BFloat16, BFloat16 > tlfloat::sincos | ( | const BFloat16 & | a | ) |

inline static constexpr

## sincos() [2/6]

constexpr xpair< Double, Double > tlfloat::sincos | ( | const Double & | a | ) |

inline static constexpr

## sincos() [3/6]

constexpr xpair< Float, Float > tlfloat::sincos | ( | const Float & | a | ) |

inline static constexpr

## sincos() [4/6]

constexpr xpair< Half, Half > tlfloat::sincos | ( | const Half & | a | ) |

inline static constexpr

## sincos() [5/6]

constexpr xpair< Octuple, Octuple > tlfloat::sincos | ( | const Octuple & | a | ) |

inline static constexpr

## sincos() [6/6]

constexpr xpair< Quad, Quad > tlfloat::sincos | ( | const Quad & | a | ) |

inline static constexpr

## sincospi() [1/6]

constexpr xpair< BFloat16, BFloat16 > tlfloat::sincospi | ( | const BFloat16 & | a | ) |

inline static constexpr

## sincospi() [2/6]

constexpr xpair< Double, Double > tlfloat::sincospi | ( | const Double & | a | ) |

inline static constexpr

## sincospi() [3/6]

constexpr xpair< Float, Float > tlfloat::sincospi | ( | const Float & | a | ) |

inline static constexpr

## sincospi() [4/6]

constexpr xpair< Half, Half > tlfloat::sincospi | ( | const Half & | a | ) |

inline static constexpr

## sincospi() [5/6]

constexpr xpair< Octuple, Octuple > tlfloat::sincospi | ( | const Octuple & | a | ) |

inline static constexpr

## sincospi() [6/6]

constexpr xpair< Quad, Quad > tlfloat::sincospi | ( | const Quad & | a | ) |

inline static constexpr

## sinh() [1/6]

constexpr BFloat16 tlfloat::sinh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## sinh() [2/6]

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

inline static constexpr

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

## sinh() [3/6]

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

inline static constexpr

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

## sinh() [4/6]

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

inline static constexpr

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

## sinh() [5/6]

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

inline static constexpr

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

## sinh() [6/6]

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

inline static constexpr

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

## sinpi() [1/6]

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

inline static constexpr

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

## sinpi() [2/6]

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

inline static constexpr

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

## sinpi() [3/6]

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

inline static constexpr

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

## sinpi() [4/6]

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

inline static constexpr

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

## sinpi() [5/6]

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

inline static constexpr

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

## sinpi() [6/6]

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

inline static constexpr

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

## tan() [1/6]

constexpr BFloat16 tlfloat::tan | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## tan() [2/6]

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

inline static constexpr

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

## tan() [3/6]

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

inline static constexpr

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

## tan() [4/6]

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

inline static constexpr

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

## tan() [5/6]

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

inline static constexpr

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

## tan() [6/6]

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

inline static constexpr

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

## tanh() [1/6]

constexpr BFloat16 tlfloat::tanh | ( | const BFloat16 & | a | ) |

inline static constexpr

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

## tanh() [2/6]

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

inline static constexpr

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

## tanh() [3/6]

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

inline static constexpr

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

## tanh() [4/6]

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

inline static constexpr

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

## tanh() [5/6]

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

inline static constexpr

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

## tanh() [6/6]

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

inline static constexpr

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

## tanpi() [1/6]

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

inline static constexpr

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

## tanpi() [2/6]

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

inline static constexpr

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

## tanpi() [3/6]

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

inline static constexpr

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

## tanpi() [4/6]

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

inline static constexpr

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

## tanpi() [5/6]

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

inline static constexpr

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

## tanpi() [6/6]

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

inline static constexpr

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

## tgamma() [1/6]

constexpr BFloat16 tlfloat::tgamma | ( | const BFloat16 & | x | ) |

inline static constexpr

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

## tgamma() [2/6]

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

inline static constexpr

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

## tgamma() [3/6]

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

inline static constexpr

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

## tgamma() [4/6]

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

inline static constexpr

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

## tgamma() [5/6]

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

inline static constexpr

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

## tgamma() [6/6]

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

inline static constexpr

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]

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

inline static

## to_string() [4/9]

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

inline static

## to_string() [5/9]

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

inline static

## to_string() [6/9]

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

inline static

## to_string() [7/9]

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

inline static

## to_string() [8/9]

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

inline static

## to_string() [9/9]

template<typename Unpacked_t>

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