diff options
Diffstat (limited to 'math/libm-test.inc')
| -rw-r--r-- | math/libm-test.inc | 334 |
1 files changed, 305 insertions, 29 deletions
diff --git a/math/libm-test.inc b/math/libm-test.inc index 8bb435875d..3851855fec 100644 --- a/math/libm-test.inc +++ b/math/libm-test.inc @@ -78,8 +78,8 @@ against. These implemented tests should check all cases that are specified in ISO C99. - Exception testing: At the moment only divide-by-zero and invalid - exceptions are tested. Overflow/underflow and inexact exceptions + Exception testing: At the moment only divide-by-zero, invalid and + overflow exceptions are tested. Underflow and inexact exceptions aren't checked at the moment. NaN values: There exist signalling and quiet NaNs. This implementation @@ -132,12 +132,14 @@ #define NO_EXCEPTION 0x0 #define INVALID_EXCEPTION 0x1 #define DIVIDE_BY_ZERO_EXCEPTION 0x2 +#define OVERFLOW_EXCEPTION 0x4 /* The next flags signals that those exceptions are allowed but not required. */ -#define INVALID_EXCEPTION_OK 0x4 -#define DIVIDE_BY_ZERO_EXCEPTION_OK 0x8 +#define INVALID_EXCEPTION_OK 0x8 +#define DIVIDE_BY_ZERO_EXCEPTION_OK 0x10 +#define OVERFLOW_EXCEPTION_OK 0x20 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK /* Some special test flags, passed togther with exceptions. */ -#define IGNORE_ZERO_INF_SIGN 0x10 +#define IGNORE_ZERO_INF_SIGN 0x40 /* Various constants (we must supply them precalculated for accuracy). */ #define M_PI_6l .52359877559829887307710723054658383L @@ -451,6 +453,11 @@ test_exceptions (const char *test_name, int exception) test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID, "Invalid operation"); #endif +#ifdef FE_OVERFLOW + if ((exception & OVERFLOW_EXCEPTION_OK) == 0) + test_single_exception (test_name, exception, OVERFLOW_EXCEPTION, + FE_OVERFLOW, "Overflow"); +#endif feclearexcept (FE_ALL_EXCEPT); } @@ -1887,6 +1894,50 @@ cexp_test (void) TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L); TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L); + TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L); + TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L); + TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L); + +#ifndef TEST_FLOAT + TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L); + TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L); + TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L); +#endif + +#if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 + TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L); + TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L); +#endif + + TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L); + TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L); + +#ifndef TEST_FLOAT + TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L); + TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L); +#endif + +#if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 + TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L); + TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L); +#endif + +#ifdef TEST_FLOAT + TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION); +#endif + +#if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024) + TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION); +#endif + +#if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 + TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION); +#endif + + TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION); + TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION); + TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION); + END (cexp, complex); } @@ -3074,7 +3125,7 @@ exp10_test (void) TEST_f_f (exp10, nan_value, nan_value); TEST_f_f (exp10, 3, 1000); TEST_f_f (exp10, -1, 0.1L); - TEST_f_f (exp10, 1e6, plus_infty); + TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION); TEST_f_f (exp10, -1e6, 0); TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L); @@ -3101,10 +3152,25 @@ exp2_test (void) TEST_f_f (exp2, 10, 1024); TEST_f_f (exp2, -1, 0.5); - TEST_f_f (exp2, 1e6, plus_infty); + TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION); TEST_f_f (exp2, -1e6, 0); TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L); + TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L); + TEST_f_f (exp2, 127, 0x1p127); + TEST_f_f (exp2, -149, 0x1p-149); + +#ifndef TEST_FLOAT + TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L); + TEST_f_f (exp2, 1023, 0x1p1023); + TEST_f_f (exp2, -1074, 0x1p-1074); +#endif + +#if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 + TEST_f_f (exp2, 16383, 0x1p16383L); + TEST_f_f (exp2, -16400, 0x1p-16400L); +#endif + END (exp2); } @@ -3137,7 +3203,8 @@ expm1_test (void) #endif errno = 0; - TEST_f_f (expm1, 100000.0, plus_infty); + /* Bug 13787: OVERFLOW exception may be missing. */ + TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION_OK); check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0); END (expm1); @@ -5242,8 +5309,8 @@ nextafter_test (void) FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX, LDBL_MAX, DBL_MAX, FLT_MAX); - TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty); - TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty); + TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION); + TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION); #ifdef TEST_LDOUBLE // XXX Enable once gcc is fixed. @@ -5422,11 +5489,75 @@ pow_test (void) TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); errno = 0; + TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); +#ifndef TEST_FLOAT + errno = 0; + TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + errno = 0; + TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +# if LDBL_MANT_DIG >= 106 + errno = 0; + TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +# if LDBL_MANT_DIG >= 113 + errno = 0; + TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +#endif TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); errno = 0; TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); +#ifndef TEST_FLOAT + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +# if LDBL_MANT_DIG >= 106 + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +# if LDBL_MANT_DIG >= 113 + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); +# endif +#endif errno = 0; TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); @@ -5435,16 +5566,38 @@ pow_test (void) TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); errno = 0; + TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + /* Bug 13879: spurious OVERFLOW exception may be present. */ + TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|OVERFLOW_EXCEPTION_OK); + check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0); errno = 0; TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION); + check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); + errno = 0; + /* Bug 13879: spurious OVERFLOW exception may be present. */ + TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|OVERFLOW_EXCEPTION_OK); + check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0); - TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty); + TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION); TEST_ff_f (pow, 10, -0x1p72L, 0); - TEST_ff_f (pow, max_value, max_value, plus_infty); - TEST_ff_f (pow, 10, -max_value, 0); + /* Bug 13873: OVERFLOW exception may be missing. */ + TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION_OK); + /* Bug 13872: spurious OVERFLOW exception may be present. */ + TEST_ff_f (pow, 10, -max_value, 0, OVERFLOW_EXCEPTION_OK); TEST_ff_f (pow, 0, 1, 0); TEST_ff_f (pow, 0, 11, 0); @@ -5476,32 +5629,155 @@ pow_test (void) /* pow (+inf, y) == +inf for y > 0. */ TEST_ff_f (pow, plus_infty, 2, plus_infty); + TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty); +#ifndef TEST_FLOAT + TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty); +# endif +#endif + TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty); + TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty); + TEST_ff_f (pow, plus_infty, max_value, plus_infty); /* pow (+inf, y) == +0 for y < 0. */ TEST_ff_f (pow, plus_infty, -1, 0.0); + TEST_ff_f (pow, plus_infty, -0xffffff, 0.0); +#ifndef TEST_FLOAT + TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0); +# endif +#endif + TEST_ff_f (pow, plus_infty, -0x1p24, 0.0); + TEST_ff_f (pow, plus_infty, -0x1p127, 0.0); + TEST_ff_f (pow, plus_infty, -max_value, 0.0); /* pow (-inf, y) == -inf for y an odd integer > 0. */ TEST_ff_f (pow, minus_infty, 27, minus_infty); + TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty); + TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty); +#ifndef TEST_FLOAT + TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty); + TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty); + TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty); + TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty); + TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty); +# endif +#endif /* pow (-inf, y) == +inf for y > 0 and not an odd integer. */ TEST_ff_f (pow, minus_infty, 28, plus_infty); + TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty); + TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty); + TEST_ff_f (pow, minus_infty, max_value, plus_infty); /* pow (-inf, y) == -0 for y an odd integer < 0. */ TEST_ff_f (pow, minus_infty, -3, minus_zero); + TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero); + TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero); +#ifndef TEST_FLOAT + TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero); + TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero); + TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero); + TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero); + TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero); +# endif +#endif /* pow (-inf, y) == +0 for y < 0 and not an odd integer. */ TEST_ff_f (pow, minus_infty, -2.0, 0.0); + TEST_ff_f (pow, minus_infty, -0x1p24, 0.0); + TEST_ff_f (pow, minus_infty, -0x1p127, 0.0); + TEST_ff_f (pow, minus_infty, -max_value, 0.0); /* pow (+0, y) == +0 for y an odd integer > 0. */ TEST_ff_f (pow, 0.0, 27, 0.0); + TEST_ff_f (pow, 0.0, 0xffffff, 0.0); +#ifndef TEST_FLOAT + TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0); +# endif +#endif /* pow (-0, y) == -0 for y an odd integer > 0. */ TEST_ff_f (pow, minus_zero, 27, minus_zero); + TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero); + TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero); +#ifndef TEST_FLOAT + TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero); + TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero); +#endif +#ifdef TEST_LDOUBLE +# if LDBL_MANT_DIG >= 64 + TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero); + TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero); +# endif +# if LDBL_MANT_DIG >= 106 + TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero); + TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero); +# endif +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero); + TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero); +# endif +#endif /* pow (+0, y) == +0 for y > 0 and not an odd integer. */ TEST_ff_f (pow, 0.0, 4, 0.0); + TEST_ff_f (pow, 0.0, 0x1p24, 0.0); + TEST_ff_f (pow, 0.0, 0x1p127, 0.0); + TEST_ff_f (pow, 0.0, max_value, 0.0); /* pow (-0, y) == +0 for y > 0 and not an odd integer. */ TEST_ff_f (pow, minus_zero, 4, 0.0); + TEST_ff_f (pow, minus_zero, 0x1p24, 0.0); + TEST_ff_f (pow, minus_zero, 0x1p127, 0.0); + TEST_ff_f (pow, minus_zero, max_value, 0.0); TEST_ff_f (pow, 16, 0.25L, 2); TEST_ff_f (pow, 0x1p64L, 0.125L, 256); @@ -6338,13 +6614,13 @@ scalbn_test (void) TEST_fi_f (scalbn, 1, 0L, 1); - TEST_fi_f (scalbn, 1, INT_MAX, plus_infty); + TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbn, 1, INT_MIN, plus_zero); - TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty); + TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero); - TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty); + TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero); - TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty); + TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero); END (scalbn); @@ -6369,32 +6645,32 @@ scalbln_test (void) TEST_fl_f (scalbln, 1, 0L, 1); - TEST_fi_f (scalbln, 1, INT_MAX, plus_infty); + TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, 1, INT_MIN, plus_zero); - TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty); + TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero); - TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty); + TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero); - TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty); + TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero); - TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty); + TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero); - TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty); + TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero); - TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty); + TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero); - TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty); + TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero); #if LONG_MAX >= 0x100000000 - TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty); + TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero); - TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty); + TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero); - TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty); + TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero); - TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty); + TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION); TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero); #endif |