#include <stdint.h>
#include <string.h>
#include <stdarg.h>
#include <tlfloat/tlfloatconfig.hpp>

Include dependency graph for tlfloat.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	tlfloat_int128_t_

struct	tlfloat_uint128_t_

struct	tlfloat_quad_

struct	tlfloat_octuple_

struct	tlfloat_quad

struct	tlfloat_octuple

struct	tlfloat_int128_t

struct	tlfloat_uint128_t

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

Macros
#define	TLFLOAT_FP_NAN 0

#define	TLFLOAT_FP_INFINITE 1

#define	TLFLOAT_FP_ZERO 2

#define	TLFLOAT_FP_SUBNORMAL 3

#define	TLFLOAT_FP_NORMAL 4

#define	TLFLOAT_FP_ILOGB0 ((int)0x80000000)

#define	TLFLOAT_FP_ILOGBNAN ((int)2147483647)

#define	TLFLOAT_LIBQUADMATH_EMULATION

#define	TLFLOAT_QUAD_IS_STRUCT

#define	TLFLOAT_INT128_IS_STRUCT

#define	TLFLOAT_M_Eq 0x1.5bf0a8b1457695355fb8ac404e7ap+1Q

#define	TLFLOAT_M_LOG2Eq 0x1.71547652b82fe1777d0ffda0d23ap+0Q

#define	TLFLOAT_M_LOG10Eq 0x1.bcb7b1526e50e32a6ab7555f5a68p-2Q

#define	TLFLOAT_M_LN2q 0x1.62e42fefa39ef35793c7673007e6p-1Q

#define	TLFLOAT_M_LN10q 0x1.26bb1bbb5551582dd4adac5705a6p+1Q

#define	TLFLOAT_M_PIq 0x1.921fb54442d18469898cc51701b8p+1Q

#define	TLFLOAT_M_PI_2q 0x1.921fb54442d18469898cc51701b8p+0Q

#define	TLFLOAT_M_PI_4q 0x1.921fb54442d18469898cc51701b8p-1Q

#define	TLFLOAT_M_1_PIq 0x1.45f306dc9c882a53f84eafa3ea6ap-2Q

#define	TLFLOAT_M_2_PIq 0x1.45f306dc9c882a53f84eafa3ea6ap-1Q

#define	TLFLOAT_M_2_SQRTPIq 0x1.20dd750429b6d11ae3a914fed7fep+0Q

#define	TLFLOAT_M_SQRT2q 0x1.6a09e667f3bcc908b2fb1366ea95p+0Q

#define	TLFLOAT_M_SQRT1_2q 0x1.6a09e667f3bcc908b2fb1366ea95p-1Q

#define	TLFLOAT_FLT128_MAX 0x1.ffffffffffffffffffffffffffffp+16383Q

#define	TLFLOAT_FLT128_MIN 0x1p-16382Q

#define	TLFLOAT_FLT128_DENORM_MIN 0x0.0000000000000000000000000001p-16382Q

#define	TLFLOAT_FLT128_TRUE_MIN 0x0.0000000000000000000000000001p-16382Q

#define	TLFLOAT_FLT128_EPSILON 0x1p-112Q

#define	M_Eq TLFLOAT_M_Eq

#define	M_LOG2Eq TLFLOAT_M_LOG2Eq

#define	M_LOG10Eq TLFLOAT_M_LOG10Eq

#define	M_LN2q TLFLOAT_M_LN2q

#define	M_LN10q TLFLOAT_M_LN10q

#define	M_PIq TLFLOAT_M_PIq

#define	M_PI_2q TLFLOAT_M_PI_2q

#define	M_PI_4q TLFLOAT_M_PI_4q

#define	M_1_PIq TLFLOAT_M_1_PIq

#define	M_2_PIq TLFLOAT_M_2_PIq

#define	M_2_SQRTPIq TLFLOAT_M_2_SQRTPIq

#define	M_SQRT2q TLFLOAT_M_SQRT2q

#define	M_SQRT1_2q TLFLOAT_M_SQRT1_2q

#define	FLT128_MAX TLFLOAT_FLT128_MAX

#define	FLT128_MIN TLFLOAT_FLT128_MIN

#define	FLT128_DENORM_MIN TLFLOAT_FLT128_DENORM_MIN

#define	FLT128_EPSILON TLFLOAT_FLT128_EPSILON

#define	FLT128_MANT_DIG 113

#define	FLT128_MIN_EXP (-16381)

#define	FLT128_MAX_EXP 16384

#define	FLT128_DIG 33

#define	FLT128_MIN_10_EXP (-4931)

#define	FLT128_MAX_10_EXP 4932

#define	TLFLOAT_POLYFUNC_f_f(OP)

#define	TLFLOAT_POLYFUNC_i_f(OP)

#define	TLFLOAT_POLYFUNC_f_f_f(OP)

#define	TLFLOAT_POLYFUNC_f_f_i(OP)

#define	TLFLOAT_POLYFUNC_f_f_pf(OP)

#define	TLFLOAT_POLYFUNC_f_f_pi(OP)

#define	TLFLOAT_POLYFUNC_f_f_f_pi(OP)

#define	TLFLOAT_POLYFUNC_f_f_f_f(OP)

Functions
uint64_t	tlfloat_version ()

int	tlfloat_printf (const char *fmt,...)

int	tlfloat_fprintf (FILE fp, const char fmt,...)

int	tlfloat_snprintf (char str, size_t size, const char fmt,...)

int	tlfloat_vprintf (const char *fmt, va_list ap)

int	tlfloat_vfprintf (FILE fp, const char fmt, va_list ap)

int	tlfloat_vsnprintf (char str, size_t size, const char fmt, va_list ap)

int	tlfloat_registerPrintfHook ()

void	tlfloat_unregisterPrintfHook ()

double	tlfloat_strtod (const char , const char *)

float	tlfloat_strtof (const char , const char *)

tlfloat_quad_	tlfloat_strtoq (const char , const char *)

tlfloat_octuple_	tlfloat_strtoo (const char , const char *)

tlfloat_int128_t_	tlfloat_strtoi128 (const char , const char *, const int)

tlfloat_uint128_t_	tlfloat_strtou128 (const char , const char *, const int)

double	tlfloat_cast_d_q (const tlfloat_quad_ x)

double	tlfloat_cast_d_o (const tlfloat_octuple_ x)

tlfloat_quad_	tlfloat_cast_q_d (const double x)

tlfloat_quad_	tlfloat_cast_q_o (const tlfloat_octuple_ x)

tlfloat_octuple_	tlfloat_cast_o_d (const double x)

tlfloat_octuple_	tlfloat_cast_o_q (const tlfloat_quad_ x)

int64_t	tlfloat_cast_i64_q (const tlfloat_quad_ x)

tlfloat_quad_	tlfloat_cast_q_i64 (const int64_t x)

int64_t	tlfloat_cast_i64_o (const tlfloat_octuple_ x)

tlfloat_octuple_	tlfloat_cast_o_i64 (const int64_t x)

uint64_t	tlfloat_cast_u64_q (const tlfloat_quad_ x)

tlfloat_quad_	tlfloat_cast_q_u64 (const uint64_t x)

uint64_t	tlfloat_cast_u64_o (const tlfloat_octuple_ x)

tlfloat_octuple_	tlfloat_cast_o_u64 (const uint64_t x)

tlfloat_int128_t_	tlfloat_cast_i128_i64 (const int64_t x)

int64_t	tlfloat_cast_i64_i128 (const tlfloat_int128_t_ x)

tlfloat_uint128_t_	tlfloat_cast_u128_u64 (const uint64_t x)

uint64_t	tlfloat_cast_u64_u128 (const tlfloat_uint128_t_ x)

tlfloat_int128_t_	tlfloat_cast_i128_d (const double x)

double	tlfloat_cast_d_i128 (const tlfloat_int128_t_ x)

tlfloat_uint128_t_	tlfloat_cast_u128_d (const double x)

double	tlfloat_cast_d_u128 (const tlfloat_uint128_t_ x)

tlfloat_int128_t_	tlfloat_cast_i128_q (const tlfloat_quad_ x)

tlfloat_quad_	tlfloat_cast_q_i128 (const tlfloat_int128_t_ x)

tlfloat_uint128_t_	tlfloat_cast_u128_q (const tlfloat_quad_ x)

tlfloat_quad_	tlfloat_cast_q_u128 (const tlfloat_uint128_t_ x)

tlfloat_int128_t_	tlfloat_cast_i128_o (const tlfloat_octuple_ x)

tlfloat_octuple_	tlfloat_cast_o_i128 (const tlfloat_int128_t_ x)

tlfloat_uint128_t_	tlfloat_cast_u128_o (const tlfloat_octuple_ x)

tlfloat_octuple_	tlfloat_cast_o_u128 (const tlfloat_uint128_t_ x)

int	tlfloat_eq_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

int	tlfloat_ne_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

int	tlfloat_lt_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

int	tlfloat_le_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

int	tlfloat_gt_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

int	tlfloat_ge_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_add_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_sub_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_mul_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_div_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_mod_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_and_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_or_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_xor_i128_i128 (const tlfloat_int128_t_ x, const tlfloat_int128_t_ y)

tlfloat_int128_t_	tlfloat_not_i128 (const tlfloat_int128_t_ x)

tlfloat_int128_t_	tlfloat_shl_i128_i (const tlfloat_int128_t_ x, const int y)

tlfloat_int128_t_	tlfloat_shr_i128_i (const tlfloat_int128_t_ x, const int y)

tlfloat_int128_t_	tlfloat_neg_i128 (const tlfloat_int128_t_ x)

int	tlfloat_eq_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

int	tlfloat_ne_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

int	tlfloat_lt_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

int	tlfloat_le_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

int	tlfloat_gt_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

int	tlfloat_ge_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_add_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_sub_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_mul_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_div_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_mod_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_and_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_or_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_xor_u128_u128 (const tlfloat_uint128_t_ x, const tlfloat_uint128_t_ y)

tlfloat_uint128_t_	tlfloat_not_u128 (const tlfloat_uint128_t_ x)

tlfloat_uint128_t_	tlfloat_shl_u128_i (const tlfloat_uint128_t_ x, const int y)

tlfloat_uint128_t_	tlfloat_shr_u128_i (const tlfloat_uint128_t_ x, const int y)

int	tlfloat_eq_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_ne_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_lt_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_le_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_gt_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_ge_q_q (const tlfloat_quad_ x, const tlfloat_quad_ y)

int	tlfloat_eq_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

int	tlfloat_ne_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

int	tlfloat_lt_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

int	tlfloat_le_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

int	tlfloat_gt_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

int	tlfloat_ge_o_o (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

float	tlfloat_addf (const float x, const float y)

double	tlfloat_add (const double x, const double y)

tlfloat_quad_	tlfloat_addq (const tlfloat_quad_ x, const tlfloat_quad_ y)

tlfloat_octuple_	tlfloat_addo (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

float	tlfloat_subf (const float x, const float y)

double	tlfloat_sub (const double x, const double y)

tlfloat_quad_	tlfloat_subq (const tlfloat_quad_ x, const tlfloat_quad_ y)

tlfloat_octuple_	tlfloat_subo (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

float	tlfloat_mulf (const float x, const float y)

double	tlfloat_mul (const double x, const double y)

tlfloat_quad_	tlfloat_mulq (const tlfloat_quad_ x, const tlfloat_quad_ y)

tlfloat_octuple_	tlfloat_mulo (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

float	tlfloat_divf (const float x, const float y)

double	tlfloat_div (const double x, const double y)

tlfloat_quad_	tlfloat_divq (const tlfloat_quad_ x, const tlfloat_quad_ y)

tlfloat_octuple_	tlfloat_divo (const tlfloat_octuple_ x, const tlfloat_octuple_ y)

float	tlfloat_negf (const float x)

double	tlfloat_neg (const double x)

tlfloat_quad_	tlfloat_negq (const tlfloat_quad_ x)

tlfloat_octuple_	tlfloat_nego (const tlfloat_octuple_ x)

float	tlfloat_fmaf (const float x, const float y, const float z)

double	tlfloat_fma (const double x, const double y, const double z)

tlfloat_quad_	tlfloat_fmaq (const tlfloat_quad_ x, const tlfloat_quad_ y, const tlfloat_quad_ z)

tlfloat_octuple_	tlfloat_fmao (const tlfloat_octuple_ x, const tlfloat_octuple_ y, const tlfloat_octuple_ z)

float	tlfloat_sqrtf (const float x)

double	tlfloat_sqrt (const double x)

tlfloat_quad_	tlfloat_sqrtq (const tlfloat_quad_ x)

tlfloat_octuple_	tlfloat_sqrto (const tlfloat_octuple_ x)

float	tlfloat_fabsf (const float x)

double	tlfloat_fabs (const double x)

float	tlfloat_copysignf (const float x, const float y)

double	tlfloat_copysign (const double x, const double y)

float	tlfloat_fmaxf (const float x, const float y)

double	tlfloat_fmax (const double x, const double y)

float	tlfloat_fminf (const float x, const float y)

double	tlfloat_fmin (const double x, const double y)

float	tlfloat_fdimf (const float x, const float y)

double	tlfloat_fdim (const double x, const double y)

float	tlfloat_ldexpf (const float x, const int y)

double	tlfloat_ldexp (const double x, const int y)

float	tlfloat_frexpf (const float x, int *y)

double	tlfloat_frexp (const double x, int *y)

float	tlfloat_modff (const float x, float *y)

double	tlfloat_modf (const double x, double *y)

float	tlfloat_nextafterf (const float x, const float y)

double	tlfloat_nextafter (const double x, const double y)

int	tlfloat_ilogbf (const float x)

int	tlfloat_ilogb (const double x)

int	tlfloat_isnanf (const float x)

int	tlfloat_isnan (const double x)

int	tlfloat_isinff (const float x)

int	tlfloat_isinf (const double x)

int	tlfloat_finitef (const float x)

int	tlfloat_finite (const double x)

int	tlfloat_fpclassifyf (const float x)

int	tlfloat_fpclassify (const double x)

int	tlfloat_signbitf (const float x)

int	tlfloat_signbit (const double x)

float	tlfloat_hypotf (const float x, const float y)

double	tlfloat_hypot (const double x, const double y)

float	tlfloat_truncf (const float x)

double	tlfloat_trunc (const double x)

float	tlfloat_floorf (const float x)

double	tlfloat_floor (const double x)

float	tlfloat_ceilf (const float x)

double	tlfloat_ceil (const double x)

float	tlfloat_roundf (const float x)

double	tlfloat_round (const double x)

float	tlfloat_rintf (const float x)

double	tlfloat_rint (const double x)

float	tlfloat_sinf (const float x)

double	tlfloat_sin (const double x)

float	tlfloat_cosf (const float x)

double	tlfloat_cos (const double x)

float	tlfloat_tanf (const float x)

double	tlfloat_tan (const double x)

float	tlfloat_sinpif (const float x)

double	tlfloat_sinpi (const double x)

float	tlfloat_cospif (const float x)

double	tlfloat_cospi (const double x)

float	tlfloat_tanpif (const float x)

double	tlfloat_tanpi (const double x)

float	tlfloat_asinf (const float x)

double	tlfloat_asin (const double x)

float	tlfloat_acosf (const float x)

double	tlfloat_acos (const double x)

float	tlfloat_atanf (const float x)

double	tlfloat_atan (const double x)

float	tlfloat_atan2f (const float y, const float x)

double	tlfloat_atan2 (const double y, const double x)

float	tlfloat_expf (const float a)

double	tlfloat_exp (const double a)

float	tlfloat_expm1f (const float a)

double	tlfloat_expm1 (const double a)

float	tlfloat_exp2f (const float a)

double	tlfloat_exp2 (const double a)

float	tlfloat_exp10f (const float a)

double	tlfloat_exp10 (const double a)

float	tlfloat_logf (const float a)

double	tlfloat_log (const double a)

float	tlfloat_log1pf (const float a)

double	tlfloat_log1p (const double a)

float	tlfloat_log2f (const float a)

double	tlfloat_log2 (const double a)

float	tlfloat_log10f (const float a)

double	tlfloat_log10 (const double a)

float	tlfloat_powf (const float x, const float y)

double	tlfloat_pow (const double x, const double y)

float	tlfloat_cbrtf (const float a)

double	tlfloat_cbrt (const double a)

float	tlfloat_sinhf (const float x)

double	tlfloat_sinh (const double x)

float	tlfloat_coshf (const float x)

double	tlfloat_cosh (const double x)

float	tlfloat_tanhf (const float x)

double	tlfloat_tanh (const double x)

float	tlfloat_asinhf (const float x)

double	tlfloat_asinh (const double x)

float	tlfloat_acoshf (const float x)

double	tlfloat_acosh (const double x)

float	tlfloat_atanhf (const float x)

double	tlfloat_atanh (const double x)

float	tlfloat_fmodf (const float x, const float y)

double	tlfloat_fmod (const double x, const double y)

float	tlfloat_remainderf (const float x, const float y)

double	tlfloat_remainder (const double x, const double y)

float	tlfloat_remquof (const float x, const float y, int *quo)

double	tlfloat_remquo (const double x, const double y, int *quo)

float	tlfloat_erff (const float x)

double	tlfloat_erf (const double x)

float	tlfloat_erfcf (const float x)

double	tlfloat_erfc (const double x)

float	tlfloat_tgammaf (const float x)

double	tlfloat_tgamma (const double x)

float	tlfloat_lgammaf (const float x)

double	tlfloat_lgamma (const double x)

static tlfloat_quad	tlfloat_fmaq (const tlfloat_quad x, const tlfloat_quad y, const tlfloat_quad z)

static tlfloat_quad	tlfloat_sqrtq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_fabsq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_copysignq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_fmaxq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_fminq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_fdimq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_ldexpq (const tlfloat_quad x, const int y)

static tlfloat_quad	tlfloat_frexpq (const tlfloat_quad x, int *y)

static tlfloat_quad	tlfloat_modfq (const tlfloat_quad x, tlfloat_quad *y)

static tlfloat_quad	tlfloat_nextafterq (const tlfloat_quad x, const tlfloat_quad y)

static int	tlfloat_ilogbq (const tlfloat_quad x)

static int	tlfloat_isnanq (const tlfloat_quad x)

static int	tlfloat_isinfq (const tlfloat_quad x)

static int	tlfloat_finiteq (const tlfloat_quad x)

static int	tlfloat_fpclassifyq (const tlfloat_quad x)

static int	tlfloat_signbitq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_hypotq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_truncq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_floorq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_ceilq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_roundq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_rintq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_sinq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_cosq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_tanq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_sinpiq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_cospiq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_tanpiq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_asinq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_acosq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_atanq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_atan2q (const tlfloat_quad y, const tlfloat_quad x)

static tlfloat_quad	tlfloat_expq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_expm1q (const tlfloat_quad x)

static tlfloat_quad	tlfloat_exp2q (const tlfloat_quad x)

static tlfloat_quad	tlfloat_exp10q (const tlfloat_quad x)

static tlfloat_quad	tlfloat_logq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_log1pq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_log2q (const tlfloat_quad x)

static tlfloat_quad	tlfloat_log10q (const tlfloat_quad x)

static tlfloat_quad	tlfloat_powq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_cbrtq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_sinhq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_coshq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_tanhq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_asinhq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_acoshq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_atanhq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_erfq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_erfcq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_tgammaq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_lgammaq (const tlfloat_quad x)

static tlfloat_quad	tlfloat_fmodq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_remainderq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	tlfloat_remquoq (const tlfloat_quad x, const tlfloat_quad y, int *quo)

static tlfloat_quad	strtoflt128 (const char s, const char *sp)

static int	quadmath_snprintf (char str, size_t size, const char fmt,...)

static tlfloat_quad	fmaq (const tlfloat_quad x, const tlfloat_quad y, const tlfloat_quad z)

static tlfloat_quad	sqrtq (const tlfloat_quad x)

static tlfloat_quad	fabsq (const tlfloat_quad x)

static tlfloat_quad	copysignq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	fmaxq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	fminq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	fdimq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	ldexpq (const tlfloat_quad x, const int y)

static tlfloat_quad	frexpq (const tlfloat_quad x, int *y)

static tlfloat_quad	modfq (const tlfloat_quad x, tlfloat_quad *y)

static tlfloat_quad	nextafterq (const tlfloat_quad x, const tlfloat_quad y)

static int	ilogbq (const tlfloat_quad x)

static int	isnanq (const tlfloat_quad x)

static int	isinfq (const tlfloat_quad x)

static int	finiteq (const tlfloat_quad x)

static int	fpclassifyq (const tlfloat_quad x)

static int	signbitq (const tlfloat_quad x)

static tlfloat_quad	hypotq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	truncq (const tlfloat_quad x)

static tlfloat_quad	floorq (const tlfloat_quad x)

static tlfloat_quad	ceilq (const tlfloat_quad x)

static tlfloat_quad	roundq (const tlfloat_quad x)

static tlfloat_quad	rintq (const tlfloat_quad x)

static tlfloat_quad	sinq (const tlfloat_quad x)

static tlfloat_quad	cosq (const tlfloat_quad x)

static void	sincosq (const tlfloat_quad x, tlfloat_quad s, tlfloat_quad c)

static tlfloat_quad	tanq (const tlfloat_quad x)

static tlfloat_quad	asinq (const tlfloat_quad x)

static tlfloat_quad	acosq (const tlfloat_quad x)

static tlfloat_quad	atanq (const tlfloat_quad x)

static tlfloat_quad	atan2q (const tlfloat_quad y, const tlfloat_quad x)

static tlfloat_quad	expq (const tlfloat_quad x)

static tlfloat_quad	expm1q (const tlfloat_quad x)

static tlfloat_quad	exp2q (const tlfloat_quad x)

static tlfloat_quad	exp10q (const tlfloat_quad x)

static tlfloat_quad	logq (const tlfloat_quad x)

static tlfloat_quad	log1pq (const tlfloat_quad x)

static tlfloat_quad	log2q (const tlfloat_quad x)

static tlfloat_quad	log10q (const tlfloat_quad x)

static tlfloat_quad	powq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	cbrtq (const tlfloat_quad x)

static tlfloat_quad	sinhq (const tlfloat_quad x)

static tlfloat_quad	coshq (const tlfloat_quad x)

static tlfloat_quad	tanhq (const tlfloat_quad x)

static tlfloat_quad	asinhq (const tlfloat_quad x)

static tlfloat_quad	acoshq (const tlfloat_quad x)

static tlfloat_quad	atanhq (const tlfloat_quad x)

static tlfloat_quad	erfq (const tlfloat_quad x)

static tlfloat_quad	erfcq (const tlfloat_quad x)

static tlfloat_quad	tgammaq (const tlfloat_quad x)

static tlfloat_quad	lgammaq (const tlfloat_quad x)

static tlfloat_quad	fmodq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	remainderq (const tlfloat_quad x, const tlfloat_quad y)

static tlfloat_quad	remquoq (const tlfloat_quad x, const tlfloat_quad y, int *quo)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator+ (const T &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator+ (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator+ (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator+ (const tlfloat_octuple &lhs, const T &rhs)

static tlfloat_octuple	operator+ (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static tlfloat_octuple	operator+ (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_octuple	operator+ (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator+ (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

template<typename rhstype >
static tlfloat_octuple &	operator+= (tlfloat_octuple &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator- (const T &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator- (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator- (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator- (const tlfloat_octuple &lhs, const T &rhs)

static tlfloat_octuple	operator- (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static tlfloat_octuple	operator- (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_octuple	operator- (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator- (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

template<typename rhstype >
static tlfloat_octuple &	operator-= (tlfloat_octuple &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator* (const T &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator* (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator* (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator* (const tlfloat_octuple &lhs, const T &rhs)

static tlfloat_octuple	operator* (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static tlfloat_octuple	operator* (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_octuple	operator* (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator* (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

template<typename rhstype >
static tlfloat_octuple &	operator*= (tlfloat_octuple &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator/ (const T &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator/ (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator/ (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_octuple	operator/ (const tlfloat_octuple &lhs, const T &rhs)

static tlfloat_octuple	operator/ (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static tlfloat_octuple	operator/ (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_octuple	operator/ (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

static tlfloat_octuple	operator/ (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

template<typename rhstype >
static tlfloat_octuple &	operator/= (tlfloat_octuple &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator== (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator== (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator== (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator== (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator== (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator== (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator== (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator== (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator!= (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator!= (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator!= (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator!= (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator!= (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator!= (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator!= (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator!= (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator< (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator< (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator< (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator< (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator< (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator< (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator< (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator< (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator<= (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator<= (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator<= (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator<= (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator<= (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator<= (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator<= (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator<= (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator> (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator> (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator> (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator> (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator> (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator> (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator> (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator> (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator>= (const T &lhs, const tlfloat_octuple &rhs)

static bool	operator>= (const tlfloat_int128_t &lhs, const tlfloat_octuple &rhs)

static bool	operator>= (const tlfloat_uint128_t &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator>= (const tlfloat_octuple &lhs, const T &rhs)

static bool	operator>= (const tlfloat_octuple &lhs, const tlfloat_int128_t &rhs)

static bool	operator>= (const tlfloat_octuple &lhs, const tlfloat_uint128_t &rhs)

static bool	operator>= (const tlfloat_octuple &lhs, const tlfloat_quad &rhs)

static bool	operator>= (const tlfloat_quad &lhs, const tlfloat_octuple &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator+ (const T &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator+ (const tlfloat_int128_t &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator+ (const tlfloat_uint128_t &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator+ (const tlfloat_quad &lhs, const T &rhs)

static tlfloat_quad	operator+ (const tlfloat_quad &lhs, const tlfloat_int128_t &rhs)

static tlfloat_quad	operator+ (const tlfloat_quad &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_quad &	operator+= (tlfloat_quad &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator- (const T &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator- (const tlfloat_int128_t &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator- (const tlfloat_uint128_t &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator- (const tlfloat_quad &lhs, const T &rhs)

static tlfloat_quad	operator- (const tlfloat_quad &lhs, const tlfloat_int128_t &rhs)

static tlfloat_quad	operator- (const tlfloat_quad &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_quad &	operator-= (tlfloat_quad &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator* (const T &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator* (const tlfloat_int128_t &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator* (const tlfloat_uint128_t &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator* (const tlfloat_quad &lhs, const T &rhs)

static tlfloat_quad	operator* (const tlfloat_quad &lhs, const tlfloat_int128_t &rhs)

static tlfloat_quad	operator* (const tlfloat_quad &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_quad &	operator*= (tlfloat_quad &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator/ (const T &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator/ (const tlfloat_int128_t &lhs, const tlfloat_quad &rhs)

static tlfloat_quad	operator/ (const tlfloat_uint128_t &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_quad	operator/ (const tlfloat_quad &lhs, const T &rhs)

static tlfloat_quad	operator/ (const tlfloat_quad &lhs, const tlfloat_int128_t &rhs)

static tlfloat_quad	operator/ (const tlfloat_quad &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_quad &	operator/= (tlfloat_quad &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator== (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator== (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator!= (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator!= (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator< (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator< (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator<= (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator<= (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator> (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator> (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator>= (const T &lhs, const tlfloat_quad &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static bool	operator>= (const tlfloat_quad &lhs, const T &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_int128_t	operator+ (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_uint128_t	operator+ (const T &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_int128_t	operator+ (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static tlfloat_int128_t	operator+ (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static tlfloat_uint128_t	operator+ (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static tlfloat_uint128_t	operator+ (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_int128_t &	operator+= (tlfloat_int128_t &lhs, const rhstype &rhs)

template<typename rhstype >
static tlfloat_uint128_t &	operator+= (tlfloat_uint128_t &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_int128_t	operator- (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_uint128_t	operator- (const T &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_int128_t	operator- (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static tlfloat_int128_t	operator- (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static tlfloat_uint128_t	operator- (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static tlfloat_uint128_t	operator- (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_int128_t &	operator-= (tlfloat_int128_t &lhs, const rhstype &rhs)

template<typename rhstype >
static tlfloat_uint128_t &	operator-= (tlfloat_uint128_t &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_int128_t	operator* (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_uint128_t	operator* (const T &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_int128_t	operator* (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static tlfloat_int128_t	operator* (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static tlfloat_uint128_t	operator* (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static tlfloat_uint128_t	operator* (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_int128_t &	operator*= (tlfloat_int128_t &lhs, const rhstype &rhs)

template<typename rhstype >
static tlfloat_uint128_t &	operator*= (tlfloat_uint128_t &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_int128_t	operator/ (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)\|\|(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>
static tlfloat_uint128_t	operator/ (const T &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_int128_t	operator/ (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static tlfloat_int128_t	operator/ (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static tlfloat_uint128_t	operator/ (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static tlfloat_uint128_t	operator/ (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename rhstype >
static tlfloat_int128_t &	operator/= (tlfloat_int128_t &lhs, const rhstype &rhs)

template<typename rhstype >
static tlfloat_uint128_t &	operator/= (tlfloat_uint128_t &lhs, const rhstype &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator== (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator== (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator== (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator== (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator== (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator== (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator== (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator== (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator!= (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator!= (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator!= (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator!= (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator!= (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator!= (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator!= (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator!= (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator< (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator< (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator< (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator< (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator< (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator< (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator< (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator< (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator<= (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator<= (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator<= (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator<= (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator<= (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator<= (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator<= (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator<= (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator> (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator> (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator> (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator> (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator> (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator> (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator> (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator> (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator>= (const T &lhs, const tlfloat_int128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator>= (const tlfloat_int128_t &lhs, const T &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator>= (const T &lhs, const tlfloat_uint128_t &rhs)

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>
static bool	operator>= (const tlfloat_uint128_t &lhs, const T &rhs)

static bool	operator>= (const tlfloat_int128_t &lhs, const tlfloat_int128_t_ &rhs)

static bool	operator>= (const tlfloat_int128_t_ &lhs, const tlfloat_int128_t &rhs)

static bool	operator>= (const tlfloat_uint128_t &lhs, const tlfloat_uint128_t_ &rhs)

static bool	operator>= (const tlfloat_uint128_t_ &lhs, const tlfloat_uint128_t &rhs)

static tlfloat_octuple	tlfloat_fmao (const tlfloat_octuple x, const tlfloat_octuple y, const tlfloat_octuple z)

static tlfloat_octuple	tlfloat_sqrto (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_fabso (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_copysigno (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_fmaxo (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_fmino (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_fdimo (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_ldexpo (const tlfloat_octuple x, const int y)

static tlfloat_octuple	tlfloat_frexpo (const tlfloat_octuple x, int *y)

static tlfloat_octuple	tlfloat_modfo (const tlfloat_octuple x, tlfloat_octuple *y)

static tlfloat_octuple	tlfloat_nextaftero (const tlfloat_octuple x, const tlfloat_octuple y)

static int	tlfloat_ilogbo (const tlfloat_octuple x)

static int	tlfloat_isnano (const tlfloat_octuple x)

static int	tlfloat_isinfo (const tlfloat_octuple x)

static int	tlfloat_finiteo (const tlfloat_octuple x)

static int	tlfloat_signbito (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_hypoto (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_trunco (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_flooro (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_ceilo (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_roundo (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_rinto (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_sino (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_coso (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_tano (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_sinpio (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_cospio (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_tanpio (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_asino (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_acoso (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_atano (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_atan2o (const tlfloat_octuple y, const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_expo (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_expm1o (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_exp2o (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_exp10o (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_logo (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_log1po (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_log2o (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_log10o (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_powo (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_cbrto (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_sinho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_cosho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_tanho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_asinho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_acosho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_atanho (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_erfo (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_erfco (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_tgammao (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_lgammao (const tlfloat_octuple x)

static tlfloat_octuple	tlfloat_fmodo (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_remaindero (const tlfloat_octuple x, const tlfloat_octuple y)

static tlfloat_octuple	tlfloat_remquoo (const tlfloat_octuple x, const tlfloat_octuple y, int *quo)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Macro Definition Documentation

◆ FLT128_DENORM_MIN

#define FLT128_DENORM_MIN TLFLOAT_FLT128_DENORM_MIN

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_DIG

#define FLT128_DIG 33

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_EPSILON

#define FLT128_EPSILON TLFLOAT_FLT128_EPSILON

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MANT_DIG

#define FLT128_MANT_DIG 113

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MAX

#define FLT128_MAX TLFLOAT_FLT128_MAX

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MAX_10_EXP

#define FLT128_MAX_10_EXP 4932

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MAX_EXP

#define FLT128_MAX_EXP 16384

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MIN

#define FLT128_MIN TLFLOAT_FLT128_MIN

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MIN_10_EXP

#define FLT128_MIN_10_EXP (-4931)

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ FLT128_MIN_EXP

#define FLT128_MIN_EXP (-16381)

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_1_PIq

#define M_1_PIq TLFLOAT_M_1_PIq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_2_PIq

#define M_2_PIq TLFLOAT_M_2_PIq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_2_SQRTPIq

#define M_2_SQRTPIq TLFLOAT_M_2_SQRTPIq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_Eq

#define M_Eq TLFLOAT_M_Eq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_LN10q

#define M_LN10q TLFLOAT_M_LN10q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_LN2q

#define M_LN2q TLFLOAT_M_LN2q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_LOG10Eq

#define M_LOG10Eq TLFLOAT_M_LOG10Eq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_LOG2Eq

#define M_LOG2Eq TLFLOAT_M_LOG2Eq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_PI_2q

#define M_PI_2q TLFLOAT_M_PI_2q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_PI_4q

#define M_PI_4q TLFLOAT_M_PI_4q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_PIq

#define M_PIq TLFLOAT_M_PIq

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_SQRT1_2q

#define M_SQRT1_2q TLFLOAT_M_SQRT1_2q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ M_SQRT2q

#define M_SQRT2q TLFLOAT_M_SQRT2q

This macro is defined only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined.

◆ TLFLOAT_FLT128_DENORM_MIN

#define TLFLOAT_FLT128_DENORM_MIN 0x0.0000000000000000000000000001p-16382Q

◆ TLFLOAT_FLT128_EPSILON

#define TLFLOAT_FLT128_EPSILON 0x1p-112Q

◆ TLFLOAT_FLT128_MAX

#define TLFLOAT_FLT128_MAX 0x1.ffffffffffffffffffffffffffffp+16383Q

◆ TLFLOAT_FLT128_MIN

#define TLFLOAT_FLT128_MIN 0x1p-16382Q

◆ TLFLOAT_FLT128_TRUE_MIN

#define TLFLOAT_FLT128_TRUE_MIN 0x0.0000000000000000000000000001p-16382Q

◆ TLFLOAT_FP_ILOGB0

#define TLFLOAT_FP_ILOGB0 ((int)0x80000000)

◆ TLFLOAT_FP_ILOGBNAN

#define TLFLOAT_FP_ILOGBNAN ((int)2147483647)

◆ TLFLOAT_FP_INFINITE

#define TLFLOAT_FP_INFINITE 1

◆ TLFLOAT_FP_NAN

#define TLFLOAT_FP_NAN 0

◆ TLFLOAT_FP_NORMAL

#define TLFLOAT_FP_NORMAL 4

◆ TLFLOAT_FP_SUBNORMAL

#define TLFLOAT_FP_SUBNORMAL 3

◆ TLFLOAT_FP_ZERO

#define TLFLOAT_FP_ZERO 2

◆ TLFLOAT_INT128_IS_STRUCT

#define TLFLOAT_INT128_IS_STRUCT

This macro is defined iff tlfloat_int128_t and tlfloat_uint128_t are not aliases of __int128_t and __uint128_t, but structs defined in tlfloat.h.

◆ TLFLOAT_LIBQUADMATH_EMULATION

#define TLFLOAT_LIBQUADMATH_EMULATION

Calls to libquadmath functions are replaced to the corresponding calls to tlfloat functions if this macro is defined

◆ TLFLOAT_M_1_PIq

#define TLFLOAT_M_1_PIq 0x1.45f306dc9c882a53f84eafa3ea6ap-2Q

◆ TLFLOAT_M_2_PIq

#define TLFLOAT_M_2_PIq 0x1.45f306dc9c882a53f84eafa3ea6ap-1Q

◆ TLFLOAT_M_2_SQRTPIq

#define TLFLOAT_M_2_SQRTPIq 0x1.20dd750429b6d11ae3a914fed7fep+0Q

◆ TLFLOAT_M_Eq

#define TLFLOAT_M_Eq 0x1.5bf0a8b1457695355fb8ac404e7ap+1Q

◆ TLFLOAT_M_LN10q

#define TLFLOAT_M_LN10q 0x1.26bb1bbb5551582dd4adac5705a6p+1Q

◆ TLFLOAT_M_LN2q

#define TLFLOAT_M_LN2q 0x1.62e42fefa39ef35793c7673007e6p-1Q

◆ TLFLOAT_M_LOG10Eq

#define TLFLOAT_M_LOG10Eq 0x1.bcb7b1526e50e32a6ab7555f5a68p-2Q

◆ TLFLOAT_M_LOG2Eq

#define TLFLOAT_M_LOG2Eq 0x1.71547652b82fe1777d0ffda0d23ap+0Q

◆ TLFLOAT_M_PI_2q

#define TLFLOAT_M_PI_2q 0x1.921fb54442d18469898cc51701b8p+0Q

◆ TLFLOAT_M_PI_4q

#define TLFLOAT_M_PI_4q 0x1.921fb54442d18469898cc51701b8p-1Q

◆ TLFLOAT_M_PIq

#define TLFLOAT_M_PIq 0x1.921fb54442d18469898cc51701b8p+1Q

◆ TLFLOAT_M_SQRT1_2q

#define TLFLOAT_M_SQRT1_2q 0x1.6a09e667f3bcc908b2fb1366ea95p-1Q

◆ TLFLOAT_M_SQRT2q

#define TLFLOAT_M_SQRT2q 0x1.6a09e667f3bcc908b2fb1366ea95p+0Q

◆ TLFLOAT_POLYFUNC_f_f

#define TLFLOAT_POLYFUNC_f_f ( OP )

Value:

  static inline float OP ## _(const float &x) { return tlfloat_ ## OP ## f(x); } \
  static inline double OP ## _(const double &x) { return tlfloat_ ## OP(x); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x) { return tlfloat_ ## OP ## q(x); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x) { return tlfloat_ ## OP ## o(x); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_f

#define TLFLOAT_POLYFUNC_f_f_f ( OP )

Value:

  static inline float OP ## _(const float &x, const float &y) { return tlfloat_ ## OP ## f(x, y); } \
  static inline double OP ## _(const double &x, const double &y) { return tlfloat_ ## OP(x, y); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, const tlfloat_quad &y) { return tlfloat_ ## OP ## q(x, y); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, const tlfloat_octuple &y) { return tlfloat_ ## OP ## o(x, y); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_f_f

#define TLFLOAT_POLYFUNC_f_f_f_f ( OP )

Value:

  static inline float OP ## _(const float &x, const float &y, const float &z) { return tlfloat_ ## OP ## f(x, y, z); } \
  static inline double OP ## _(const double &x, const double &y, const double &z) { return tlfloat_ ## OP(x, y, z); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, const tlfloat_quad &y, const tlfloat_quad &z) { return tlfloat_ ## OP ## q(x, y, z); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, const tlfloat_octuple &y, const tlfloat_octuple &z) { return tlfloat_ ## OP ## o(x, y, z); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_f_pi

#define TLFLOAT_POLYFUNC_f_f_f_pi ( OP )

Value:

  static inline float OP ## _(const float &x, const float &y, int *z) { return tlfloat_ ## OP ## f(x, y, z); } \
  static inline double OP ## _(const double &x, const double &y, int *z) { return tlfloat_ ## OP(x, y, z); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, const tlfloat_quad &y, int *z) { return tlfloat_ ## OP ## q(x, y, z); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, const tlfloat_octuple &y, int *z) { return tlfloat_ ## OP ## o(x, y, z); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_i

#define TLFLOAT_POLYFUNC_f_f_i ( OP )

Value:

  static inline float OP ## _(const float &x, const int &y) { return tlfloat_ ## OP ## f(x, y); } \
  static inline double OP ## _(const double &x, const int &y) { return tlfloat_ ## OP(x, y); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, const int &y) { return tlfloat_ ## OP ## q(x, y); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, const int &y) { return tlfloat_ ## OP ## o(x, y); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_pf

#define TLFLOAT_POLYFUNC_f_f_pf ( OP )

Value:

  static inline float OP ## _(const float &x, float *y) { return tlfloat_ ## OP ## f(x, y); } \
  static inline double OP ## _(const double &x, double *y) { return tlfloat_ ## OP(x, y); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, tlfloat_quad *y) { return tlfloat_ ## OP ## q(x, y); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, tlfloat_octuple *y) { return tlfloat_ ## OP ## o(x, y); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_f_f_pi

#define TLFLOAT_POLYFUNC_f_f_pi ( OP )

Value:

  static inline float OP ## _(const float &x, int *y) { return tlfloat_ ## OP ## f(x, y); } \
  static inline double OP ## _(const double &x, int *y) { return tlfloat_ ## OP(x, y); } \
  static inline tlfloat_quad OP ## _(const tlfloat_quad &x, int *y) { return tlfloat_ ## OP ## q(x, y); } \
  static inline tlfloat_octuple OP ## _(const tlfloat_octuple &x, int *y) { return tlfloat_ ## OP ## o(x, y); } \
  static_assert(true, "")

◆ TLFLOAT_POLYFUNC_i_f

#define TLFLOAT_POLYFUNC_i_f ( OP )

Value:

  static inline int OP ## _(const float &x) { return tlfloat_ ## OP ## f(x); } \
  static inline int OP ## _(const double &x) { return tlfloat_ ## OP(x); } \
  static inline int OP ## _(const tlfloat_quad &x) { return tlfloat_ ## OP ## q(x); } \
  static inline int OP ## _(const tlfloat_octuple &x) { return tlfloat_ ## OP ## o(x); } \
  static_assert(true, "")

◆ TLFLOAT_QUAD_IS_STRUCT

#define TLFLOAT_QUAD_IS_STRUCT

This macro is defined iff tlfloat_quad is not an alias of __float128, but a struct defined in tlfloat.h.

Function Documentation

◆ acoshq()

static tlfloat_quad acoshq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ acosq()

static tlfloat_quad acosq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ asinhq()

static tlfloat_quad asinhq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ asinq()

static tlfloat_quad asinq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ atan2q()

static tlfloat_quad atan2q	(	const tlfloat_quad	y,
		const tlfloat_quad	x
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ atanhq()

static tlfloat_quad atanhq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ atanq()

static tlfloat_quad atanq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ cbrtq()

static tlfloat_quad cbrtq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ ceilq()

static tlfloat_quad ceilq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ copysignq()

static tlfloat_quad copysignq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ coshq()

static tlfloat_quad coshq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ cosq()

static tlfloat_quad cosq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ erfcq()

static tlfloat_quad erfcq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ erfq()

static tlfloat_quad erfq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ exp10q()

static tlfloat_quad exp10q ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ exp2q()

static tlfloat_quad exp2q ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ expm1q()

static tlfloat_quad expm1q ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ expq()

static tlfloat_quad expq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fabsq()

static tlfloat_quad fabsq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fdimq()

static tlfloat_quad fdimq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ finiteq()

static int finiteq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ floorq()

static tlfloat_quad floorq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fmaq()

static tlfloat_quad fmaq	(	const tlfloat_quad	x,
		const tlfloat_quad	y,
		const tlfloat_quad	z
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fmaxq()

static tlfloat_quad fmaxq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fminq()

static tlfloat_quad fminq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fmodq()

static tlfloat_quad fmodq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ fpclassifyq()

static int fpclassifyq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ frexpq()

static tlfloat_quad frexpq	(	const tlfloat_quad	x,
		int *	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ hypotq()

static tlfloat_quad hypotq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ ilogbq()

static int ilogbq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ isinfq()

static int isinfq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ isnanq()

static int isnanq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ ldexpq()

static tlfloat_quad ldexpq	(	const tlfloat_quad	x,
		const int	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ lgammaq()

static tlfloat_quad lgammaq ( const tlfloat_quad x )

inlinestatic

This is experimental implementation of log gamma function. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ log10q()

static tlfloat_quad log10q ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ log1pq()

static tlfloat_quad log1pq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ log2q()

static tlfloat_quad log2q ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ logq()

static tlfloat_quad logq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ modfq()

static tlfloat_quad modfq	(	const tlfloat_quad	x,
		tlfloat_quad *	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ nextafterq()

static tlfloat_quad nextafterq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ operator!=() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator!=	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator!=() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator!=	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator!=() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator!=	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator!=() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator!=	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator!=() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator!=	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator!=() [6/18]

static bool operator!=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator!=() [7/18]

static bool operator!=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator!=() [8/18]

static bool operator!=	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator!=() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator!=	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator!=() [10/18]

static bool operator!=	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator!=() [11/18]

static bool operator!=	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator!=() [12/18]

static bool operator!=	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator!=() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator!=	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator!=() [14/18]

static bool operator!=	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator!=() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator!=	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator!=() [16/18]

static bool operator!=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator!=() [17/18]

static bool operator!=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator!=() [18/18]

static bool operator!=	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator*() [1/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_int128_t operator*	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator*() [2/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator*	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator*() [3/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator*	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator*() [4/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_uint128_t operator*	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator*() [5/20]

static tlfloat_int128_t operator*	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator*() [6/20]

static tlfloat_octuple operator*	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator*() [7/20]

static tlfloat_quad operator*	(	const tlfloat_int128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator*() [8/20]

static tlfloat_int128_t operator*	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator*() [9/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator*	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator*() [10/20]

static tlfloat_octuple operator*	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator*() [11/20]

static tlfloat_octuple operator*	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator*() [12/20]

static tlfloat_octuple operator*	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator*() [13/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator*	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator*() [14/20]

static tlfloat_quad operator*	(	const tlfloat_quad &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator*() [15/20]

static tlfloat_octuple operator*	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator*() [16/20]

static tlfloat_quad operator*	(	const tlfloat_quad &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator*() [17/20]

static tlfloat_octuple operator*	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator*() [18/20]

static tlfloat_quad operator*	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator*() [19/20]

static tlfloat_uint128_t operator*	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator*() [20/20]

static tlfloat_uint128_t operator*	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator*=() [1/4]

template<typename rhstype >

static tlfloat_int128_t & operator*=	(	tlfloat_int128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator*=() [2/4]

template<typename rhstype >

static tlfloat_octuple & operator*=	(	tlfloat_octuple &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator*=() [3/4]

template<typename rhstype >

static tlfloat_quad & operator*=	(	tlfloat_quad &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator*=() [4/4]

template<typename rhstype >

static tlfloat_uint128_t & operator*=	(	tlfloat_uint128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator+() [1/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_int128_t operator+	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator+() [2/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator+	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator+() [3/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator+	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator+() [4/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_uint128_t operator+	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator+() [5/20]

static tlfloat_int128_t operator+	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator+() [6/20]

static tlfloat_octuple operator+	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator+() [7/20]

static tlfloat_quad operator+	(	const tlfloat_int128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator+() [8/20]

static tlfloat_int128_t operator+	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator+() [9/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator+	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator+() [10/20]

static tlfloat_octuple operator+	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator+() [11/20]

static tlfloat_octuple operator+	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator+() [12/20]

static tlfloat_octuple operator+	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator+() [13/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator+	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator+() [14/20]

static tlfloat_quad operator+	(	const tlfloat_quad &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator+() [15/20]

static tlfloat_octuple operator+	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator+() [16/20]

static tlfloat_quad operator+	(	const tlfloat_quad &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator+() [17/20]

static tlfloat_octuple operator+	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator+() [18/20]

static tlfloat_quad operator+	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator+() [19/20]

static tlfloat_uint128_t operator+	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator+() [20/20]

static tlfloat_uint128_t operator+	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator+=() [1/4]

template<typename rhstype >

static tlfloat_int128_t & operator+=	(	tlfloat_int128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator+=() [2/4]

template<typename rhstype >

static tlfloat_octuple & operator+=	(	tlfloat_octuple &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator+=() [3/4]

template<typename rhstype >

static tlfloat_quad & operator+=	(	tlfloat_quad &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator+=() [4/4]

template<typename rhstype >

static tlfloat_uint128_t & operator+=	(	tlfloat_uint128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator-() [1/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_int128_t operator-	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator-() [2/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator-	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator-() [3/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator-	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator-() [4/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_uint128_t operator-	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator-() [5/20]

static tlfloat_int128_t operator-	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator-() [6/20]

static tlfloat_octuple operator-	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator-() [7/20]

static tlfloat_quad operator-	(	const tlfloat_int128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator-() [8/20]

static tlfloat_int128_t operator-	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator-() [9/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator-	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator-() [10/20]

static tlfloat_octuple operator-	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator-() [11/20]

static tlfloat_octuple operator-	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator-() [12/20]

static tlfloat_octuple operator-	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator-() [13/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator-	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator-() [14/20]

static tlfloat_quad operator-	(	const tlfloat_quad &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator-() [15/20]

static tlfloat_octuple operator-	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator-() [16/20]

static tlfloat_quad operator-	(	const tlfloat_quad &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator-() [17/20]

static tlfloat_octuple operator-	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator-() [18/20]

static tlfloat_quad operator-	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator-() [19/20]

static tlfloat_uint128_t operator-	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator-() [20/20]

static tlfloat_uint128_t operator-	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator-=() [1/4]

template<typename rhstype >

static tlfloat_int128_t & operator-=	(	tlfloat_int128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator-=() [2/4]

template<typename rhstype >

static tlfloat_octuple & operator-=	(	tlfloat_octuple &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator-=() [3/4]

template<typename rhstype >

static tlfloat_quad & operator-=	(	tlfloat_quad &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator-=() [4/4]

template<typename rhstype >

static tlfloat_uint128_t & operator-=	(	tlfloat_uint128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator/() [1/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_int128_t operator/	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator/() [2/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator/	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator/() [3/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator/	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator/() [4/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_uint128_t operator/	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator/() [5/20]

static tlfloat_int128_t operator/	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator/() [6/20]

static tlfloat_octuple operator/	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator/() [7/20]

static tlfloat_quad operator/	(	const tlfloat_int128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator/() [8/20]

static tlfloat_int128_t operator/	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator/() [9/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_octuple operator/	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator/() [10/20]

static tlfloat_octuple operator/	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator/() [11/20]

static tlfloat_octuple operator/	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator/() [12/20]

static tlfloat_octuple operator/	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator/() [13/20]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static tlfloat_quad operator/	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator/() [14/20]

static tlfloat_quad operator/	(	const tlfloat_quad &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator/() [15/20]

static tlfloat_octuple operator/	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator/() [16/20]

static tlfloat_quad operator/	(	const tlfloat_quad &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator/() [17/20]

static tlfloat_octuple operator/	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator/() [18/20]

static tlfloat_quad operator/	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator/() [19/20]

static tlfloat_uint128_t operator/	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator/() [20/20]

static tlfloat_uint128_t operator/	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator/=() [1/4]

template<typename rhstype >

static tlfloat_int128_t & operator/=	(	tlfloat_int128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator/=() [2/4]

template<typename rhstype >

static tlfloat_octuple & operator/=	(	tlfloat_octuple &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator/=() [3/4]

template<typename rhstype >

static tlfloat_quad & operator/=	(	tlfloat_quad &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator/=() [4/4]

template<typename rhstype >

static tlfloat_uint128_t & operator/=	(	tlfloat_uint128_t &	lhs,
		const rhstype &	rhs
	)

inlinestatic

◆ operator<() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator<() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator<() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<() [6/18]

static bool operator<	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator<() [7/18]

static bool operator<	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<() [8/18]

static bool operator<	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<() [10/18]

static bool operator<	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<() [11/18]

static bool operator<	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator<() [12/18]

static bool operator<	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator<() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<() [14/18]

static bool operator<	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<() [16/18]

static bool operator<	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<() [17/18]

static bool operator<	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator<() [18/18]

static bool operator<	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator<=() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<=	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<=() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<=	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<=() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<=	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator<=() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<=	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator<=() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<=	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<=() [6/18]

static bool operator<=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator<=() [7/18]

static bool operator<=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<=() [8/18]

static bool operator<=	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<=() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<=	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<=() [10/18]

static bool operator<=	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator<=() [11/18]

static bool operator<=	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator<=() [12/18]

static bool operator<=	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator<=() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator<=	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<=() [14/18]

static bool operator<=	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<=() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator<=	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator<=() [16/18]

static bool operator<=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator<=() [17/18]

static bool operator<=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator<=() [18/18]

static bool operator<=	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator==() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator==	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator==() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator==	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator==() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator==	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator==() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator==	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator==() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator==	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator==() [6/18]

static bool operator==	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator==() [7/18]

static bool operator==	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator==() [8/18]

static bool operator==	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator==() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator==	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator==() [10/18]

static bool operator==	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator==() [11/18]

static bool operator==	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator==() [12/18]

static bool operator==	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator==() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator==	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator==() [14/18]

static bool operator==	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator==() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator==	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator==() [16/18]

static bool operator==	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator==() [17/18]

static bool operator==	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator==() [18/18]

static bool operator==	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator>() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>() [6/18]

static bool operator>	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator>() [7/18]

static bool operator>	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>() [8/18]

static bool operator>	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>() [10/18]

static bool operator>	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>() [11/18]

static bool operator>	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator>() [12/18]

static bool operator>	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>() [14/18]

static bool operator>	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>() [16/18]

static bool operator>	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>() [17/18]

static bool operator>	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator>() [18/18]

static bool operator>	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>=() [1/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>=	(	const T &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>=() [2/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>=	(	const T &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>=() [3/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>=	(	const T &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator>=() [4/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>=	(	const T &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>=() [5/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>=	(	const tlfloat_int128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>=() [6/18]

static bool operator>=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_int128_t_ &	rhs
	)

inlinestatic

◆ operator>=() [7/18]

static bool operator>=	(	const tlfloat_int128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>=() [8/18]

static bool operator>=	(	const tlfloat_int128_t_ &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>=() [9/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>=	(	const tlfloat_octuple &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>=() [10/18]

static bool operator>=	(	const tlfloat_octuple &	lhs,
		const tlfloat_int128_t &	rhs
	)

inlinestatic

◆ operator>=() [11/18]

static bool operator>=	(	const tlfloat_octuple &	lhs,
		const tlfloat_quad &	rhs
	)

inlinestatic

◆ operator>=() [12/18]

static bool operator>=	(	const tlfloat_octuple &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ operator>=() [13/18]

template<typename T , typename std::enable_if<((std::is_floating_point< T >::value &&sizeof(T)<=8)||(std::is_integral< T >::value &&sizeof(T)<=8)), int >::type = 0>

static bool operator>=	(	const tlfloat_quad &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>=() [14/18]

static bool operator>=	(	const tlfloat_quad &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>=() [15/18]

template<typename T , typename std::enable_if<(std::is_integral< T >::value &&sizeof(T)<=8), int >::type = 0>

static bool operator>=	(	const tlfloat_uint128_t &	lhs,
		const T &	rhs
	)

inlinestatic

◆ operator>=() [16/18]

static bool operator>=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_octuple &	rhs
	)

inlinestatic

◆ operator>=() [17/18]

static bool operator>=	(	const tlfloat_uint128_t &	lhs,
		const tlfloat_uint128_t_ &	rhs
	)

inlinestatic

◆ operator>=() [18/18]

static bool operator>=	(	const tlfloat_uint128_t_ &	lhs,
		const tlfloat_uint128_t &	rhs
	)

inlinestatic

◆ powq()

static tlfloat_quad powq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ quadmath_snprintf()

static int quadmath_snprintf	(	char *	str,
		size_t	size,
		const char *	fmt,
			...
	)

inlinestatic

This function is designed to be used as a replacement for the function of the same name in quadmath.h, but it is actually an alias of tlfloat_snprintf. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ remainderq()

static tlfloat_quad remainderq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ remquoq()

static tlfloat_quad remquoq	(	const tlfloat_quad	x,
		const tlfloat_quad	y,
		int *	quo
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ rintq()

static tlfloat_quad rintq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ roundq()

static tlfloat_quad roundq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ signbitq()

static int signbitq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ sincosq()

static void sincosq	(	const tlfloat_quad	x,
		tlfloat_quad *	s,
		tlfloat_quad *	c
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ sinhq()

static tlfloat_quad sinhq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ sinq()

static tlfloat_quad sinq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ sqrtq()

static tlfloat_quad sqrtq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ strtoflt128()

static tlfloat_quad strtoflt128	(	const char *	s,
		const char **	sp
	)

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ tanhq()

static tlfloat_quad tanhq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ tanq()

static tlfloat_quad tanq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ tgammaq()

static tlfloat_quad tgammaq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

◆ tlfloat_acos()

double tlfloat_acos ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acosf()

float tlfloat_acosf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acosh()

double tlfloat_acosh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acoshf()

float tlfloat_acoshf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acosho()

static tlfloat_octuple tlfloat_acosho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acoshq()

static tlfloat_quad tlfloat_acoshq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acoso()

static tlfloat_octuple tlfloat_acoso ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_acosq()

static tlfloat_quad tlfloat_acosq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_add()

double tlfloat_add	(	const double	x,
		const double	y
	)

◆ tlfloat_add_i128_i128()

tlfloat_int128_t_ tlfloat_add_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_add_u128_u128()

tlfloat_uint128_t_ tlfloat_add_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_addf()

float tlfloat_addf	(	const float	x,
		const float	y
	)

◆ tlfloat_addo()

tlfloat_octuple_ tlfloat_addo	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs addition of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_addq()

tlfloat_quad_ tlfloat_addq	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs addition of two quadruple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_and_i128_i128()

tlfloat_int128_t_ tlfloat_and_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_and_u128_u128()

tlfloat_uint128_t_ tlfloat_and_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_asin()

double tlfloat_asin ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinf()

float tlfloat_asinf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinh()

double tlfloat_asinh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinhf()

float tlfloat_asinhf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinho()

static tlfloat_octuple tlfloat_asinho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinhq()

static tlfloat_quad tlfloat_asinhq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asino()

static tlfloat_octuple tlfloat_asino ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_asinq()

static tlfloat_quad tlfloat_asinq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atan()

double tlfloat_atan ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atan2()

double tlfloat_atan2	(	const double	y,
		const double	x
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atan2f()

float tlfloat_atan2f	(	const float	y,
		const float	x
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atan2o()

static tlfloat_octuple tlfloat_atan2o	(	const tlfloat_octuple	y,
		const tlfloat_octuple	x
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atan2q()

static tlfloat_quad tlfloat_atan2q	(	const tlfloat_quad	y,
		const tlfloat_quad	x
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanf()

float tlfloat_atanf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanh()

double tlfloat_atanh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanhf()

float tlfloat_atanhf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanho()

static tlfloat_octuple tlfloat_atanho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanhq()

static tlfloat_quad tlfloat_atanhq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atano()

static tlfloat_octuple tlfloat_atano ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_atanq()

static tlfloat_quad tlfloat_atanq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cast_d_i128()

double tlfloat_cast_d_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_cast_d_o()

double tlfloat_cast_d_o ( const tlfloat_octuple_ x )

This function casts a octuple-precision FP number to a double-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_d_q()

double tlfloat_cast_d_q ( const tlfloat_quad_ x )

This function casts a quadruple-precision FP number to a double-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_d_u128()

double tlfloat_cast_d_u128 ( const tlfloat_uint128_t_ x )

◆ tlfloat_cast_i128_d()

tlfloat_int128_t_ tlfloat_cast_i128_d ( const double x )

◆ tlfloat_cast_i128_i64()

tlfloat_int128_t_ tlfloat_cast_i128_i64 ( const int64_t x )

◆ tlfloat_cast_i128_o()

tlfloat_int128_t_ tlfloat_cast_i128_o ( const tlfloat_octuple_ x )

◆ tlfloat_cast_i128_q()

tlfloat_int128_t_ tlfloat_cast_i128_q ( const tlfloat_quad_ x )

◆ tlfloat_cast_i64_i128()

int64_t tlfloat_cast_i64_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_cast_i64_o()

int64_t tlfloat_cast_i64_o ( const tlfloat_octuple_ x )

This function casts a octuple-precision FP number to a 64-bit signed integer. Link with -ltlfloat.

◆ tlfloat_cast_i64_q()

int64_t tlfloat_cast_i64_q ( const tlfloat_quad_ x )

This function casts a quadruple-precision FP number to a 64-bit signed integer. Link with -ltlfloat.

◆ tlfloat_cast_o_d()

tlfloat_octuple_ tlfloat_cast_o_d ( const double x )

This function casts a double-precision FP number to a octuple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_o_i128()

tlfloat_octuple_ tlfloat_cast_o_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_cast_o_i64()

tlfloat_octuple_ tlfloat_cast_o_i64 ( const int64_t x )

This function casts a 64-bit signed integer to a octuple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_o_q()

tlfloat_octuple_ tlfloat_cast_o_q ( const tlfloat_quad_ x )

This function casts a quadruple-precision FP number to a octuple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_o_u128()

tlfloat_octuple_ tlfloat_cast_o_u128 ( const tlfloat_uint128_t_ x )

◆ tlfloat_cast_o_u64()

tlfloat_octuple_ tlfloat_cast_o_u64 ( const uint64_t x )

This function casts a 64-bit unsigned integer to a octuple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_q_d()

tlfloat_quad_ tlfloat_cast_q_d ( const double x )

This function casts a double-precision FP number to a quadruple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_q_i128()

tlfloat_quad_ tlfloat_cast_q_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_cast_q_i64()

tlfloat_quad_ tlfloat_cast_q_i64 ( const int64_t x )

This function casts a 64-bit signed integer to a quadruple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_q_o()

tlfloat_quad_ tlfloat_cast_q_o ( const tlfloat_octuple_ x )

This function casts a octuple-precision FP number to a quadruple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_q_u128()

tlfloat_quad_ tlfloat_cast_q_u128 ( const tlfloat_uint128_t_ x )

◆ tlfloat_cast_q_u64()

tlfloat_quad_ tlfloat_cast_q_u64 ( const uint64_t x )

This function casts a 64-bit unsigned integer to a quadruple-precision FP number. Link with -ltlfloat.

◆ tlfloat_cast_u128_d()

tlfloat_uint128_t_ tlfloat_cast_u128_d ( const double x )

◆ tlfloat_cast_u128_o()

tlfloat_uint128_t_ tlfloat_cast_u128_o ( const tlfloat_octuple_ x )

◆ tlfloat_cast_u128_q()

tlfloat_uint128_t_ tlfloat_cast_u128_q ( const tlfloat_quad_ x )

◆ tlfloat_cast_u128_u64()

tlfloat_uint128_t_ tlfloat_cast_u128_u64 ( const uint64_t x )

◆ tlfloat_cast_u64_o()

uint64_t tlfloat_cast_u64_o ( const tlfloat_octuple_ x )

This function casts a octuple-precision FP number to a 64-bit unsigned integer. Link with -ltlfloat.

◆ tlfloat_cast_u64_q()

uint64_t tlfloat_cast_u64_q ( const tlfloat_quad_ x )

This function casts a quadruple-precision FP number to a 64-bit unsigned integer. Link with -ltlfloat.

◆ tlfloat_cast_u64_u128()

uint64_t tlfloat_cast_u64_u128 ( const tlfloat_uint128_t_ x )

◆ tlfloat_cbrt()

double tlfloat_cbrt ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cbrtf()

float tlfloat_cbrtf ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cbrto()

static tlfloat_octuple tlfloat_cbrto ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cbrtq()

static tlfloat_quad tlfloat_cbrtq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ceil()

double tlfloat_ceil ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ceilf()

float tlfloat_ceilf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ceilo()

static tlfloat_octuple tlfloat_ceilo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ceilq()

static tlfloat_quad tlfloat_ceilq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_copysign()

double tlfloat_copysign	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_copysignf()

float tlfloat_copysignf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_copysigno()

static tlfloat_octuple tlfloat_copysigno	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_copysignq()

static tlfloat_quad tlfloat_copysignq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cos()

double tlfloat_cos ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cosf()

float tlfloat_cosf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cosh()

double tlfloat_cosh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_coshf()

float tlfloat_coshf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cosho()

static tlfloat_octuple tlfloat_cosho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_coshq()

static tlfloat_quad tlfloat_coshq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_coso()

static tlfloat_octuple tlfloat_coso ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_cospi()

double tlfloat_cospi ( const double x )

◆ tlfloat_cospif()

float tlfloat_cospif ( const float x )

◆ tlfloat_cospio()

static tlfloat_octuple tlfloat_cospio ( const tlfloat_octuple x )

inlinestatic

◆ tlfloat_cospiq()

static tlfloat_quad tlfloat_cospiq ( const tlfloat_quad x )

inlinestatic

◆ tlfloat_cosq()

static tlfloat_quad tlfloat_cosq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_div()

double tlfloat_div	(	const double	x,
		const double	y
	)

◆ tlfloat_div_i128_i128()

tlfloat_int128_t_ tlfloat_div_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_div_u128_u128()

tlfloat_uint128_t_ tlfloat_div_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_divf()

float tlfloat_divf	(	const float	x,
		const float	y
	)

◆ tlfloat_divo()

tlfloat_octuple_ tlfloat_divo	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs division of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_divq()

tlfloat_quad_ tlfloat_divq	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs division of two quadruple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_eq_i128_i128()

int tlfloat_eq_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_eq_o_o()

int tlfloat_eq_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_eq_q_q()

int tlfloat_eq_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_eq_u128_u128()

int tlfloat_eq_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_erf()

double tlfloat_erf ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfc()

double tlfloat_erfc ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfcf()

float tlfloat_erfcf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfco()

static tlfloat_octuple tlfloat_erfco ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfcq()

static tlfloat_quad tlfloat_erfcq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erff()

float tlfloat_erff ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfo()

static tlfloat_octuple tlfloat_erfo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_erfq()

static tlfloat_quad tlfloat_erfq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp()

double tlfloat_exp ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp10()

double tlfloat_exp10 ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp10f()

float tlfloat_exp10f ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp10o()

static tlfloat_octuple tlfloat_exp10o ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp10q()

static tlfloat_quad tlfloat_exp10q ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp2()

double tlfloat_exp2 ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp2f()

float tlfloat_exp2f ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp2o()

static tlfloat_octuple tlfloat_exp2o ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_exp2q()

static tlfloat_quad tlfloat_exp2q ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expf()

float tlfloat_expf ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expm1()

double tlfloat_expm1 ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expm1f()

float tlfloat_expm1f ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expm1o()

static tlfloat_octuple tlfloat_expm1o ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expm1q()

static tlfloat_quad tlfloat_expm1q ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expo()

static tlfloat_octuple tlfloat_expo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_expq()

static tlfloat_quad tlfloat_expq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fabs()

double tlfloat_fabs ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fabsf()

float tlfloat_fabsf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fabso()

static tlfloat_octuple tlfloat_fabso ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fabsq()

static tlfloat_quad tlfloat_fabsq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fdim()

double tlfloat_fdim	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fdimf()

float tlfloat_fdimf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fdimo()

static tlfloat_octuple tlfloat_fdimo	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fdimq()

static tlfloat_quad tlfloat_fdimq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_finite()

int tlfloat_finite ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_finitef()

int tlfloat_finitef ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_finiteo()

static int tlfloat_finiteo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_finiteq()

static int tlfloat_finiteq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_floor()

double tlfloat_floor ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_floorf()

float tlfloat_floorf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_flooro()

static tlfloat_octuple tlfloat_flooro ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_floorq()

static tlfloat_quad tlfloat_floorq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fma()

double tlfloat_fma	(	const double	x,
		const double	y,
		const double	z
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmaf()

float tlfloat_fmaf	(	const float	x,
		const float	y,
		const float	z
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmao() [1/2]

static tlfloat_octuple tlfloat_fmao	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y,
		const tlfloat_octuple	z
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmao() [2/2]

tlfloat_octuple_ tlfloat_fmao	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y,
		const tlfloat_octuple_	z
	)

◆ tlfloat_fmaq() [1/2]

static tlfloat_quad tlfloat_fmaq	(	const tlfloat_quad	x,
		const tlfloat_quad	y,
		const tlfloat_quad	z
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmaq() [2/2]

tlfloat_quad_ tlfloat_fmaq	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y,
		const tlfloat_quad_	z
	)

◆ tlfloat_fmax()

double tlfloat_fmax	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmaxf()

float tlfloat_fmaxf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmaxo()

static tlfloat_octuple tlfloat_fmaxo	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmaxq()

static tlfloat_quad tlfloat_fmaxq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmin()

double tlfloat_fmin	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fminf()

float tlfloat_fminf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmino()

static tlfloat_octuple tlfloat_fmino	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fminq()

static tlfloat_quad tlfloat_fminq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmod()

double tlfloat_fmod	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmodf()

float tlfloat_fmodf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmodo()

static tlfloat_octuple tlfloat_fmodo	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fmodq()

static tlfloat_quad tlfloat_fmodq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fpclassify()

int tlfloat_fpclassify ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fpclassifyf()

int tlfloat_fpclassifyf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fpclassifyq()

static int tlfloat_fpclassifyq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_fprintf()

int tlfloat_fprintf	(	FILE *	fp,
		const char *	fmt,
			...
	)

See explanation for tlfloat_printf()

◆ tlfloat_frexp()

double tlfloat_frexp	(	const double	x,
		int *	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_frexpf()

float tlfloat_frexpf	(	const float	x,
		int *	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_frexpo()

static tlfloat_octuple tlfloat_frexpo	(	const tlfloat_octuple	x,
		int *	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_frexpq()

static tlfloat_quad tlfloat_frexpq	(	const tlfloat_quad	x,
		int *	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ge_i128_i128()

int tlfloat_ge_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_ge_o_o()

int tlfloat_ge_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_ge_q_q()

int tlfloat_ge_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_ge_u128_u128()

int tlfloat_ge_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_gt_i128_i128()

int tlfloat_gt_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_gt_o_o()

int tlfloat_gt_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_gt_q_q()

int tlfloat_gt_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_gt_u128_u128()

int tlfloat_gt_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_hypot()

double tlfloat_hypot	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_hypotf()

float tlfloat_hypotf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_hypoto()

static tlfloat_octuple tlfloat_hypoto	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_hypotq()

static tlfloat_quad tlfloat_hypotq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ilogb()

int tlfloat_ilogb ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ilogbf()

int tlfloat_ilogbf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ilogbo()

static int tlfloat_ilogbo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ilogbq()

static int tlfloat_ilogbq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isinf()

int tlfloat_isinf ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isinff()

int tlfloat_isinff ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isinfo()

static int tlfloat_isinfo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isinfq()

static int tlfloat_isinfq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isnan()

int tlfloat_isnan ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isnanf()

int tlfloat_isnanf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isnano()

static int tlfloat_isnano ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_isnanq()

static int tlfloat_isnanq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ldexp()

double tlfloat_ldexp	(	const double	x,
		const int	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ldexpf()

float tlfloat_ldexpf	(	const float	x,
		const int	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ldexpo()

static tlfloat_octuple tlfloat_ldexpo	(	const tlfloat_octuple	x,
		const int	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_ldexpq()

static tlfloat_quad tlfloat_ldexpq	(	const tlfloat_quad	x,
		const int	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_le_i128_i128()

int tlfloat_le_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_le_o_o()

int tlfloat_le_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_le_q_q()

int tlfloat_le_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_le_u128_u128()

int tlfloat_le_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_lgamma()

double tlfloat_lgamma ( const double x )

This is experimental implementation of log gamma function. Link with -ltlfloat.

◆ tlfloat_lgammaf()

float tlfloat_lgammaf ( const float x )

This is experimental implementation of log gamma function. Link with -ltlfloat.

◆ tlfloat_lgammao()

static tlfloat_octuple tlfloat_lgammao ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_lgammaq()

static tlfloat_quad tlfloat_lgammaq ( const tlfloat_quad x )

inlinestatic

This is experimental implementation of log gamma function. Link with -ltlfloat.

◆ tlfloat_log()

double tlfloat_log ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log10()

double tlfloat_log10 ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log10f()

float tlfloat_log10f ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log10o()

static tlfloat_octuple tlfloat_log10o ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log10q()

static tlfloat_quad tlfloat_log10q ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log1p()

double tlfloat_log1p ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log1pf()

float tlfloat_log1pf ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log1po()

static tlfloat_octuple tlfloat_log1po ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log1pq()

static tlfloat_quad tlfloat_log1pq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log2()

double tlfloat_log2 ( const double a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log2f()

float tlfloat_log2f ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log2o()

static tlfloat_octuple tlfloat_log2o ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_log2q()

static tlfloat_quad tlfloat_log2q ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_logf()

float tlfloat_logf ( const float a )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_logo()

static tlfloat_octuple tlfloat_logo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_logq()

static tlfloat_quad tlfloat_logq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_lt_i128_i128()

int tlfloat_lt_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_lt_o_o()

int tlfloat_lt_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_lt_q_q()

int tlfloat_lt_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_lt_u128_u128()

int tlfloat_lt_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_mod_i128_i128()

tlfloat_int128_t_ tlfloat_mod_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_mod_u128_u128()

tlfloat_uint128_t_ tlfloat_mod_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_modf()

double tlfloat_modf	(	const double	x,
		double *	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_modff()

float tlfloat_modff	(	const float	x,
		float *	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_modfo()

static tlfloat_octuple tlfloat_modfo	(	const tlfloat_octuple	x,
		tlfloat_octuple *	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_modfq()

static tlfloat_quad tlfloat_modfq	(	const tlfloat_quad	x,
		tlfloat_quad *	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_mul()

double tlfloat_mul	(	const double	x,
		const double	y
	)

◆ tlfloat_mul_i128_i128()

tlfloat_int128_t_ tlfloat_mul_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_mul_u128_u128()

tlfloat_uint128_t_ tlfloat_mul_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_mulf()

float tlfloat_mulf	(	const float	x,
		const float	y
	)

◆ tlfloat_mulo()

tlfloat_octuple_ tlfloat_mulo	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs multiplication of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_mulq()

tlfloat_quad_ tlfloat_mulq	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs multiplication of two quadruple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_ne_i128_i128()

int tlfloat_ne_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_ne_o_o()

int tlfloat_ne_o_o	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs ordered comparison of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_ne_q_q()

int tlfloat_ne_q_q	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs ordered comparison of two quad-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_ne_u128_u128()

int tlfloat_ne_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_neg()

double tlfloat_neg ( const double x )

◆ tlfloat_neg_i128()

tlfloat_int128_t_ tlfloat_neg_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_negf()

float tlfloat_negf ( const float x )

◆ tlfloat_nego()

tlfloat_octuple_ tlfloat_nego ( const tlfloat_octuple_ x )

◆ tlfloat_negq()

tlfloat_quad_ tlfloat_negq ( const tlfloat_quad_ x )

◆ tlfloat_nextafter()

double tlfloat_nextafter	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_nextafterf()

float tlfloat_nextafterf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_nextaftero()

static tlfloat_octuple tlfloat_nextaftero	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_nextafterq()

static tlfloat_quad tlfloat_nextafterq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_not_i128()

tlfloat_int128_t_ tlfloat_not_i128 ( const tlfloat_int128_t_ x )

◆ tlfloat_not_u128()

tlfloat_uint128_t_ tlfloat_not_u128 ( const tlfloat_uint128_t_ x )

◆ tlfloat_or_i128_i128()

tlfloat_int128_t_ tlfloat_or_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_or_u128_u128()

tlfloat_uint128_t_ tlfloat_or_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_pow()

double tlfloat_pow	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_powf()

float tlfloat_powf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_powo()

static tlfloat_octuple tlfloat_powo	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_powq()

static tlfloat_quad tlfloat_powq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_printf()

int tlfloat_printf	(	const char *	fmt,
			...
	)

The tlfloat_printf family of functions has the functionality to produce output of numbers of the types defined in TLFloat library, in addition to the functionality of the standard printf family of functions. To output a number of type defined in TLFloat library, use _m as the length modifier where m is a decimal integer represents the data size of the corresponding argument in bits. For example, use '%_256g' to output an octuple-precision FP number, and '%_128d' to output a 128-bit signed integer. Q and O modifier have to be used to output an FP number in tlfloat_quad and tlfloat_octuple types, respectively.

◆ tlfloat_registerPrintfHook()

int tlfloat_registerPrintfHook ( )

This functionality is experimental. Please use tlfloat_printf functions instead. On systems with GLIBC, printf hooks can be registered by calling this function.

◆ tlfloat_remainder()

double tlfloat_remainder	(	const double	x,
		const double	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remainderf()

float tlfloat_remainderf	(	const float	x,
		const float	y
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remaindero()

static tlfloat_octuple tlfloat_remaindero	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remainderq()

static tlfloat_quad tlfloat_remainderq	(	const tlfloat_quad	x,
		const tlfloat_quad	y
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remquo()

double tlfloat_remquo	(	const double	x,
		const double	y,
		int *	quo
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remquof()

float tlfloat_remquof	(	const float	x,
		const float	y,
		int *	quo
	)

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remquoo()

static tlfloat_octuple tlfloat_remquoo	(	const tlfloat_octuple	x,
		const tlfloat_octuple	y,
		int *	quo
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_remquoq()

static tlfloat_quad tlfloat_remquoq	(	const tlfloat_quad	x,
		const tlfloat_quad	y,
		int *	quo
	)

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_rint()

double tlfloat_rint ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_rintf()

float tlfloat_rintf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_rinto()

static tlfloat_octuple tlfloat_rinto ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_rintq()

static tlfloat_quad tlfloat_rintq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_round()

double tlfloat_round ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_roundf()

float tlfloat_roundf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_roundo()

static tlfloat_octuple tlfloat_roundo ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_roundq()

static tlfloat_quad tlfloat_roundq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_shl_i128_i()

tlfloat_int128_t_ tlfloat_shl_i128_i	(	const tlfloat_int128_t_	x,
		const int	y
	)

◆ tlfloat_shl_u128_i()

tlfloat_uint128_t_ tlfloat_shl_u128_i	(	const tlfloat_uint128_t_	x,
		const int	y
	)

◆ tlfloat_shr_i128_i()

tlfloat_int128_t_ tlfloat_shr_i128_i	(	const tlfloat_int128_t_	x,
		const int	y
	)

◆ tlfloat_shr_u128_i()

tlfloat_uint128_t_ tlfloat_shr_u128_i	(	const tlfloat_uint128_t_	x,
		const int	y
	)

◆ tlfloat_signbit()

int tlfloat_signbit ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_signbitf()

int tlfloat_signbitf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_signbito()

static int tlfloat_signbito ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_signbitq()

static int tlfloat_signbitq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sin()

double tlfloat_sin ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinf()

float tlfloat_sinf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinh()

double tlfloat_sinh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinhf()

float tlfloat_sinhf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinho()

static tlfloat_octuple tlfloat_sinho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinhq()

static tlfloat_quad tlfloat_sinhq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sino()

static tlfloat_octuple tlfloat_sino ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sinpi()

double tlfloat_sinpi ( const double x )

◆ tlfloat_sinpif()

float tlfloat_sinpif ( const float x )

◆ tlfloat_sinpio()

static tlfloat_octuple tlfloat_sinpio ( const tlfloat_octuple x )

inlinestatic

◆ tlfloat_sinpiq()

static tlfloat_quad tlfloat_sinpiq ( const tlfloat_quad x )

inlinestatic

◆ tlfloat_sinq()

static tlfloat_quad tlfloat_sinq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_snprintf()

int tlfloat_snprintf	(	char *	str,
		size_t	size,
		const char *	fmt,
			...
	)

See explanation for tlfloat_printf()

◆ tlfloat_sqrt()

double tlfloat_sqrt ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sqrtf()

float tlfloat_sqrtf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sqrto() [1/2]

static tlfloat_octuple tlfloat_sqrto ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sqrto() [2/2]

tlfloat_octuple_ tlfloat_sqrto ( const tlfloat_octuple_ x )

◆ tlfloat_sqrtq() [1/2]

static tlfloat_quad tlfloat_sqrtq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_sqrtq() [2/2]

tlfloat_quad_ tlfloat_sqrtq ( const tlfloat_quad_ x )

◆ tlfloat_strtod()

double tlfloat_strtod	(	const char *	nptr,
		const char **	endptr
	)

The tlfloat_strtod family of functions provides functionality equivalent to the standard strtod family of functions, but corresponds to the types defined in the TLFloat library.

◆ tlfloat_strtof()

float tlfloat_strtof	(	const char *	nptr,
		const char **	endptr
	)

◆ tlfloat_strtoi128()

tlfloat_int128_t_ tlfloat_strtoi128	(	const char *	nptr,
		const char **	endptr,
		const int	base
	)

◆ tlfloat_strtoo()

tlfloat_octuple_ tlfloat_strtoo	(	const char *	nptr,
		const char **	endptr
	)

◆ tlfloat_strtoq()

tlfloat_quad_ tlfloat_strtoq	(	const char *	nptr,
		const char **	endptr
	)

◆ tlfloat_strtou128()

tlfloat_uint128_t_ tlfloat_strtou128	(	const char *	nptr,
		const char **	endptr,
		const int	base
	)

◆ tlfloat_sub()

double tlfloat_sub	(	const double	x,
		const double	y
	)

◆ tlfloat_sub_i128_i128()

tlfloat_int128_t_ tlfloat_sub_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_sub_u128_u128()

tlfloat_uint128_t_ tlfloat_sub_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ tlfloat_subf()

float tlfloat_subf	(	const float	x,
		const float	y
	)

◆ tlfloat_subo()

tlfloat_octuple_ tlfloat_subo	(	const tlfloat_octuple_	x,
		const tlfloat_octuple_	y
	)

This function performs subtraction of two octuple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_subq()

tlfloat_quad_ tlfloat_subq	(	const tlfloat_quad_	x,
		const tlfloat_quad_	y
	)

This function performs subtraction of two quadruple-precision floating point numbers. Link with -ltlfloat.

◆ tlfloat_tan()

double tlfloat_tan ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanf()

float tlfloat_tanf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanh()

double tlfloat_tanh ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanhf()

float tlfloat_tanhf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanho()

static tlfloat_octuple tlfloat_tanho ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanhq()

static tlfloat_quad tlfloat_tanhq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tano()

static tlfloat_octuple tlfloat_tano ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tanpi()

double tlfloat_tanpi ( const double x )

◆ tlfloat_tanpif()

float tlfloat_tanpif ( const float x )

◆ tlfloat_tanpio()

static tlfloat_octuple tlfloat_tanpio ( const tlfloat_octuple x )

inlinestatic

◆ tlfloat_tanpiq()

static tlfloat_quad tlfloat_tanpiq ( const tlfloat_quad x )

inlinestatic

◆ tlfloat_tanq()

static tlfloat_quad tlfloat_tanq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tgamma()

double tlfloat_tgamma ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tgammaf()

float tlfloat_tgammaf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tgammao()

static tlfloat_octuple tlfloat_tgammao ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_tgammaq()

static tlfloat_quad tlfloat_tgammaq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_trunc()

double tlfloat_trunc ( const double x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_truncf()

float tlfloat_truncf ( const float x )

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_trunco()

static tlfloat_octuple tlfloat_trunco ( const tlfloat_octuple x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_truncq()

static tlfloat_quad tlfloat_truncq ( const tlfloat_quad x )

inlinestatic

This function is for calling the corresponding function defined in tlfloat namespace from C language. Link with -ltlfloat.

◆ tlfloat_unregisterPrintfHook()

void tlfloat_unregisterPrintfHook ( )

Unregister printf hooks

◆ tlfloat_version()

uint64_t tlfloat_version ( )

This function returns TLFLOAT_VERSION_MAJOR * 1000000ULL + TLFLOAT_VERSION_MINOR * 1000ULL + TLFLOAT_VERSION_PATCH

◆ tlfloat_vfprintf()

int tlfloat_vfprintf	(	FILE *	fp,
		const char *	fmt,
		va_list	ap
	)

See explanation for tlfloat_printf()

◆ tlfloat_vprintf()

int tlfloat_vprintf	(	const char *	fmt,
		va_list	ap
	)

See explanation for tlfloat_printf()

◆ tlfloat_vsnprintf()

int tlfloat_vsnprintf	(	char *	str,
		size_t	size,
		const char *	fmt,
		va_list	ap
	)

See explanation for tlfloat_printf()

◆ tlfloat_xor_i128_i128()

tlfloat_int128_t_ tlfloat_xor_i128_i128	(	const tlfloat_int128_t_	x,
		const tlfloat_int128_t_	y
	)

◆ tlfloat_xor_u128_u128()

tlfloat_uint128_t_ tlfloat_xor_u128_u128	(	const tlfloat_uint128_t_	x,
		const tlfloat_uint128_t_	y
	)

◆ truncq()

static tlfloat_quad truncq ( const tlfloat_quad x )

inlinestatic

This function has the same functionality as the corresponding function in quadmath.h. This function is available only if TLFLOAT_LIBQUADMATH_EMULATION macro is defined. Link with -ltlfloat.

Classes

Namespaces

Macros

Functions

Macro Definition Documentation

◆ FLT128_DENORM_MIN

◆ FLT128_DIG

◆ FLT128_EPSILON

◆ FLT128_MANT_DIG

◆ FLT128_MAX

◆ FLT128_MAX_10_EXP

◆ FLT128_MAX_EXP

◆ FLT128_MIN

◆ FLT128_MIN_10_EXP

◆ FLT128_MIN_EXP

◆ M_1_PIq

◆ M_2_PIq

◆ M_2_SQRTPIq

◆ M_Eq

◆ M_LN10q

◆ M_LN2q

◆ M_LOG10Eq

◆ M_LOG2Eq

◆ M_PI_2q

◆ M_PI_4q

◆ M_PIq

◆ M_SQRT1_2q

◆ M_SQRT2q

◆ TLFLOAT_FLT128_DENORM_MIN

◆ TLFLOAT_FLT128_EPSILON

◆ TLFLOAT_FLT128_MAX

◆ TLFLOAT_FLT128_MIN

◆ TLFLOAT_FLT128_TRUE_MIN

◆ TLFLOAT_FP_ILOGB0

◆ TLFLOAT_FP_ILOGBNAN

◆ TLFLOAT_FP_INFINITE

◆ TLFLOAT_FP_NAN

◆ TLFLOAT_FP_NORMAL

◆ TLFLOAT_FP_SUBNORMAL

◆ TLFLOAT_FP_ZERO

◆ TLFLOAT_INT128_IS_STRUCT

◆ TLFLOAT_LIBQUADMATH_EMULATION

◆ TLFLOAT_M_1_PIq

◆ TLFLOAT_M_2_PIq

◆ TLFLOAT_M_2_SQRTPIq

◆ TLFLOAT_M_Eq

◆ TLFLOAT_M_LN10q

◆ TLFLOAT_M_LN2q

◆ TLFLOAT_M_LOG10Eq

◆ TLFLOAT_M_LOG2Eq

◆ TLFLOAT_M_PI_2q

◆ TLFLOAT_M_PI_4q

◆ TLFLOAT_M_PIq

◆ TLFLOAT_M_SQRT1_2q

◆ TLFLOAT_M_SQRT2q

◆ TLFLOAT_POLYFUNC_f_f

◆ TLFLOAT_POLYFUNC_f_f_f

◆ TLFLOAT_POLYFUNC_f_f_f_f

◆ TLFLOAT_POLYFUNC_f_f_f_pi

◆ TLFLOAT_POLYFUNC_f_f_i

◆ TLFLOAT_POLYFUNC_f_f_pf

◆ TLFLOAT_POLYFUNC_f_f_pi

◆ TLFLOAT_POLYFUNC_i_f

◆ TLFLOAT_QUAD_IS_STRUCT

Function Documentation

◆ acoshq()

◆ acosq()

◆ asinhq()

◆ asinq()

◆ atan2q()

◆ atanhq()

◆ atanq()

◆ cbrtq()

◆ ceilq()

◆ copysignq()

◆ coshq()

◆ cosq()

◆ erfcq()

◆ erfq()

◆ exp10q()