int main(void) { long double NaN = 0.0l / 0.0l; long double Inf = 1.0l / 0.0l; long double negInf = -1.0l / 0.0l; long double val = __VERIFIER_nondet_long_double(); if (!__isnanl(val) && !__isinfl(val) && !__iszerol(val)) { if (val > 0) { assert(fabsl(val) == val); } else { assert(fabsl(val) == val); } } assert(fabsl(0.0l) == 0.0l); assert(fabsl(-0.0l) == 0.0l); int isNeg = __signbitl(fabsl(-0.0l)); assert(!isNeg); assert(fabsl(Inf) == Inf); assert(fabsl(negInf) == Inf); assert(__isnanl(fabsl(NaN))); return 0; }
/* Wrapper scalbl */ long double __scalbl (long double x, long double fn) { if (__glibc_unlikely (_LIB_VERSION == _SVID_)) return sysv_scalbl (x, fn); else { long double z = __ieee754_scalbl (x, fn); if (__glibc_unlikely (!__finitel (z) || z == 0.0L)) { if (__isnanl (z)) { if (!__isnanl (x) && !__isnanl (fn)) __set_errno (EDOM); } else if (__isinf_nsl (z)) { if (!__isinf_nsl (x) && !__isinf_nsl (fn)) __set_errno (ERANGE); } else { /* z == 0. */ if (x != 0.0L && !__isinf_nsl (fn)) __set_errno (ERANGE); } } return z; } }
/* wrapper fmodl */ long double __fmodl (long double x, long double y) { if (__builtin_expect (__isinf_nsl (x) || y == 0.0L, 0) && _LIB_VERSION != _IEEE_ && !__isnanl (y) && !__isnanl (x)) /* fmod(+-Inf,y) or fmod(x,0) */ return __kernel_standard_l (x, y, 227); return __ieee754_fmodl (x, y); }
/* wrapper remainderl */ long double __remainderl (long double x, long double y) { if (((__builtin_expect (y == 0.0L, 0) && ! __isnanl (x)) || (__builtin_expect (__isinf_nsl (x), 0) && ! __isnanl (y))) && _LIB_VERSION != _IEEE_) return __kernel_standard (x, y, 228); /* remainder domain */ return __ieee754_remainderl (x, y); }
/* wrapper powl */ long double __powl (long double x, long double y) { long double z = __ieee754_powl (x, y); if (__builtin_expect (!__finitel (z), 0)) { if (_LIB_VERSION != _IEEE_) { if (__isnanl (x)) { if (y == 0.0L) /* pow(NaN,0.0) */ return __kernel_standard_l (x, y, 242); } else if (__finitel (x) && __finitel (y)) { if (__isnanl (z)) /* pow neg**non-int */ return __kernel_standard_l (x, y, 224); else if (x == 0.0L && y < 0.0L) { if (signbit (x) && signbit (z)) /* pow(-0.0,negative) */ return __kernel_standard_l (x, y, 223); else /* pow(+0.0,negative) */ return __kernel_standard_l (x, y, 243); } else /* pow overflow */ return __kernel_standard_l (x, y, 221); } } } else if (__builtin_expect (z == 0.0L, 0) && __finitel (x) && __finitel (y) && _LIB_VERSION != _IEEE_) { if (x == 0.0L) { if (y == 0.0L) /* pow(0.0,0.0) */ return __kernel_standard_l (x, y, 220); } else /* pow underflow */ return __kernel_standard_l (x, y, 222); } return z; }
long double __ieee754_scalbl (long double x, long double fn) { if (__builtin_expect (__isnanl (x), 0)) return x * fn; if (__builtin_expect (!__finitel (fn), 0)) { if (__isnanl (fn) || fn > 0.0L) return x * fn; if (x == 0.0L) return x; return x / -fn; } if (__builtin_expect ((long double) (int) fn != fn, 0)) return invalid_fn (x, fn); return __scalbnl (x, (int) fn); }
long double __ieee754_scalbl (long double x, long double fn) { if (__glibc_unlikely (__isnanl (x))) return x * fn; if (__glibc_unlikely (!__finitel (fn))) { if (__isnanl (fn) || fn > 0.0L) return x * fn; if (x == 0.0L) return x; return x / -fn; } if (__glibc_unlikely ((long double) (int) fn != fn)) return invalid_fn (x, fn); return __scalbnl (x, (int) fn); }
ATF_TC_BODY(strtold_nan, tc) { #ifndef __vax__ # ifdef __HAVE_LONG_DOUBLE char *end; volatile long double ld = strtold(nan_string, &end); ATF_REQUIRE(isnan(ld) != 0); ATF_REQUIRE(__isnanl(ld) != 0); ATF_REQUIRE(strcmp(end, "y") == 0); # else atf_tc_skip("Requires long double support"); # endif #else atf_tc_skip("vax not supported"); #endif }
int printf_size (FILE *fp, const struct printf_info *info, const void *const *args) { /* Units for the both formats. */ #define BINARY_UNITS " kmgtpezy" #define DECIMAL_UNITS " KMGTPEZY" static const char units[2][sizeof (BINARY_UNITS)] = { BINARY_UNITS, /* For binary format. */ DECIMAL_UNITS /* For decimal format. */ }; const char *tag = units[isupper (info->spec) != 0]; int divisor = isupper (info->spec) ? 1000 : 1024; /* The floating-point value to output. */ union { union ieee754_double dbl; union ieee854_long_double ldbl; } fpnum; const void *ptr = &fpnum; int negative = 0; /* "NaN" or "Inf" for the special cases. */ const char *special = NULL; const wchar_t *wspecial = NULL; struct printf_info fp_info; int done = 0; int wide = info->wide; /* Fetch the argument value. */ #ifndef __NO_LONG_DOUBLE_MATH if (info->is_long_double && sizeof (long double) > sizeof (double)) { fpnum.ldbl.d = *(const long double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnanl (fpnum.ldbl.d)) { special = "nan"; wspecial = L"nan"; negative = 0; } else if (__isinfl (fpnum.ldbl.d)) { special = "inf"; wspecial = L"inf"; negative = fpnum.ldbl.d < 0; } else while (fpnum.ldbl.d >= divisor && tag[1] != '\0') { fpnum.ldbl.d /= divisor; ++tag; } } else #endif /* no long double */ { fpnum.dbl.d = *(const double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnan (fpnum.dbl.d)) { special = "nan"; wspecial = L"nan"; negative = 0; } else if (__isinf (fpnum.dbl.d)) { special = "inf"; wspecial = L"inf"; negative = fpnum.dbl.d < 0; } else while (fpnum.dbl.d >= divisor && tag[1] != '\0') { fpnum.dbl.d /= divisor; ++tag; } } if (special) { int width = info->prec > width ? info->prec : info->width; if (negative || info->showsign || info->space) --width; width -= 3; if (!info->left && width > 0) PADN (' ', width); if (negative) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); PRINT (special, wspecial, 3); if (info->left && width > 0) PADN (' ', width); return done; } /* Prepare to print the number. We want to use `__printf_fp' so we have to prepare a `printf_info' structure. */ fp_info.spec = 'f'; fp_info.prec = info->prec < 0 ? 3 : info->prec; fp_info.is_long_double = info->is_long_double; fp_info.is_short = info->is_short; fp_info.is_long = info->is_long; fp_info.alt = info->alt; fp_info.space = info->space; fp_info.left = info->left; fp_info.showsign = info->showsign; fp_info.group = info->group; fp_info.extra = info->extra; fp_info.pad = info->pad; fp_info.wide = wide; if (fp_info.left && fp_info.pad == L' ') { /* We must do the padding ourself since the unit character must be placed before the padding spaces. */ fp_info.width = 0; done = __printf_fp (fp, &fp_info, &ptr); if (done > 0) { outchar (*tag); if (info->width > done) PADN (' ', info->width - done); } } else { /* We can let __printf_fp do all the printing and just add our unit character afterwards. */ fp_info.width = info->width - 1; done = __printf_fp (fp, &fp_info, &ptr); if (done > 0) outchar (*tag); } return done; }
long double fmaxl (long double _x, long double _y) { return (( isgreaterequal(_x, _y) || __isnanl (_y)) ? _x : _y ); }
long double fminl (long double _x, long double _y) { return ((islessequal(_x, _y) || __isnanl (_y)) ? _x : _y ); }
int __printf_fphex (FILE *fp, const struct printf_info *info, const void *const *args) { /* The floating-point value to output. */ union { union ieee754_double dbl; long double ldbl; } fpnum; /* Locale-dependent representation of decimal point. */ const char *decimal; wchar_t decimalwc; /* "NaN" or "Inf" for the special cases. */ const char *special = NULL; const wchar_t *wspecial = NULL; /* Buffer for the generated number string for the mantissa. The maximal size for the mantissa is 128 bits. */ char numbuf[32]; char *numstr; char *numend; wchar_t wnumbuf[32]; wchar_t *wnumstr; wchar_t *wnumend; int negative; /* The maximal exponent of two in decimal notation has 5 digits. */ char expbuf[5]; char *expstr; wchar_t wexpbuf[5]; wchar_t *wexpstr; int expnegative; int exponent; /* Non-zero is mantissa is zero. */ int zero_mantissa; /* The leading digit before the decimal point. */ char leading; /* Precision. */ int precision = info->prec; /* Width. */ int width = info->width; /* Number of characters written. */ int done = 0; /* Nonzero if this is output on a wide character stream. */ #if __OPTION_POSIX_C_LANG_WIDE_CHAR int wide = info->wide; #else /* This should never be called on a wide-oriented stream when OPTION_POSIX_C_LANG_WIDE_CHAR is disabled, but the compiler can't be trusted to figure that out. */ const int wide = 0; #endif /* Figure out the decimal point character. */ #if __OPTION_EGLIBC_LOCALE_CODE if (info->extra == 0) { decimal = _NL_CURRENT (LC_NUMERIC, DECIMAL_POINT); decimalwc = _NL_CURRENT_WORD (LC_NUMERIC, _NL_NUMERIC_DECIMAL_POINT_WC); } else { decimal = _NL_CURRENT (LC_MONETARY, MON_DECIMAL_POINT); decimalwc = _NL_CURRENT_WORD (LC_MONETARY, _NL_MONETARY_DECIMAL_POINT_WC); } /* The decimal point character must never be zero. */ assert (*decimal != '\0' && decimalwc != L'\0'); #else decimal = "."; decimalwc = L'.'; #endif /* Fetch the argument value. */ #ifndef __NO_LONG_DOUBLE_MATH if (info->is_long_double && sizeof (long double) > sizeof (double)) { fpnum.ldbl = *(const long double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnanl (fpnum.ldbl)) { if (isupper (info->spec)) { special = "NAN"; wspecial = L"NAN"; } else { special = "nan"; wspecial = L"nan"; } } else { if (__isinfl (fpnum.ldbl)) { if (isupper (info->spec)) { special = "INF"; wspecial = L"INF"; } else { special = "inf"; wspecial = L"inf"; } } } negative = signbit (fpnum.ldbl); } else #endif /* no long double */ { fpnum.dbl.d = *(const double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnan (fpnum.dbl.d)) { negative = fpnum.dbl.ieee.negative != 0; if (isupper (info->spec)) { special = "NAN"; wspecial = L"NAN"; } else { special = "nan"; wspecial = L"nan"; } } else { int res = __isinf (fpnum.dbl.d); if (res) { if (isupper (info->spec)) { special = "INF"; wspecial = L"INF"; } else { special = "inf"; wspecial = L"inf"; } negative = res < 0; } else negative = signbit (fpnum.dbl.d); } } if (special) { int width = info->width; if (negative || info->showsign || info->space) --width; width -= 3; if (!info->left && width > 0) PADN (' ', width); if (negative) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); PRINT (special, wspecial, 3); if (info->left && width > 0) PADN (' ', width); return done; } if (info->is_long_double == 0 || sizeof (double) == sizeof (long double)) { /* We have 52 bits of mantissa plus one implicit digit. Since 52 bits are representable without rest using hexadecimal digits we use only the implicit digits for the number before the decimal point. */ unsigned long long int num; num = (((unsigned long long int) fpnum.dbl.ieee.mantissa0) << 32 | fpnum.dbl.ieee.mantissa1); zero_mantissa = num == 0; if (sizeof (unsigned long int) > 6) { wnumstr = _itowa_word (num, wnumbuf + (sizeof wnumbuf) / sizeof (wchar_t), 16, info->spec == 'A'); numstr = _itoa_word (num, numbuf + sizeof numbuf, 16, info->spec == 'A'); } else { wnumstr = _itowa (num, wnumbuf + sizeof wnumbuf / sizeof (wchar_t), 16, info->spec == 'A'); numstr = _itoa (num, numbuf + sizeof numbuf, 16, info->spec == 'A'); } /* Fill with zeroes. */ while (wnumstr > wnumbuf + (sizeof wnumbuf - 52) / sizeof (wchar_t)) { *--wnumstr = L'0'; *--numstr = '0'; } leading = fpnum.dbl.ieee.exponent == 0 ? '0' : '1'; exponent = fpnum.dbl.ieee.exponent; if (exponent == 0) { if (zero_mantissa) expnegative = 0; else { /* This is a denormalized number. */ expnegative = 1; exponent = IEEE754_DOUBLE_BIAS - 1; } } else if (exponent >= IEEE754_DOUBLE_BIAS) { expnegative = 0; exponent -= IEEE754_DOUBLE_BIAS; } else { expnegative = 1; exponent = -(exponent - IEEE754_DOUBLE_BIAS); } } #ifdef PRINT_FPHEX_LONG_DOUBLE else PRINT_FPHEX_LONG_DOUBLE; #endif /* Look for trailing zeroes. */ if (! zero_mantissa) { wnumend = &wnumbuf[sizeof wnumbuf / sizeof wnumbuf[0]]; numend = &numbuf[sizeof numbuf / sizeof numbuf[0]]; while (wnumend[-1] == L'0') { --wnumend; --numend; } bool do_round_away = false; if (precision != -1 && precision < numend - numstr) { char last_digit = precision > 0 ? numstr[precision - 1] : leading; char next_digit = numstr[precision]; int last_digit_value = (last_digit >= 'A' && last_digit <= 'F' ? last_digit - 'A' + 10 : (last_digit >= 'a' && last_digit <= 'f' ? last_digit - 'a' + 10 : last_digit - '0')); int next_digit_value = (next_digit >= 'A' && next_digit <= 'F' ? next_digit - 'A' + 10 : (next_digit >= 'a' && next_digit <= 'f' ? next_digit - 'a' + 10 : next_digit - '0')); bool more_bits = ((next_digit_value & 7) != 0 || precision + 1 < numend - numstr); int rounding_mode = get_rounding_mode (); do_round_away = round_away (negative, last_digit_value & 1, next_digit_value >= 8, more_bits, rounding_mode); } if (precision == -1) precision = numend - numstr; else if (do_round_away) { /* Round up. */ int cnt = precision; while (--cnt >= 0) { char ch = numstr[cnt]; /* We assume that the digits and the letters are ordered like in ASCII. This is true for the rest of GNU, too. */ if (ch == '9') { wnumstr[cnt] = (wchar_t) info->spec; numstr[cnt] = info->spec; /* This is tricky, think about it! */ break; } else if (tolower (ch) < 'f') { ++numstr[cnt]; ++wnumstr[cnt]; break; } else { numstr[cnt] = '0'; wnumstr[cnt] = L'0'; } } if (cnt < 0) { /* The mantissa so far was fff...f Now increment the leading digit. Here it is again possible that we get an overflow. */ if (leading == '9') leading = info->spec; else if (tolower (leading) < 'f') ++leading; else { leading = '1'; if (expnegative) { exponent -= 4; if (exponent <= 0) { exponent = -exponent; expnegative = 0; } } else exponent += 4; } } } } else { if (precision == -1) precision = 0; numend = numstr; wnumend = wnumstr; } /* Now we can compute the exponent string. */ expstr = _itoa_word (exponent, expbuf + sizeof expbuf, 10, 0); wexpstr = _itowa_word (exponent, wexpbuf + sizeof wexpbuf / sizeof (wchar_t), 10, 0); /* Now we have all information to compute the size. */ width -= ((negative || info->showsign || info->space) /* Sign. */ + 2 + 1 + 0 + precision + 1 + 1 /* 0x h . hhh P ExpoSign. */ + ((expbuf + sizeof expbuf) - expstr)); /* Exponent. */ /* Count the decimal point. A special case when the mantissa or the precision is zero and the `#' is not given. In this case we must not print the decimal point. */ if (precision > 0 || info->alt) width -= wide ? 1 : strlen (decimal); if (!info->left && info->pad != '0' && width > 0) PADN (' ', width); if (negative) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); outchar ('0'); if ('X' - 'A' == 'x' - 'a') outchar (info->spec + ('x' - 'a')); else outchar (info->spec == 'A' ? 'X' : 'x'); if (!info->left && info->pad == '0' && width > 0) PADN ('0', width); outchar (leading); if (precision > 0 || info->alt) { const wchar_t *wtmp = &decimalwc; PRINT (decimal, wtmp, wide ? 1 : strlen (decimal)); } if (precision > 0) { ssize_t tofill = precision - (numend - numstr); PRINT (numstr, wnumstr, MIN (numend - numstr, precision)); if (tofill > 0) PADN ('0', tofill); } if ('P' - 'A' == 'p' - 'a') outchar (info->spec + ('p' - 'a')); else outchar (info->spec == 'A' ? 'P' : 'p'); outchar (expnegative ? '-' : '+'); PRINT (expstr, wexpstr, (expbuf + sizeof expbuf) - expstr); if (info->left && info->pad != '0' && width > 0) PADN (info->pad, width); return done; }
int __printf_size (FILE *fp, const struct printf_info *info, const void *const *args) { /* Units for the both formats. */ #define BINARY_UNITS " kmgtpezy" #define DECIMAL_UNITS " KMGTPEZY" static const char units[2][sizeof (BINARY_UNITS)] = { BINARY_UNITS, /* For binary format. */ DECIMAL_UNITS /* For decimal format. */ }; const char *tag = units[isupper (info->spec) != 0]; int divisor = isupper (info->spec) ? 1000 : 1024; /* The floating-point value to output. */ union { union ieee754_double dbl; union ieee854_long_double ldbl; } fpnum; const void *ptr = &fpnum; int fpnum_sign = 0; /* "NaN" or "Inf" for the special cases. */ const char *special = NULL; const wchar_t *wspecial = NULL; struct printf_info fp_info; int done = 0; #if __OPTION_POSIX_C_LANG_WIDE_CHAR int wide = info->wide; #else /* This should never be called on a wide-oriented stream when OPTION_POSIX_C_LANG_WIDE_CHAR is disabled, but the compiler can't be trusted to figure that out. */ const int wide = 0; #endif int res; /* Fetch the argument value. */ #ifndef __NO_LONG_DOUBLE_MATH if (info->is_long_double && sizeof (long double) > sizeof (double)) { fpnum.ldbl.d = *(const long double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnanl (fpnum.ldbl.d)) { special = "nan"; wspecial = L"nan"; // fpnum_sign = 0; Already zero } else if ((res = __isinfl (fpnum.ldbl.d))) { fpnum_sign = res; special = "inf"; wspecial = L"inf"; } else while (fpnum.ldbl.d >= divisor && tag[1] != '\0') { fpnum.ldbl.d /= divisor; ++tag; } } else #endif /* no long double */ { fpnum.dbl.d = *(const double *) args[0]; /* Check for special values: not a number or infinity. */ if (__isnan (fpnum.dbl.d)) { special = "nan"; wspecial = L"nan"; // fpnum_sign = 0; Already zero } else if ((res = __isinf (fpnum.dbl.d))) { fpnum_sign = res; special = "inf"; wspecial = L"inf"; } else while (fpnum.dbl.d >= divisor && tag[1] != '\0') { fpnum.dbl.d /= divisor; ++tag; } } if (special) { int width = info->prec > info->width ? info->prec : info->width; if (fpnum_sign < 0 || info->showsign || info->space) --width; width -= 3; if (!info->left && width > 0) PADN (' ', width); if (fpnum_sign < 0) outchar ('-'); else if (info->showsign) outchar ('+'); else if (info->space) outchar (' '); PRINT (special, wspecial, 3); if (info->left && width > 0) PADN (' ', width); return done; } /* Prepare to print the number. We want to use `__printf_fp' so we have to prepare a `printf_info' structure. */ fp_info = *info; fp_info.spec = 'f'; fp_info.prec = info->prec < 0 ? 3 : info->prec; fp_info.wide = wide; if (fp_info.left && fp_info.pad == L' ') { /* We must do the padding ourself since the unit character must be placed before the padding spaces. */ fp_info.width = 0; done = __printf_fp (fp, &fp_info, &ptr); if (done > 0) { outchar (*tag); if (info->width > done) PADN (' ', info->width - done); } } else { /* We can let __printf_fp do all the printing and just add our unit character afterwards. */ fp_info.width = info->width - 1; done = __printf_fp (fp, &fp_info, &ptr); if (done > 0) outchar (*tag); } return done; }
TEST(math, powl) { ASSERT_TRUE(__isnanl(powl(nanl(""), 3.0L))); ASSERT_DOUBLE_EQ(1.0L, (powl(1.0L, nanl("")))); ASSERT_TRUE(__isnanl(powl(2.0L, nanl("")))); ASSERT_DOUBLE_EQ(8.0L, powl(2.0L, 3.0L)); }
TEST(math, __isnanl) { ASSERT_FALSE(__isnanl(123.0L)); ASSERT_TRUE(__isnanl(nanl(""))); }
TEST(math, powl) { ASSERT_TRUE(__isnanl(powl(nanl(""), 3.0))); ASSERT_FLOAT_EQ(1.0, (powl(1.0, nanl("")))); ASSERT_TRUE(__isnanl(powl(2.0, nanl("")))); ASSERT_FLOAT_EQ(8.0, powl(2.0, 3.0)); }
/// Return whether the given value is defined inline static bool isDefined( double _fdValue ) { return !__isnanl( _fdValue ); };
static int testl(long double long_double_x, int int_x, long long_x) { int r = 0; r += __finitel(long_double_x); r += __fpclassifyl(long_double_x); r += __isinfl(long_double_x); r += __isnanl(long_double_x); r += __signbitl(long_double_x); r += acoshl(long_double_x); r += acosl(long_double_x); r += asinhl(long_double_x); r += asinl(long_double_x); r += atan2l(long_double_x, long_double_x); r += atanhl(long_double_x); r += atanl(long_double_x); r += cbrtl(long_double_x); r += ceill(long_double_x); r += copysignl(long_double_x, long_double_x); r += coshl(long_double_x); r += cosl(long_double_x); r += erfcl(long_double_x); r += erfl(long_double_x); r += exp2l(long_double_x); r += expl(long_double_x); r += expm1l(long_double_x); r += fabsl(long_double_x); r += fdiml(long_double_x, long_double_x); r += floorl(long_double_x); r += fmal(long_double_x, long_double_x, long_double_x); r += fmaxl(long_double_x, long_double_x); r += fminl(long_double_x, long_double_x); r += fmodl(long_double_x, long_double_x); r += frexpl(long_double_x, &int_x); r += hypotl(long_double_x, long_double_x); r += ilogbl(long_double_x); r += ldexpl(long_double_x, int_x); r += lgammal(long_double_x); r += llrintl(long_double_x); r += llroundl(long_double_x); r += log10l(long_double_x); r += log1pl(long_double_x); r += log2l(long_double_x); r += logbl(long_double_x); r += logl(long_double_x); r += lrintl(long_double_x); r += lroundl(long_double_x); r += modfl(long_double_x, &long_double_x); r += nearbyintl(long_double_x); r += nextafterl(long_double_x, long_double_x); r += nexttowardl(long_double_x, long_double_x); r += powl(long_double_x, long_double_x); r += remainderl(long_double_x, long_double_x); r += remquol(long_double_x, long_double_x, &int_x); r += rintl(long_double_x); r += roundl(long_double_x); r += scalblnl(long_double_x, long_x); r += scalbnl(long_double_x, int_x); r += sinhl(long_double_x); r += sinl(long_double_x); r += sqrtl(long_double_x); r += tanhl(long_double_x); r += tanl(long_double_x); r += tgammal(long_double_x); r += truncl(long_double_x); return r; }