math/libm-test.inc

   1 /* Copyright (C) 1997-2006, 2007, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 /* Part of testsuite for libm.
  20
  21    This file is processed by a perl script.  The resulting file has to
  22    be included by a master file that defines:
  23
  24    Macros:
  25    FUNC(function): converts general function name (like cos) to
  26    name with correct suffix (e.g. cosl or cosf)
  27    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  28    FLOAT:          floating point type to test
  29    - TEST_MSG:     informal message to be displayed
  30    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  31    chooses one of the parameters as delta for testing
  32    equality
  33    PRINTF_EXPR     Floating point conversion specification to print a variable
  34    of type FLOAT with printf.  PRINTF_EXPR just contains
  35    the specifier, not the percent and width arguments,
  36    e.g. "f".
  37    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  38    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  39
  40 /* This testsuite has currently tests for:
  41    acos, acosh, asin, asinh, atan, atan2, atanh,
  42    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  43    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
  44    frexp, gamma, hypot,
  45    ilogb, isfinite, isnormal,
  46    j0, j1, jn,
  47    ldexp, lgamma, log, log10, log1p, log2, logb,
  48    modf, nearbyint, nextafter, nexttoward,
  49    pow, remainder, remquo, rint, lrint, llrint,
  50    round, lround, llround,
  51    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
  52    y0, y1, yn, significand
  53
  54    and for the following complex math functions:
  55    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
  56    ccos, ccosh, cexp, cimag, clog, clog10, conj, cpow, cproj, creal,
  57    csin, csinh, csqrt, ctan, ctanh.
  58
  59    At the moment the following functions and macros aren't tested:
  60    drem (alias for remainder),
  61    finite (functions equivalent to isfinite macro),
  62    isinf, isnan,
  63    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
  64    lgamma_r,
  65    nan,
  66    pow10 (alias for exp10).
  67
  68    Parameter handling is primitive in the moment:
  69    --verbose=[0..3] for different levels of output:
  70    0: only error count
  71    1: basic report on failed tests (default)
  72    2: full report on all tests
  73    -v for full output (equals --verbose=3)
  74    -u for generation of an ULPs file
  75  */
  76
  77 /* "Philosophy":
  78
  79    This suite tests some aspects of the correct implementation of
  80    mathematical functions in libm.  Some simple, specific parameters
  81    are tested for correctness but there's no exhaustive
  82    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  83    is also tested.  Correct handling of exceptions is checked
  84    against.  These implemented tests should check all cases that are
  85    specified in ISO C99.
  86
  87    Exception testing: At the moment only divide-by-zero, invalid,
  88    overflow and underflow exceptions are tested.  Inexact exceptions
  89    aren't checked at the moment.
  90
  91    NaN values: There exist signalling and quiet NaNs.  This implementation
  92    only uses quiet NaN as parameter but does not differentiate
  93    between the two kinds of NaNs as result.  Where the sign of a NaN is
  94    significant, this is not tested.
  95
  96    Inline functions: Inlining functions should give an improvement in
  97    speed - but not in precission.  The inlined functions return
  98    reasonable values for a reasonable range of input values.  The
  99    result is not necessarily correct for all values and exceptions are
 100    not correctly raised in all cases.  Problematic input and return
 101    values are infinity, not-a-number and minus zero.  This suite
 102    therefore does not check these specific inputs and the exception
 103    handling for inlined mathematical functions - just the "reasonable"
 104    values are checked.
 105
 106    Beware: The tests might fail for any of the following reasons:
 107    - Tests are wrong
 108    - Functions are wrong
 109    - Floating Point Unit not working properly
 110    - Compiler has errors
 111
 112    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 113
 114
 115    To Do: All parameter should be numbers that can be represented as
 116    exact floating point values.  Currently some values cannot be
 117    represented exactly and therefore the result is not the expected
 118    result.  For this we will use 36 digits so that numbers can be
 119    represented exactly.  */
 120
 121 #ifndef _GNU_SOURCE
 122 # define _GNU_SOURCE
 123 #endif
 124
 125 #include "libm-test-ulps.h"
 126 #include <complex.h>
 127 #include <math.h>
 128 #include <float.h>
 129 #include <fenv.h>
 130 #include <limits.h>
 131
 132 #include <errno.h>
 133 #include <stdlib.h>
 134 #include <stdio.h>
 135 #include <string.h>
 136 #include <argp.h>
 137
 138 /* Allow platforms without all rounding modes to test properly,
 139    assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which
 140    causes fesetround() to return failure.  */
 141 #ifndef FE_TONEAREST
 142 # define FE_TONEAREST   __FE_UNDEFINED
 143 #endif
 144 #ifndef FE_TOWARDZERO
 145 # define FE_TOWARDZERO  __FE_UNDEFINED
 146 #endif
 147 #ifndef FE_UPWARD
 148 # define FE_UPWARD      __FE_UNDEFINED
 149 #endif
 150 #ifndef FE_DOWNWARD
 151 # define FE_DOWNWARD    __FE_UNDEFINED
 152 #endif
 153
 154 /* Possible exceptions */
 155 #define NO_EXCEPTION                    0x0
 156 #define INVALID_EXCEPTION               0x1
 157 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 158 #define OVERFLOW_EXCEPTION              0x4
 159 #define UNDERFLOW_EXCEPTION             0x8
 160 /* The next flags signals that those exceptions are allowed but not required.   */
 161 #define INVALID_EXCEPTION_OK            0x10
 162 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x20
 163 #define OVERFLOW_EXCEPTION_OK           0x40
 164 #define UNDERFLOW_EXCEPTION_OK          0x80
 165 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 166 /* Some special test flags, passed together with exceptions.  */
 167 #define IGNORE_ZERO_INF_SIGN            0x100
 168
 169 /* Values underflowing only for float.  */
 170 #ifdef TEST_FLOAT
 171 # define UNDERFLOW_EXCEPTION_FLOAT      UNDERFLOW_EXCEPTION
 172 # define UNDERFLOW_EXCEPTION_OK_FLOAT   UNDERFLOW_EXCEPTION_OK
 173 #else
 174 # define UNDERFLOW_EXCEPTION_FLOAT      0
 175 # define UNDERFLOW_EXCEPTION_OK_FLOAT   0
 176 #endif
 177 /* Values underflowing only for double or types with a larger least
 178    positive normal value.  */
 179 #if defined TEST_FLOAT || defined TEST_DOUBLE \
 180   || (defined TEST_LDOUBLE && LDBL_MIN_EXP >= DBL_MIN_EXP)
 181 # define UNDERFLOW_EXCEPTION_DOUBLE     UNDERFLOW_EXCEPTION
 182 #else
 183 # define UNDERFLOW_EXCEPTION_DOUBLE     0
 184 #endif
 185 /* Values underflowing only for IBM long double or types with a larger least
 186    positive normal value.  */
 187 #if defined TEST_FLOAT || (defined TEST_LDOUBLE && LDBL_MIN_EXP > DBL_MIN_EXP)
 188 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        UNDERFLOW_EXCEPTION
 189 #else
 190 # define UNDERFLOW_EXCEPTION_LDOUBLE_IBM        0
 191 #endif
 192
 193 /* Various constants (we must supply them precalculated for accuracy).  */
 194 #define M_PI_6l                 .52359877559829887307710723054658383L
 195 #define M_E2l                   7.389056098930650227230427460575008L
 196 #define M_E3l                   20.085536923187667740928529654581719L
 197 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
 198 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 199 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
 200 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
 201 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 202 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 203 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 204 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 205 #define M_PI_LOG10El            M_PIl * M_LOG10El
 206 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
 207
 208 static FILE *ulps_file; /* File to document difference.  */
 209 static int output_ulps; /* Should ulps printed?  */
 210
 211 static int noErrors;    /* number of errors */
 212 static int noTests;     /* number of tests (without testing exceptions) */
 213 static int noExcTests;  /* number of tests for exception flags */
 214 static int noXFails;    /* number of expected failures.  */
 215 static int noXPasses;   /* number of unexpected passes.  */
 216
 217 static int verbose;
 218 static int output_max_error;    /* Should the maximal errors printed?  */
 219 static int output_points;       /* Should the single function results printed?  */
 220 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 221
 222 static FLOAT minus_zero, plus_zero;
 223 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
 224 static FLOAT min_subnorm_value;
 225
 226 static FLOAT max_error, real_max_error, imag_max_error;
 227
 228
 229 #define BUILD_COMPLEX(real, imag) \
 230   ({ __complex__ FLOAT __retval;                                              \
 231      __real__ __retval = (real);                                              \
 232      __imag__ __retval = (imag);                                              \
 233      __retval; })
 234
 235 #define BUILD_COMPLEX_INT(real, imag) \
 236   ({ __complex__ int __retval;                                                \
 237      __real__ __retval = (real);                                              \
 238      __imag__ __retval = (imag);                                              \
 239      __retval; })
 240
 241
 242 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 243                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 244
 245 static void
 246 init_max_error (void)
 247 {
 248   max_error = 0;
 249   real_max_error = 0;
 250   imag_max_error = 0;
 251   feclearexcept (FE_ALL_EXCEPT);
 252 }
 253
 254 static void
 255 set_max_error (FLOAT current, FLOAT *curr_max_error)
 256 {
 257   if (current > *curr_max_error)
 258     *curr_max_error = current;
 259 }
 260
 261
 262 /* Should the message print to screen?  This depends on the verbose flag,
 263    and the test status.  */
 264 static int
 265 print_screen (int ok, int xfail)
 266 {
 267   if (output_points
 268       && (verbose > 1
 269           || (verbose == 1 && ok == xfail)))
 270     return 1;
 271   return 0;
 272 }
 273
 274
 275 /* Should the message print to screen?  This depends on the verbose flag,
 276    and the test status.  */
 277 static int
 278 print_screen_max_error (int ok, int xfail)
 279 {
 280   if (output_max_error
 281       && (verbose > 1
 282           || ((verbose == 1) && (ok == xfail))))
 283     return 1;
 284   return 0;
 285 }
 286
 287 /* Update statistic counters.  */
 288 static void
 289 update_stats (int ok, int xfail)
 290 {
 291   ++noTests;
 292   if (ok && xfail)
 293     ++noXPasses;
 294   else if (!ok && xfail)
 295     ++noXFails;
 296   else if (!ok && !xfail)
 297     ++noErrors;
 298 }
 299
 300 static void
 301 print_ulps (const char *test_name, FLOAT ulp)
 302 {
 303   if (output_ulps)
 304     {
 305       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 306       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 307                CHOOSE("ldouble", "double", "float",
 308                       "ildouble", "idouble", "ifloat"),
 309                FUNC(ceil) (ulp));
 310     }
 311 }
 312
 313 static void
 314 print_function_ulps (const char *function_name, FLOAT ulp)
 315 {
 316   if (output_ulps)
 317     {
 318       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 319       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 320                CHOOSE("ldouble", "double", "float",
 321                       "ildouble", "idouble", "ifloat"),
 322                FUNC(ceil) (ulp));
 323     }
 324 }
 325
 326
 327 static void
 328 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 329                              FLOAT imag_ulp)
 330 {
 331   if (output_ulps)
 332     {
 333       if (real_ulp != 0.0)
 334         {
 335           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 336           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 337                    CHOOSE("ldouble", "double", "float",
 338                           "ildouble", "idouble", "ifloat"),
 339                    FUNC(ceil) (real_ulp));
 340         }
 341       if (imag_ulp != 0.0)
 342         {
 343           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 344           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 345                    CHOOSE("ldouble", "double", "float",
 346                           "ildouble", "idouble", "ifloat"),
 347                    FUNC(ceil) (imag_ulp));
 348         }
 349
 350
 351     }
 352 }
 353
 354
 355
 356 /* Test if Floating-Point stack hasn't changed */
 357 static void
 358 fpstack_test (const char *test_name)
 359 {
 360 #ifdef i386
 361   static int old_stack;
 362   int sw;
 363
 364   asm ("fnstsw" : "=a" (sw));
 365   sw >>= 11;
 366   sw &= 7;
 367
 368   if (sw != old_stack)
 369     {
 370       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 371               test_name, sw, old_stack);
 372       ++noErrors;
 373       old_stack = sw;
 374     }
 375 #endif
 376 }
 377
 378
 379 static void
 380 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 381 {
 382   int ok = 0;
 383
 384   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 385     {
 386       ok = 1;
 387     }
 388
 389   if (!ok)
 390     print_function_ulps (func_name, max_error);
 391
 392
 393   if (print_screen_max_error (ok, xfail))
 394     {
 395       printf ("Maximal error of `%s'\n", func_name);
 396       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
 397       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
 398     }
 399
 400   update_stats (ok, xfail);
 401 }
 402
 403
 404 static void
 405 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 406                          __complex__ int xfail)
 407 {
 408   int ok = 0;
 409
 410   if ((real_max_error == 0 && imag_max_error == 0)
 411       || (real_max_error <= __real__ allowed
 412           && imag_max_error <= __imag__ allowed
 413           && !ignore_max_ulp))
 414     {
 415       ok = 1;
 416     }
 417
 418   if (!ok)
 419     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 420
 421
 422   if (print_screen_max_error (ok, xfail))
 423     {
 424       printf ("Maximal error of real part of: %s\n", func_name);
 425       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 426               FUNC(ceil) (real_max_error));
 427       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 428               FUNC(ceil) (__real__ allowed));
 429       printf ("Maximal error of imaginary part of: %s\n", func_name);
 430       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 431               FUNC(ceil) (imag_max_error));
 432       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 433               FUNC(ceil) (__imag__ allowed));
 434     }
 435
 436   update_stats (ok, xfail);
 437 }
 438
 439
 440 /* Test whether a given exception was raised.  */
 441 static void
 442 test_single_exception (const char *test_name,
 443                        int exception,
 444                        int exc_flag,
 445                        int fe_flag,
 446                        const char *flag_name)
 447 {
 448 #ifndef TEST_INLINE
 449   int ok = 1;
 450   if (exception & exc_flag)
 451     {
 452       if (fetestexcept (fe_flag))
 453         {
 454           if (print_screen (1, 0))
 455             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 456         }
 457       else
 458         {
 459           ok = 0;
 460           if (print_screen (0, 0))
 461             printf ("Failure: %s: Exception \"%s\" not set\n",
 462                     test_name, flag_name);
 463         }
 464     }
 465   else
 466     {
 467       if (fetestexcept (fe_flag))
 468         {
 469           ok = 0;
 470           if (print_screen (0, 0))
 471             printf ("Failure: %s: Exception \"%s\" set\n",
 472                     test_name, flag_name);
 473         }
 474       else
 475         {
 476           if (print_screen (1, 0))
 477             printf ("%s: Exception \"%s\" not set\n", test_name,
 478                     flag_name);
 479         }
 480     }
 481   if (!ok)
 482     ++noErrors;
 483
 484 #endif
 485 }
 486
 487
 488 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 489    allowed but not required exceptions.
 490 */
 491 static void
 492 test_exceptions (const char *test_name, int exception)
 493 {
 494   ++noExcTests;
 495 #ifdef FE_DIVBYZERO
 496   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 497     test_single_exception (test_name, exception,
 498                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 499                            "Divide by zero");
 500 #endif
 501 #ifdef FE_INVALID
 502   if ((exception & INVALID_EXCEPTION_OK) == 0)
 503     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 504                          "Invalid operation");
 505 #endif
 506 #ifdef FE_OVERFLOW
 507   if ((exception & OVERFLOW_EXCEPTION_OK) == 0)
 508     test_single_exception (test_name, exception, OVERFLOW_EXCEPTION,
 509                            FE_OVERFLOW, "Overflow");
 510 #endif
 511 #ifdef FE_UNDERFLOW
 512   if ((exception & UNDERFLOW_EXCEPTION_OK) == 0)
 513     test_single_exception (test_name, exception, UNDERFLOW_EXCEPTION,
 514                            FE_UNDERFLOW, "Underflow");
 515 #endif
 516   feclearexcept (FE_ALL_EXCEPT);
 517 }
 518
 519
 520 static void
 521 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 522                       FLOAT max_ulp, int xfail, int exceptions,
 523                       FLOAT *curr_max_error)
 524 {
 525   int ok = 0;
 526   int print_diff = 0;
 527   FLOAT diff = 0;
 528   FLOAT ulp = 0;
 529
 530   test_exceptions (test_name, exceptions);
 531   if (isnan (computed) && isnan (expected))
 532     ok = 1;
 533   else if (isinf (computed) && isinf (expected))
 534     {
 535       /* Test for sign of infinities.  */
 536       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 537           && signbit (computed) != signbit (expected))
 538         {
 539           ok = 0;
 540           printf ("infinity has wrong sign.\n");
 541         }
 542       else
 543         ok = 1;
 544     }
 545   /* Don't calc ulp for NaNs or infinities.  */
 546   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 547     ok = 0;
 548   else
 549     {
 550       diff = FUNC(fabs) (computed - expected);
 551       switch (fpclassify (expected))
 552         {
 553         case FP_ZERO:
 554           /* ilogb (0) isn't allowed. */
 555           ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 556           break;
 557         case FP_NORMAL:
 558           ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 559           break;
 560         case FP_SUBNORMAL:
 561           /* 1ulp for a subnormal value, shifted by MANT_DIG, is the
 562              least normal value.  */
 563           ulp = (FUNC(ldexp) (diff, MANT_DIG) / min_value);
 564           break;
 565         default:
 566           /* It should never happen. */
 567           abort ();
 568           break;
 569         }
 570       set_max_error (ulp, curr_max_error);
 571       print_diff = 1;
 572       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 573           && computed == 0.0 && expected == 0.0
 574           && signbit(computed) != signbit (expected))
 575         ok = 0;
 576       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
 577         ok = 1;
 578       else
 579         {
 580           ok = 0;
 581           print_ulps (test_name, ulp);
 582         }
 583
 584     }
 585   if (print_screen (ok, xfail))
 586     {
 587       if (!ok)
 588         printf ("Failure: ");
 589       printf ("Test: %s\n", test_name);
 590       printf ("Result:\n");
 591       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 592               computed, computed);
 593       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 594               expected, expected);
 595       if (print_diff)
 596         {
 597           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 598                   "\n", diff, diff);
 599           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 600           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 601         }
 602     }
 603   update_stats (ok, xfail);
 604
 605   fpstack_test (test_name);
 606 }
 607
 608
 609 static void
 610 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 611              FLOAT max_ulp, int xfail, int exceptions)
 612 {
 613   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 614                         exceptions, &max_error);
 615 }
 616
 617
 618 static void
 619 check_complex (const char *test_name, __complex__ FLOAT computed,
 620                __complex__ FLOAT expected,
 621                __complex__ FLOAT max_ulp, __complex__ int xfail,
 622                int exception)
 623 {
 624   FLOAT part_comp, part_exp, part_max_ulp;
 625   int part_xfail;
 626   char str[200];
 627
 628   sprintf (str, "Real part of: %s", test_name);
 629   part_comp = __real__ computed;
 630   part_exp = __real__ expected;
 631   part_max_ulp = __real__ max_ulp;
 632   part_xfail = __real__ xfail;
 633
 634   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 635                         exception, &real_max_error);
 636
 637   sprintf (str, "Imaginary part of: %s", test_name);
 638   part_comp = __imag__ computed;
 639   part_exp = __imag__ expected;
 640   part_max_ulp = __imag__ max_ulp;
 641   part_xfail = __imag__ xfail;
 642
 643   /* Don't check again for exceptions, just pass through the
 644      zero/inf sign test.  */
 645   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 646                         exception & IGNORE_ZERO_INF_SIGN,
 647                         &imag_max_error);
 648 }
 649
 650
 651 /* Check that computed and expected values are equal (int values).  */
 652 static void
 653 check_int (const char *test_name, int computed, int expected, int max_ulp,
 654            int xfail, int exceptions)
 655 {
 656   int diff = computed - expected;
 657   int ok = 0;
 658
 659   test_exceptions (test_name, exceptions);
 660   noTests++;
 661   if (abs (diff) <= max_ulp)
 662     ok = 1;
 663
 664   if (!ok)
 665     print_ulps (test_name, diff);
 666
 667   if (print_screen (ok, xfail))
 668     {
 669       if (!ok)
 670         printf ("Failure: ");
 671       printf ("Test: %s\n", test_name);
 672       printf ("Result:\n");
 673       printf (" is:         %d\n", computed);
 674       printf (" should be:  %d\n", expected);
 675     }
 676
 677   update_stats (ok, xfail);
 678   fpstack_test (test_name);
 679 }
 680
 681
 682 /* Check that computed and expected values are equal (long int values).  */
 683 static void
 684 check_long (const char *test_name, long int computed, long int expected,
 685             long int max_ulp, int xfail, int exceptions)
 686 {
 687   long int diff = computed - expected;
 688   int ok = 0;
 689
 690   test_exceptions (test_name, exceptions);
 691   noTests++;
 692   if (labs (diff) <= max_ulp)
 693     ok = 1;
 694
 695   if (!ok)
 696     print_ulps (test_name, diff);
 697
 698   if (print_screen (ok, xfail))
 699     {
 700       if (!ok)
 701         printf ("Failure: ");
 702       printf ("Test: %s\n", test_name);
 703       printf ("Result:\n");
 704       printf (" is:         %ld\n", computed);
 705       printf (" should be:  %ld\n", expected);
 706     }
 707
 708   update_stats (ok, xfail);
 709   fpstack_test (test_name);
 710 }
 711
 712
 713 /* Check that computed value is true/false.  */
 714 static void
 715 check_bool (const char *test_name, int computed, int expected,
 716             long int max_ulp, int xfail, int exceptions)
 717 {
 718   int ok = 0;
 719
 720   test_exceptions (test_name, exceptions);
 721   noTests++;
 722   if ((computed == 0) == (expected == 0))
 723     ok = 1;
 724
 725   if (print_screen (ok, xfail))
 726     {
 727       if (!ok)
 728         printf ("Failure: ");
 729       printf ("Test: %s\n", test_name);
 730       printf ("Result:\n");
 731       printf (" is:         %d\n", computed);
 732       printf (" should be:  %d\n", expected);
 733     }
 734
 735   update_stats (ok, xfail);
 736   fpstack_test (test_name);
 737 }
 738
 739
 740 /* check that computed and expected values are equal (long int values) */
 741 static void
 742 check_longlong (const char *test_name, long long int computed,
 743                 long long int expected,
 744                 long long int max_ulp, int xfail,
 745                 int exceptions)
 746 {
 747   long long int diff = computed - expected;
 748   int ok = 0;
 749
 750   test_exceptions (test_name, exceptions);
 751   noTests++;
 752   if (llabs (diff) <= max_ulp)
 753     ok = 1;
 754
 755   if (!ok)
 756     print_ulps (test_name, diff);
 757
 758   if (print_screen (ok, xfail))
 759     {
 760       if (!ok)
 761         printf ("Failure:");
 762       printf ("Test: %s\n", test_name);
 763       printf ("Result:\n");
 764       printf (" is:         %lld\n", computed);
 765       printf (" should be:  %lld\n", expected);
 766     }
 767
 768   update_stats (ok, xfail);
 769   fpstack_test (test_name);
 770 }
 771
 772
 773
 774 /* This is to prevent messages from the SVID libm emulation.  */
 775 int
 776 matherr (struct exception *x __attribute__ ((unused)))
 777 {
 778   return 1;
 779 }
 780
 781
 782 /****************************************************************************
 783   Tests for single functions of libm.
 784   Please keep them alphabetically sorted!
 785 ****************************************************************************/
 786
 787 static void
 788 acos_test (void)
 789 {
 790   errno = 0;
 791   FUNC(acos) (0);
 792   if (errno == ENOSYS)
 793     /* Function not implemented.  */
 794     return;
 795
 796   START (acos);
 797
 798   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 799   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 800   TEST_f_f (acos, nan_value, nan_value);
 801
 802   /* |x| > 1: */
 803   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 804   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 805   TEST_f_f (acos, max_value, nan_value, INVALID_EXCEPTION);
 806   TEST_f_f (acos, -max_value, nan_value, INVALID_EXCEPTION);
 807
 808   TEST_f_f (acos, 0, M_PI_2l);
 809   TEST_f_f (acos, minus_zero, M_PI_2l);
 810   TEST_f_f (acos, 1, 0);
 811   TEST_f_f (acos, -1, M_PIl);
 812   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 813   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 814   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 815   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 816   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 817   TEST_f_f (acos, 0x0.ffffffp0L, 3.4526698471620358760324948263873649728491e-4L);
 818   TEST_f_f (acos, -0x0.ffffffp0L, 3.1412473866050770348750401337968641476999L);
 819 #ifndef TEST_FLOAT
 820   TEST_f_f (acos, 0x0.ffffffff8p0L, 1.5258789062648029736620564947844627548516e-5L);
 821   TEST_f_f (acos, -0x0.ffffffff8p0L, 3.1415773948007305904329067627145550395696L);
 822   TEST_f_f (acos, 0x0.ffffffffffffp0L, 8.4293697021788088529885473244391795127130e-8L);
 823   TEST_f_f (acos, -0x0.ffffffffffffp0L, 3.1415925692960962166745548533940296398054L);
 824 #endif
 825 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
 826   TEST_f_f (acos, 0x0.ffffffffffffffffp0L, 3.2927225399135962333718255320079907245059e-10L);
 827   TEST_f_f (acos, -0x0.ffffffffffffffffp0L, 3.1415926532605209844712837599423203309964L);
 828 #endif
 829   END (acos);
 830 }
 831
 832
 833 static void
 834 acos_test_tonearest (void)
 835 {
 836   int save_round_mode;
 837   errno = 0;
 838   FUNC(acos) (0);
 839   if (errno == ENOSYS)
 840     /* Function not implemented.  */
 841     return;
 842
 843   START (acos_tonearest);
 844
 845   save_round_mode = fegetround ();
 846
 847   if (!fesetround (FE_TONEAREST))
 848     {
 849       TEST_f_f (acos, 0, M_PI_2l);
 850       TEST_f_f (acos, minus_zero, M_PI_2l);
 851       TEST_f_f (acos, 1, 0);
 852       TEST_f_f (acos, -1, M_PIl);
 853       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 854       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 855     }
 856
 857   fesetround (save_round_mode);
 858
 859   END (acos_tonearest);
 860 }
 861
 862
 863 static void
 864 acos_test_towardzero (void)
 865 {
 866   int save_round_mode;
 867   errno = 0;
 868   FUNC(acos) (0);
 869   if (errno == ENOSYS)
 870     /* Function not implemented.  */
 871     return;
 872
 873   START (acos_towardzero);
 874
 875   save_round_mode = fegetround ();
 876
 877   if (!fesetround (FE_TOWARDZERO))
 878     {
 879       TEST_f_f (acos, 0, M_PI_2l);
 880       TEST_f_f (acos, minus_zero, M_PI_2l);
 881       TEST_f_f (acos, 1, 0);
 882       TEST_f_f (acos, -1, M_PIl);
 883       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 884       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 885     }
 886
 887   fesetround (save_round_mode);
 888
 889   END (acos_towardzero);
 890 }
 891
 892
 893 static void
 894 acos_test_downward (void)
 895 {
 896   int save_round_mode;
 897   errno = 0;
 898   FUNC(acos) (0);
 899   if (errno == ENOSYS)
 900     /* Function not implemented.  */
 901     return;
 902
 903   START (acos_downward);
 904
 905   save_round_mode = fegetround ();
 906
 907   if (!fesetround (FE_DOWNWARD))
 908     {
 909       TEST_f_f (acos, 0, M_PI_2l);
 910       TEST_f_f (acos, minus_zero, M_PI_2l);
 911       TEST_f_f (acos, 1, 0);
 912       TEST_f_f (acos, -1, M_PIl);
 913       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 914       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 915     }
 916
 917   fesetround (save_round_mode);
 918
 919   END (acos_downward);
 920 }
 921
 922
 923 static void
 924 acos_test_upward (void)
 925 {
 926   int save_round_mode;
 927   errno = 0;
 928   FUNC(acos) (0);
 929   if (errno == ENOSYS)
 930     /* Function not implemented.  */
 931     return;
 932
 933   START (acos_upward);
 934
 935   save_round_mode = fegetround ();
 936
 937   if (!fesetround (FE_UPWARD))
 938     {
 939       TEST_f_f (acos, 0, M_PI_2l);
 940       TEST_f_f (acos, minus_zero, M_PI_2l);
 941       TEST_f_f (acos, 1, 0);
 942       TEST_f_f (acos, -1, M_PIl);
 943       TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 944       TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 945     }
 946
 947   fesetround (save_round_mode);
 948
 949   END (acos_upward);
 950 }
 951
 952 static void
 953 acosh_test (void)
 954 {
 955   errno = 0;
 956   FUNC(acosh) (7);
 957   if (errno == ENOSYS)
 958     /* Function not implemented.  */
 959     return;
 960
 961   START (acosh);
 962
 963   TEST_f_f (acosh, plus_infty, plus_infty);
 964   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 965
 966   /* x < 1:  */
 967   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 968   TEST_f_f (acosh, -max_value, nan_value, INVALID_EXCEPTION);
 969
 970   TEST_f_f (acosh, 1, 0);
 971   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 972
 973   END (acosh);
 974 }
 975
 976 static void
 977 asin_test (void)
 978 {
 979   errno = 0;
 980   FUNC(asin) (0);
 981   if (errno == ENOSYS)
 982     /* Function not implemented.  */
 983     return;
 984
 985   START (asin);
 986
 987   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 988   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 989   TEST_f_f (asin, nan_value, nan_value);
 990
 991   /* asin x == NaN plus invalid exception for |x| > 1.  */
 992   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
 993   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
 994   TEST_f_f (asin, max_value, nan_value, INVALID_EXCEPTION);
 995   TEST_f_f (asin, -max_value, nan_value, INVALID_EXCEPTION);
 996
 997   TEST_f_f (asin, 0, 0);
 998   TEST_f_f (asin, minus_zero, minus_zero);
 999   TEST_f_f (asin, 0.5, M_PI_6l);
1000   TEST_f_f (asin, -0.5, -M_PI_6l);
1001   TEST_f_f (asin, 1.0, M_PI_2l);
1002   TEST_f_f (asin, -1.0, -M_PI_2l);
1003   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
1004   TEST_f_f (asin, 0x0.ffffffp0L, 1.5704510598101804156437184421571127056013L);
1005   TEST_f_f (asin, -0x0.ffffffp0L, -1.5704510598101804156437184421571127056013L);
1006 #ifndef TEST_FLOAT
1007   TEST_f_f (asin, 0x0.ffffffff8p0L, 1.5707810680058339712015850710748035974710L);
1008   TEST_f_f (asin, -0x0.ffffffff8p0L, -1.5707810680058339712015850710748035974710L);
1009   TEST_f_f (asin, 0x0.ffffffffffffp0L, 1.5707962425011995974432331617542781977068L);
1010   TEST_f_f (asin, -0x0.ffffffffffffp0L, -1.5707962425011995974432331617542781977068L);
1011 #endif
1012 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
1013   TEST_f_f (asin, 0x0.ffffffffffffffffp0L, 1.5707963264656243652399620683025688888978L);
1014   TEST_f_f (asin, -0x0.ffffffffffffffffp0L, -1.5707963264656243652399620683025688888978L);
1015 #endif
1016
1017   END (asin);
1018 }
1019
1020
1021 static void
1022 asin_test_tonearest (void)
1023 {
1024   int save_round_mode;
1025   errno = 0;
1026   FUNC(asin) (0);
1027   if (errno == ENOSYS)
1028     /* Function not implemented.  */
1029     return;
1030
1031   START (asin_tonearest);
1032
1033   save_round_mode = fegetround ();
1034
1035   if (!fesetround (FE_TONEAREST))
1036     {
1037       TEST_f_f (asin, 0, 0);
1038       TEST_f_f (asin, minus_zero, minus_zero);
1039       TEST_f_f (asin, 0.5, M_PI_6l);
1040       TEST_f_f (asin, -0.5, -M_PI_6l);
1041       TEST_f_f (asin, 1.0, M_PI_2l);
1042       TEST_f_f (asin, -1.0, -M_PI_2l);
1043     }
1044
1045   fesetround (save_round_mode);
1046
1047   END (asin_tonearest);
1048 }
1049
1050
1051 static void
1052 asin_test_towardzero (void)
1053 {
1054   int save_round_mode;
1055   errno = 0;
1056   FUNC(asin) (0);
1057   if (errno == ENOSYS)
1058     /* Function not implemented.  */
1059     return;
1060
1061   START (asin_towardzero);
1062
1063   save_round_mode = fegetround ();
1064
1065   if (!fesetround (FE_TOWARDZERO))
1066     {
1067       TEST_f_f (asin, 0, 0);
1068       TEST_f_f (asin, minus_zero, minus_zero);
1069       TEST_f_f (asin, 0.5, M_PI_6l);
1070       TEST_f_f (asin, -0.5, -M_PI_6l);
1071       TEST_f_f (asin, 1.0, M_PI_2l);
1072       TEST_f_f (asin, -1.0, -M_PI_2l);
1073     }
1074
1075   fesetround (save_round_mode);
1076
1077   END (asin_towardzero);
1078 }
1079
1080
1081 static void
1082 asin_test_downward (void)
1083 {
1084   int save_round_mode;
1085   errno = 0;
1086   FUNC(asin) (0);
1087   if (errno == ENOSYS)
1088     /* Function not implemented.  */
1089     return;
1090
1091   START (asin_downward);
1092
1093   save_round_mode = fegetround ();
1094
1095   if (!fesetround (FE_DOWNWARD))
1096     {
1097       TEST_f_f (asin, 0, 0);
1098       TEST_f_f (asin, minus_zero, minus_zero);
1099       TEST_f_f (asin, 0.5, M_PI_6l);
1100       TEST_f_f (asin, -0.5, -M_PI_6l);
1101       TEST_f_f (asin, 1.0, M_PI_2l);
1102       TEST_f_f (asin, -1.0, -M_PI_2l);
1103     }
1104
1105   fesetround (save_round_mode);
1106
1107   END (asin_downward);
1108 }
1109
1110
1111 static void
1112 asin_test_upward (void)
1113 {
1114   int save_round_mode;
1115   errno = 0;
1116   FUNC(asin) (0);
1117   if (errno == ENOSYS)
1118     /* Function not implemented.  */
1119     return;
1120
1121   START (asin_upward);
1122
1123   save_round_mode = fegetround ();
1124
1125   if (!fesetround (FE_UPWARD))
1126     {
1127       TEST_f_f (asin, 0, 0);
1128       TEST_f_f (asin, minus_zero, minus_zero);
1129       TEST_f_f (asin, 0.5, M_PI_6l);
1130       TEST_f_f (asin, -0.5, -M_PI_6l);
1131       TEST_f_f (asin, 1.0, M_PI_2l);
1132       TEST_f_f (asin, -1.0, -M_PI_2l);
1133     }
1134
1135   fesetround (save_round_mode);
1136
1137   END (asin_upward);
1138 }
1139
1140 static void
1141 asinh_test (void)
1142 {
1143   errno = 0;
1144   FUNC(asinh) (0.7L);
1145   if (errno == ENOSYS)
1146     /* Function not implemented.  */
1147     return;
1148
1149   START (asinh);
1150
1151   TEST_f_f (asinh, 0, 0);
1152   TEST_f_f (asinh, minus_zero, minus_zero);
1153 #ifndef TEST_INLINE
1154   TEST_f_f (asinh, plus_infty, plus_infty);
1155   TEST_f_f (asinh, minus_infty, minus_infty);
1156 #endif
1157   TEST_f_f (asinh, nan_value, nan_value);
1158   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
1159
1160   END (asinh);
1161 }
1162
1163 static void
1164 atan_test (void)
1165 {
1166   errno = 0;
1167   FUNC(atan) (0);
1168   if (errno == ENOSYS)
1169     /* Function not implemented.  */
1170     return;
1171
1172   START (atan);
1173
1174   TEST_f_f (atan, 0, 0);
1175   TEST_f_f (atan, minus_zero, minus_zero);
1176
1177   TEST_f_f (atan, plus_infty, M_PI_2l);
1178   TEST_f_f (atan, minus_infty, -M_PI_2l);
1179   TEST_f_f (atan, nan_value, nan_value);
1180
1181   TEST_f_f (atan, 1, M_PI_4l);
1182   TEST_f_f (atan, -1, -M_PI_4l);
1183
1184   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
1185
1186   END (atan);
1187 }
1188
1189
1190
1191 static void
1192 atanh_test (void)
1193 {
1194   errno = 0;
1195   FUNC(atanh) (0.7L);
1196   if (errno == ENOSYS)
1197     /* Function not implemented.  */
1198     return;
1199
1200   START (atanh);
1201
1202
1203   TEST_f_f (atanh, 0, 0);
1204   TEST_f_f (atanh, minus_zero, minus_zero);
1205
1206   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1207   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
1208   TEST_f_f (atanh, nan_value, nan_value);
1209
1210   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
1211   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
1212   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
1213   TEST_f_f (atanh, max_value, nan_value, INVALID_EXCEPTION);
1214   TEST_f_f (atanh, -max_value, nan_value, INVALID_EXCEPTION);
1215
1216   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
1217
1218   END (atanh);
1219 }
1220
1221 static void
1222 atan2_test (void)
1223 {
1224   errno = 0;
1225   FUNC(atan2) (-0, 1);
1226   if (errno == ENOSYS)
1227     /* Function not implemented.  */
1228     return;
1229
1230   START (atan2);
1231
1232   /* atan2 (0,x) == 0 for x > 0.  */
1233   TEST_ff_f (atan2, 0, 1, 0);
1234
1235   /* atan2 (-0,x) == -0 for x > 0.  */
1236   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
1237
1238   TEST_ff_f (atan2, 0, 0, 0);
1239   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
1240
1241   /* atan2 (+0,x) == +pi for x < 0.  */
1242   TEST_ff_f (atan2, 0, -1, M_PIl);
1243
1244   /* atan2 (-0,x) == -pi for x < 0.  */
1245   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
1246
1247   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
1248   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
1249
1250   /* atan2 (y,+0) == pi/2 for y > 0.  */
1251   TEST_ff_f (atan2, 1, 0, M_PI_2l);
1252
1253   /* atan2 (y,-0) == pi/2 for y > 0.  */
1254   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
1255
1256   /* atan2 (y,+0) == -pi/2 for y < 0.  */
1257   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
1258
1259   /* atan2 (y,-0) == -pi/2 for y < 0.  */
1260   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
1261
1262   /* atan2 (y,inf) == +0 for finite y > 0.  */
1263   TEST_ff_f (atan2, 1, plus_infty, 0);
1264
1265   /* atan2 (y,inf) == -0 for finite y < 0.  */
1266   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
1267
1268   /* atan2(+inf, x) == pi/2 for finite x.  */
1269   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
1270
1271   /* atan2(-inf, x) == -pi/2 for finite x.  */
1272   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
1273
1274   /* atan2 (y,-inf) == +pi for finite y > 0.  */
1275   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
1276
1277   /* atan2 (y,-inf) == -pi for finite y < 0.  */
1278   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
1279
1280   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
1281   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
1282   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
1283   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
1284   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
1285
1286   TEST_ff_f (atan2, max_value, max_value, M_PI_4l);
1287
1288   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
1289   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
1290   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
1291   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
1292   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
1293   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
1294
1295   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
1296
1297   END (atan2);
1298 }
1299
1300 static void
1301 cabs_test (void)
1302 {
1303   errno = 0;
1304   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
1305   if (errno == ENOSYS)
1306     /* Function not implemented.  */
1307     return;
1308
1309   START (cabs);
1310
1311   /* cabs (x + iy) is specified as hypot (x,y) */
1312
1313   /* cabs (+inf + i x) == +inf.  */
1314   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
1315   /* cabs (-inf + i x) == +inf.  */
1316   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
1317
1318   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1319   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
1320
1321   TEST_c_f (cabs, nan_value, nan_value, nan_value);
1322
1323   /* cabs (x,y) == cabs (y,x).  */
1324   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1325   /* cabs (x,y) == cabs (-x,y).  */
1326   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
1327   /* cabs (x,y) == cabs (-y,x).  */
1328   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
1329   /* cabs (x,y) == cabs (-x,-y).  */
1330   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
1331   /* cabs (x,y) == cabs (-y,-x).  */
1332   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
1333   /* cabs (x,0) == fabs (x).  */
1334   TEST_c_f (cabs, -0.75L, 0, 0.75L);
1335   TEST_c_f (cabs, 0.75L, 0, 0.75L);
1336   TEST_c_f (cabs, -1.0L, 0, 1.0L);
1337   TEST_c_f (cabs, 1.0L, 0, 1.0L);
1338   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
1339   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
1340
1341   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
1342
1343   END (cabs);
1344 }
1345
1346
1347 static void
1348 cacos_test (void)
1349 {
1350   errno = 0;
1351   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1352   if (errno == ENOSYS)
1353     /* Function not implemented.  */
1354     return;
1355
1356   START (cacos);
1357
1358
1359   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1360   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1361   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1362   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1363
1364   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1365   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1366
1367   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1368   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1369
1370   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1371   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1372   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1373   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1374   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1375   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1376
1377   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1378   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1379   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1380   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1381
1382   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1383   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1384   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1385   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1386
1387   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1388   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1389
1390   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1391   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1392
1393   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1394   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1395
1396   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1397   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1398
1399   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1400   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1401
1402   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1403
1404   TEST_c_c (cacos, plus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1405   TEST_c_c (cacos, minus_zero, -1.5L, M_PI_2l, 1.194763217287109304111930828519090523536L);
1406   TEST_c_c (cacos, plus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1407   TEST_c_c (cacos, minus_zero, -1.0L, M_PI_2l, 0.8813735870195430252326093249797923090282L);
1408   TEST_c_c (cacos, plus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1409   TEST_c_c (cacos, minus_zero, -0.5L, M_PI_2l, 0.4812118250596034474977589134243684231352L);
1410   TEST_c_c (cacos, plus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1411   TEST_c_c (cacos, minus_zero, 0.5L, M_PI_2l, -0.4812118250596034474977589134243684231352L);
1412   TEST_c_c (cacos, plus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1413   TEST_c_c (cacos, minus_zero, 1.0L, M_PI_2l, -0.8813735870195430252326093249797923090282L);
1414   TEST_c_c (cacos, plus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1415   TEST_c_c (cacos, minus_zero, 1.5L, M_PI_2l, -1.194763217287109304111930828519090523536L);
1416
1417   TEST_c_c (cacos, -1.5L, plus_zero, M_PIl, -0.9624236501192068949955178268487368462704L);
1418   TEST_c_c (cacos, -1.5L, minus_zero, M_PIl, 0.9624236501192068949955178268487368462704L);
1419   TEST_c_c (cacos, -1.0L, plus_zero, M_PIl, minus_zero);
1420   TEST_c_c (cacos, -1.0L, minus_zero, M_PIl, plus_zero);
1421   TEST_c_c (cacos, -0.5L, plus_zero, 2.094395102393195492308428922186335256131L, minus_zero);
1422   TEST_c_c (cacos, -0.5L, minus_zero, 2.094395102393195492308428922186335256131L, plus_zero);
1423   TEST_c_c (cacos, 0.5L, plus_zero, 1.047197551196597746154214461093167628066L, minus_zero);
1424   TEST_c_c (cacos, 0.5L, minus_zero, 1.047197551196597746154214461093167628066L, plus_zero);
1425   TEST_c_c (cacos, 1.0L, plus_zero, plus_zero, minus_zero);
1426   TEST_c_c (cacos, 1.0L, minus_zero, plus_zero, plus_zero);
1427   TEST_c_c (cacos, 1.5L, plus_zero, plus_zero, -0.9624236501192068949955178268487368462704L);
1428   TEST_c_c (cacos, 1.5L, minus_zero, plus_zero, 0.9624236501192068949955178268487368462704L);
1429
1430   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1431   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1432
1433   END (cacos, complex);
1434 }
1435
1436 static void
1437 cacosh_test (void)
1438 {
1439   errno = 0;
1440   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1441   if (errno == ENOSYS)
1442     /* Function not implemented.  */
1443     return;
1444
1445   START (cacosh);
1446
1447
1448   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1449   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1450   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1451   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1452   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1453   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1454
1455   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1456   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1457
1458   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1459   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1460   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1461   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1462   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1463   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1464
1465   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1466   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1467   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1468   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1469
1470   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1471   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1472   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1473   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1474
1475   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1476   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1477
1478   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1479   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1480
1481   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1482   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1483
1484   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1485   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1486
1487   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1488   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1489
1490   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1491
1492   TEST_c_c (cacosh, plus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1493   TEST_c_c (cacosh, minus_zero, -1.5L, 1.194763217287109304111930828519090523536L, -M_PI_2l);
1494   TEST_c_c (cacosh, plus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1495   TEST_c_c (cacosh, minus_zero, -1.0L, 0.8813735870195430252326093249797923090282L, -M_PI_2l);
1496   TEST_c_c (cacosh, plus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1497   TEST_c_c (cacosh, minus_zero, -0.5L, 0.4812118250596034474977589134243684231352L, -M_PI_2l);
1498   TEST_c_c (cacosh, plus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1499   TEST_c_c (cacosh, minus_zero, 0.5L, 0.4812118250596034474977589134243684231352L, M_PI_2l);
1500   TEST_c_c (cacosh, plus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1501   TEST_c_c (cacosh, minus_zero, 1.0L, 0.8813735870195430252326093249797923090282L, M_PI_2l);
1502   TEST_c_c (cacosh, plus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1503   TEST_c_c (cacosh, minus_zero, 1.5L, 1.194763217287109304111930828519090523536L, M_PI_2l);
1504
1505   TEST_c_c (cacosh, -1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, M_PIl);
1506   TEST_c_c (cacosh, -1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, -M_PIl);
1507   TEST_c_c (cacosh, -1.0L, plus_zero, plus_zero, M_PIl);
1508   TEST_c_c (cacosh, -1.0L, minus_zero, plus_zero, -M_PIl);
1509   TEST_c_c (cacosh, -0.5L, plus_zero, plus_zero, 2.094395102393195492308428922186335256131L);
1510   TEST_c_c (cacosh, -0.5L, minus_zero, plus_zero, -2.094395102393195492308428922186335256131L);
1511   TEST_c_c (cacosh, 0.5L, plus_zero, plus_zero, 1.047197551196597746154214461093167628066L);
1512   TEST_c_c (cacosh, 0.5L, minus_zero, plus_zero, -1.047197551196597746154214461093167628066L);
1513   TEST_c_c (cacosh, 1.0L, plus_zero, plus_zero, plus_zero);
1514   TEST_c_c (cacosh, 1.0L, minus_zero, plus_zero, minus_zero);
1515   TEST_c_c (cacosh, 1.5L, plus_zero, 0.9624236501192068949955178268487368462704L, plus_zero);
1516   TEST_c_c (cacosh, 1.5L, minus_zero, 0.9624236501192068949955178268487368462704L, minus_zero);
1517
1518   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1519   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1520
1521   END (cacosh, complex);
1522 }
1523
1524
1525 static void
1526 carg_test (void)
1527 {
1528   START (carg);
1529
1530   /* carg (x + iy) is specified as atan2 (y, x) */
1531
1532   /* carg (x + i 0) == 0 for x > 0.  */
1533   TEST_c_f (carg, 2.0, 0, 0);
1534   /* carg (x - i 0) == -0 for x > 0.  */
1535   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1536
1537   TEST_c_f (carg, 0, 0, 0);
1538   TEST_c_f (carg, 0, minus_zero, minus_zero);
1539
1540   /* carg (x + i 0) == +pi for x < 0.  */
1541   TEST_c_f (carg, -2.0, 0, M_PIl);
1542
1543   /* carg (x - i 0) == -pi for x < 0.  */
1544   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1545
1546   TEST_c_f (carg, minus_zero, 0, M_PIl);
1547   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1548
1549   /* carg (+0 + i y) == pi/2 for y > 0.  */
1550   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1551
1552   /* carg (-0 + i y) == pi/2 for y > 0.  */
1553   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1554
1555   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1556   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1557
1558   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1559   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1560
1561   /* carg (inf + i y) == +0 for finite y > 0.  */
1562   TEST_c_f (carg, plus_infty, 2.0, 0);
1563
1564   /* carg (inf + i y) == -0 for finite y < 0.  */
1565   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1566
1567   /* carg(x + i inf) == pi/2 for finite x.  */
1568   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1569
1570   /* carg(x - i inf) == -pi/2 for finite x.  */
1571   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1572
1573   /* carg (-inf + i y) == +pi for finite y > 0.  */
1574   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1575
1576   /* carg (-inf + i y) == -pi for finite y < 0.  */
1577   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1578
1579   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1580
1581   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1582
1583   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1584
1585   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1586
1587   TEST_c_f (carg, nan_value, nan_value, nan_value);
1588
1589   END (carg);
1590 }
1591
1592 static void
1593 casin_test (void)
1594 {
1595   errno = 0;
1596   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1597   if (errno == ENOSYS)
1598     /* Function not implemented.  */
1599     return;
1600
1601   START (casin);
1602
1603   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1604   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1605   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1606   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1607
1608   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1609   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1610   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1611   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1612
1613   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1614   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1615   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1616   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1617   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1618   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1619   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1620   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1621
1622   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1623   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1624   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1625   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1626
1627   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1628   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1629   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1630   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1631
1632   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1633   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1634
1635   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1636   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1637
1638   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1639   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1640
1641   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1642   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1643
1644   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1645   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1646
1647   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1648
1649   TEST_c_c (casin, plus_zero, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L);
1650   TEST_c_c (casin, minus_zero, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L);
1651   TEST_c_c (casin, plus_zero, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L);
1652   TEST_c_c (casin, minus_zero, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L);
1653   TEST_c_c (casin, plus_zero, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L);
1654   TEST_c_c (casin, minus_zero, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L);
1655   TEST_c_c (casin, plus_zero, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L);
1656   TEST_c_c (casin, minus_zero, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L);
1657   TEST_c_c (casin, plus_zero, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L);
1658   TEST_c_c (casin, minus_zero, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L);
1659   TEST_c_c (casin, plus_zero, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L);
1660   TEST_c_c (casin, minus_zero, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L);
1661
1662   TEST_c_c (casin, -1.5L, plus_zero, -M_PI_2l, 0.9624236501192068949955178268487368462704L);
1663   TEST_c_c (casin, -1.5L, minus_zero, -M_PI_2l, -0.9624236501192068949955178268487368462704L);
1664   TEST_c_c (casin, -1.0L, plus_zero, -M_PI_2l, plus_zero);
1665   TEST_c_c (casin, -1.0L, minus_zero, -M_PI_2l, minus_zero);
1666   TEST_c_c (casin, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L, plus_zero);
1667   TEST_c_c (casin, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L, minus_zero);
1668   TEST_c_c (casin, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L, plus_zero);
1669   TEST_c_c (casin, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L, minus_zero);
1670   TEST_c_c (casin, 1.0L, plus_zero, M_PI_2l, plus_zero);
1671   TEST_c_c (casin, 1.0L, minus_zero, M_PI_2l, minus_zero);
1672   TEST_c_c (casin, 1.5L, plus_zero, M_PI_2l, 0.9624236501192068949955178268487368462704L);
1673   TEST_c_c (casin, 1.5L, minus_zero, M_PI_2l, -0.9624236501192068949955178268487368462704L);
1674
1675   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1676   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1677
1678   END (casin, complex);
1679 }
1680
1681
1682 static void
1683 casinh_test (void)
1684 {
1685   errno = 0;
1686   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1687   if (errno == ENOSYS)
1688     /* Function not implemented.  */
1689     return;
1690
1691   START (casinh);
1692
1693   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1694   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1695   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1696   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1697
1698   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1699   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1700   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1701   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1702
1703   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1704   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1705   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1706   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1707   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1708   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1709   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1710   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1711
1712   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1713   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1714   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1715   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1716
1717   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1718   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1719   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1720   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1721
1722   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1723   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1724
1725   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1726   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1727
1728   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1729   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1730
1731   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1732   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1733
1734   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1735   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1736
1737   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1738
1739   TEST_c_c (casinh, plus_zero, -1.5L, 0.9624236501192068949955178268487368462704L, -M_PI_2l);
1740   TEST_c_c (casinh, minus_zero, -1.5L, -0.9624236501192068949955178268487368462704L, -M_PI_2l);
1741   TEST_c_c (casinh, plus_zero, -1.0L, plus_zero, -M_PI_2l);
1742   TEST_c_c (casinh, minus_zero, -1.0L, minus_zero, -M_PI_2l);
1743   TEST_c_c (casinh, plus_zero, -0.5L, plus_zero, -0.5235987755982988730771072305465838140329L);
1744   TEST_c_c (casinh, minus_zero, -0.5L, minus_zero, -0.5235987755982988730771072305465838140329L);
1745   TEST_c_c (casinh, plus_zero, 0.5L, plus_zero, 0.5235987755982988730771072305465838140329L);
1746   TEST_c_c (casinh, minus_zero, 0.5L, minus_zero, 0.5235987755982988730771072305465838140329L);
1747   TEST_c_c (casinh, plus_zero, 1.0L, plus_zero, M_PI_2l);
1748   TEST_c_c (casinh, minus_zero, 1.0L, minus_zero, M_PI_2l);
1749   TEST_c_c (casinh, plus_zero, 1.5L, 0.9624236501192068949955178268487368462704L, M_PI_2l);
1750   TEST_c_c (casinh, minus_zero, 1.5L, -0.9624236501192068949955178268487368462704L, M_PI_2l);
1751
1752   TEST_c_c (casinh, -1.5L, plus_zero, -1.194763217287109304111930828519090523536L, plus_zero);
1753   TEST_c_c (casinh, -1.5L, minus_zero, -1.194763217287109304111930828519090523536L, minus_zero);
1754   TEST_c_c (casinh, -1.0L, plus_zero, -0.8813735870195430252326093249797923090282L, plus_zero);
1755   TEST_c_c (casinh, -1.0L, minus_zero, -0.8813735870195430252326093249797923090282L, minus_zero);
1756   TEST_c_c (casinh, -0.5L, plus_zero, -0.4812118250596034474977589134243684231352L, plus_zero);
1757   TEST_c_c (casinh, -0.5L, minus_zero, -0.4812118250596034474977589134243684231352L, minus_zero);
1758   TEST_c_c (casinh, 0.5L, plus_zero, 0.4812118250596034474977589134243684231352L, plus_zero);
1759   TEST_c_c (casinh, 0.5L, minus_zero, 0.4812118250596034474977589134243684231352L, minus_zero);
1760   TEST_c_c (casinh, 1.0L, plus_zero, 0.8813735870195430252326093249797923090282L, plus_zero);
1761   TEST_c_c (casinh, 1.0L, minus_zero, 0.8813735870195430252326093249797923090282L, minus_zero);
1762   TEST_c_c (casinh, 1.5L, plus_zero, 1.194763217287109304111930828519090523536L, plus_zero);
1763   TEST_c_c (casinh, 1.5L, minus_zero, 1.194763217287109304111930828519090523536L, minus_zero);
1764
1765   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1766   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1767
1768   END (casinh, complex);
1769 }
1770
1771
1772 static void
1773 catan_test (void)
1774 {
1775   errno = 0;
1776   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1777   if (errno == ENOSYS)
1778     /* Function not implemented.  */
1779     return;
1780
1781   START (catan);
1782
1783   TEST_c_c (catan, 0, 0, 0, 0);
1784   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1785   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1786   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1787
1788   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1789   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1790   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1791   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1792
1793
1794   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1795   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1796   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1797   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1798   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1799   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1800   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1801   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1802
1803   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1804   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1805   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1806   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1807
1808   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1809   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1810   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1811   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1812
1813   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1814   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1815
1816   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1817   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1818
1819   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1820   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1821
1822   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1823   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1824
1825   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1826   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1827
1828   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1829   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1830
1831   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1832
1833   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1834   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1835
1836   END (catan, complex);
1837 }
1838
1839 static void
1840 catanh_test (void)
1841 {
1842   errno = 0;
1843   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1844   if (errno == ENOSYS)
1845     /* Function not implemented.  */
1846     return;
1847
1848   START (catanh);
1849
1850   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1851   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1852   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1853   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1854
1855   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1856   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1857   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1858   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1859
1860   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1861   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1862   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1863   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1864   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1865   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1866   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1867   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1868
1869   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1870   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1871   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1872   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1873
1874   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1875   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1876   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1877   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1878
1879   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1880   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1881
1882   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1883   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1884
1885   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1886   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1887
1888   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1889   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1890
1891   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1892   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1893
1894   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1895   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1896
1897   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1898
1899   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1900   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1901
1902   END (catanh, complex);
1903 }
1904
1905 static void
1906 cbrt_test (void)
1907 {
1908   errno = 0;
1909   FUNC(cbrt) (8);
1910   if (errno == ENOSYS)
1911     /* Function not implemented.  */
1912     return;
1913
1914   START (cbrt);
1915
1916   TEST_f_f (cbrt, 0.0, 0.0);
1917   TEST_f_f (cbrt, minus_zero, minus_zero);
1918
1919   TEST_f_f (cbrt, plus_infty, plus_infty);
1920   TEST_f_f (cbrt, minus_infty, minus_infty);
1921   TEST_f_f (cbrt, nan_value, nan_value);
1922
1923   TEST_f_f (cbrt, -0.001L, -0.1L);
1924   TEST_f_f (cbrt, 8, 2);
1925   TEST_f_f (cbrt, -27.0, -3.0);
1926   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1927   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1928
1929   END (cbrt);
1930 }
1931
1932
1933 static void
1934 ccos_test (void)
1935 {
1936   errno = 0;
1937   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1938   if (errno == ENOSYS)
1939     /* Function not implemented.  */
1940     return;
1941
1942   START (ccos);
1943
1944   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1945   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1946   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1947   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1948
1949   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1950   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1951   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1952   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1953
1954   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1955   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1956   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1957   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1958
1959   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1960   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1961   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1962   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1963
1964   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1965   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1966   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1967   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1968
1969   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1970   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1971   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1972   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1973
1974   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1975   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1976
1977   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1978   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1979
1980   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1981   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1982
1983   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1984   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1985
1986   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1987   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1988
1989   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1990   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1991
1992   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1993
1994   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1995   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1996
1997   TEST_c_c (ccos, 0.75, 89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
1998   TEST_c_c (ccos, 0.75, -89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
1999   TEST_c_c (ccos, -0.75, 89.5, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2000   TEST_c_c (ccos, -0.75, -89.5, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2001
2002 #ifndef TEST_FLOAT
2003   TEST_c_c (ccos, 0.75, 710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2004   TEST_c_c (ccos, 0.75, -710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2005   TEST_c_c (ccos, -0.75, 710.5, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2006   TEST_c_c (ccos, -0.75, -710.5, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2007 #endif
2008
2009 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2010   TEST_c_c (ccos, 0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2011   TEST_c_c (ccos, 0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2012   TEST_c_c (ccos, -0.75, 11357.25, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2013   TEST_c_c (ccos, -0.75, -11357.25, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2014 #endif
2015
2016 #ifdef TEST_FLOAT
2017   TEST_c_c (ccos, 0x1p-149, 180, plus_infty, -1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2018 #endif
2019
2020 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2021   TEST_c_c (ccos, 0x1p-1074, 1440, plus_infty, -5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2022 #endif
2023
2024 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2025   TEST_c_c (ccos, 0x1p-16434L, 22730, plus_infty, -1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2026 #endif
2027
2028   END (ccos, complex);
2029 }
2030
2031
2032 static void
2033 ccosh_test (void)
2034 {
2035   errno = 0;
2036   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
2037   if (errno == ENOSYS)
2038     /* Function not implemented.  */
2039     return;
2040
2041   START (ccosh);
2042
2043   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
2044   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
2045   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
2046   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
2047
2048   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2049   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2050   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2051   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2052
2053   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
2054   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
2055   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
2056   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
2057
2058   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2059   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2060   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2061   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2062
2063   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
2064   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
2065   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
2066   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
2067
2068   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2069   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2070   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2071   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2072
2073   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2074   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2075
2076   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
2077   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
2078
2079   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2080   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2081
2082   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2083   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2084
2085   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2086   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2087
2088   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2089   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2090
2091   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
2092
2093   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
2094
2095   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
2096
2097   TEST_c_c (ccosh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2098   TEST_c_c (ccosh, -89.5, 0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2099   TEST_c_c (ccosh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
2100   TEST_c_c (ccosh, -89.5, -0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
2101
2102 #ifndef TEST_FLOAT
2103   TEST_c_c (ccosh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2104   TEST_c_c (ccosh, -710.5, 0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2105   TEST_c_c (ccosh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
2106   TEST_c_c (ccosh, -710.5, -0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
2107 #endif
2108
2109 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2110   TEST_c_c (ccosh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2111   TEST_c_c (ccosh, -11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2112   TEST_c_c (ccosh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
2113   TEST_c_c (ccosh, -11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
2114 #endif
2115
2116 #ifdef TEST_FLOAT
2117   TEST_c_c (ccosh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
2118 #endif
2119
2120 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2121   TEST_c_c (ccosh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
2122 #endif
2123
2124 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2125   TEST_c_c (ccosh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
2126 #endif
2127
2128   END (ccosh, complex);
2129 }
2130
2131
2132 static void
2133 ceil_test (void)
2134 {
2135   START (ceil);
2136
2137   TEST_f_f (ceil, 0.0, 0.0);
2138   TEST_f_f (ceil, minus_zero, minus_zero);
2139   TEST_f_f (ceil, plus_infty, plus_infty);
2140   TEST_f_f (ceil, minus_infty, minus_infty);
2141   TEST_f_f (ceil, nan_value, nan_value);
2142
2143   TEST_f_f (ceil, M_PIl, 4.0);
2144   TEST_f_f (ceil, -M_PIl, -3.0);
2145   TEST_f_f (ceil, 0.1, 1.0);
2146   TEST_f_f (ceil, 0.25, 1.0);
2147   TEST_f_f (ceil, 0.625, 1.0);
2148   TEST_f_f (ceil, -0.1, minus_zero);
2149   TEST_f_f (ceil, -0.25, minus_zero);
2150   TEST_f_f (ceil, -0.625, minus_zero);
2151
2152 #ifdef TEST_LDOUBLE
2153   /* The result can only be represented in long double.  */
2154   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
2155   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
2156   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
2157   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
2158   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
2159
2160   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
2161   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
2162   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
2163   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
2164   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
2165
2166 # if LDBL_MANT_DIG > 100
2167   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
2168   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
2169   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
2170   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
2171   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
2172   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
2173 # endif
2174
2175   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
2176   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
2177   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
2178   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
2179   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
2180
2181   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
2182   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
2183   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
2184   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
2185   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
2186
2187 # if LDBL_MANT_DIG > 100
2188   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
2189   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
2190   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
2191   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
2192   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
2193   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
2194
2195   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
2196   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
2197   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
2198   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
2199   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
2200   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
2201 # endif
2202
2203   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
2204   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
2205   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
2206   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
2207   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
2208
2209   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
2210   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
2211   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
2212   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
2213   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
2214
2215   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
2216   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
2217   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
2218   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
2219   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
2220 #endif
2221
2222   END (ceil);
2223 }
2224
2225
2226 static void
2227 cexp_test (void)
2228 {
2229   errno = 0;
2230   FUNC(cexp) (BUILD_COMPLEX (0, 0));
2231   if (errno == ENOSYS)
2232     /* Function not implemented.  */
2233     return;
2234
2235   START (cexp);
2236
2237   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
2238   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
2239   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
2240   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
2241
2242   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
2243   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
2244
2245   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
2246   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
2247
2248   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2249   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2250
2251   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2252   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2253
2254   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2255   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2256
2257   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2258   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2259
2260   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
2261   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
2262   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
2263   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
2264
2265   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2266   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2267
2268   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
2269   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
2270
2271   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
2272
2273   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
2274
2275   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2276   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2277
2278   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2279   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2280   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2281   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
2282
2283   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
2284   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
2285
2286   TEST_c_c (cexp, 0, 0x1p65, 0.99888622066058013610642172179340364209972L, -0.047183876212354673805106149805700013943218L);
2287   TEST_c_c (cexp, 0, -0x1p65, 0.99888622066058013610642172179340364209972L, 0.047183876212354673805106149805700013943218L);
2288   TEST_c_c (cexp, 50, 0x1p127, 4.053997150228616856622417636046265337193e21L, 3.232070315463388524466674772633810238819e21L);
2289
2290 #ifndef TEST_FLOAT
2291   TEST_c_c (cexp, 0, 1e22, 0.5232147853951389454975944733847094921409L, -0.8522008497671888017727058937530293682618L);
2292   TEST_c_c (cexp, 0, 0x1p1023, -0.826369834614147994500785680811743734805L, 0.5631277798508840134529434079444683477104L);
2293   TEST_c_c (cexp, 500, 0x1p1023, -1.159886268932754433233243794561351783426e217L, 7.904017694554466595359379965081774849708e216L);
2294 #endif
2295
2296 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2297   TEST_c_c (cexp, 0, 0x1p16383L, 0.9210843909921906206874509522505756251609L, 0.3893629985894208126948115852610595405563L);
2298   TEST_c_c (cexp, -10000, 0x1p16383L, 1.045876464564882298442774542991176546722e-4343L, 4.421154026488516836023811173959413420548e-4344L);
2299 #endif
2300
2301   TEST_c_c (cexp, 88.75, 0.75, 2.558360358486542817001900410314204322891e38L, 2.383359453227311447654736314679677655100e38L);
2302   TEST_c_c (cexp, -95, 0.75, 4.039714446238306526889476684000081624047e-42L, 3.763383677300535390271646960780570275931e-42L, UNDERFLOW_EXCEPTION_FLOAT);
2303
2304 #ifndef TEST_FLOAT
2305   TEST_c_c (cexp, 709.8125, 0.75, 1.355121963080879535248452862759108365762e308L, 1.262426823598609432507811340856186873507e308L);
2306   TEST_c_c (cexp, -720, 0.75, 1.486960657116368433685753325516638551722e-313L, 1.385247284245720590980701226843815229385e-313L, UNDERFLOW_EXCEPTION_DOUBLE);
2307 #endif
2308
2309 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2310   TEST_c_c (cexp, 11356.5625, 0.75, 9.052188470850960144814815984311663764287e4931L, 8.432986734191301036267148978260970230200e4931L);
2311   TEST_c_c (cexp, -11370, 0.75, 8.631121063182211587489310508568170739592e-4939L, 8.040721827809267291427062346918413482824e-4939L, UNDERFLOW_EXCEPTION);
2312 #endif
2313
2314 #ifdef TEST_FLOAT
2315   TEST_c_c (cexp, 180, 0x1p-149, plus_infty, 2.087071793345235105931967606907855310664e33L, OVERFLOW_EXCEPTION);
2316 #endif
2317
2318 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2319   TEST_c_c (cexp, 1440, 0x1p-1074, plus_infty, 1.196295853897226111293303155636183216483e302L, OVERFLOW_EXCEPTION);
2320 #endif
2321
2322 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2323   TEST_c_c (cexp, 22730, 0x1p-16434L, plus_infty, 2.435706297811211974162115164702304105374e4924L, OVERFLOW_EXCEPTION);
2324 #endif
2325
2326   TEST_c_c (cexp, 1e6, 0, plus_infty, 0, OVERFLOW_EXCEPTION);
2327   TEST_c_c (cexp, 1e6, min_value, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
2328   TEST_c_c (cexp, 1e6, -min_value, plus_infty, minus_infty, OVERFLOW_EXCEPTION);
2329
2330   END (cexp, complex);
2331 }
2332
2333
2334 static void
2335 cimag_test (void)
2336 {
2337   START (cimag);
2338   TEST_c_f (cimag, 1.0, 0.0, 0.0);
2339   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
2340   TEST_c_f (cimag, 1.0, nan_value, nan_value);
2341   TEST_c_f (cimag, nan_value, nan_value, nan_value);
2342   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
2343   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
2344   TEST_c_f (cimag, 2.0, 3.0, 3.0);
2345
2346   END (cimag);
2347 }
2348
2349 static void
2350 clog_test (void)
2351 {
2352   errno = 0;
2353   FUNC(clog) (BUILD_COMPLEX (-2, -3));
2354   if (errno == ENOSYS)
2355     /* Function not implemented.  */
2356     return;
2357
2358   START (clog);
2359
2360   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2361   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2362
2363   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2364   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2365
2366   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
2367   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
2368
2369   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
2370   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
2371
2372   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
2373   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
2374   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
2375   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
2376   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
2377   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
2378   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
2379   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
2380
2381   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
2382   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
2383   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
2384   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
2385
2386   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
2387   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
2388   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
2389   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
2390
2391   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
2392   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
2393
2394   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
2395   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
2396
2397   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2398   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2399   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2400   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2401
2402   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2403   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2404   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2405   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2406
2407   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
2408
2409   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
2410   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
2411
2412   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
2413   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2414   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
2415   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
2416
2417 #ifndef TEST_FLOAT
2418   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
2419   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
2420   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
2421   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
2422 #endif
2423
2424 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2425   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
2426   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
2427   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
2428 #endif
2429
2430   TEST_c_c (clog, 0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2431   TEST_c_c (clog, -0x1p-149L, 0x1.fp+127L, 88.69109041335841930424871526389807508374L, M_PI_2l);
2432   TEST_c_c (clog, 0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2433   TEST_c_c (clog, -0x1p-149L, -0x1.fp+127L, 88.69109041335841930424871526389807508374L, -M_PI_2l);
2434   TEST_c_c (clog, -0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, M_PIl);
2435   TEST_c_c (clog, -0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, -M_PIl);
2436 #ifdef TEST_FLOAT
2437   TEST_c_c (clog, 0x1.fp+127L, 0x1p-149L, 88.69109041335841930424871526389807508374L, plus_zero, UNDERFLOW_EXCEPTION);
2438   TEST_c_c (clog, 0x1.fp+127L, -0x1p-149L, 88.69109041335841930424871526389807508374L, minus_zero, UNDERFLOW_EXCEPTION);
2439 #endif
2440
2441 #ifndef TEST_FLOAT
2442   TEST_c_c (clog, 0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2443   TEST_c_c (clog, -0x1p-1074L, 0x1.fp+1023L, 709.7509641950694165420886960904242800794L, M_PI_2l);
2444   TEST_c_c (clog, 0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2445   TEST_c_c (clog, -0x1p-1074L, -0x1.fp+1023L, 709.7509641950694165420886960904242800794L, -M_PI_2l);
2446   TEST_c_c (clog, -0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, M_PIl);
2447   TEST_c_c (clog, -0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, -M_PIl);
2448 #endif
2449 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2450   TEST_c_c (clog, 0x1.fp+1023L, 0x1p-1074L, 709.7509641950694165420886960904242800794L, plus_zero, UNDERFLOW_EXCEPTION);
2451   TEST_c_c (clog, 0x1.fp+1023L, -0x1p-1074L, 709.7509641950694165420886960904242800794L, minus_zero, UNDERFLOW_EXCEPTION);
2452 #endif
2453
2454 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2455   TEST_c_c (clog, 0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2456   TEST_c_c (clog, -0x1p-16445L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2457   TEST_c_c (clog, 0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2458   TEST_c_c (clog, -0x1p-16445L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2459   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, M_PIl);
2460   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, -M_PIl);
2461   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16445L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2462   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16445L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2463 # if LDBL_MANT_DIG >= 113
2464   TEST_c_c (clog, 0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2465   TEST_c_c (clog, -0x1p-16494L, 0x1.fp+16383L, 11356.49165759582936919077408168801636572L, M_PI_2l);
2466   TEST_c_c (clog, 0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2467   TEST_c_c (clog, -0x1p-16494L, -0x1.fp+16383L, 11356.49165759582936919077408168801636572L, -M_PI_2l);
2468   TEST_c_c (clog, -0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, M_PIl);
2469   TEST_c_c (clog, -0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, -M_PIl);
2470   TEST_c_c (clog, 0x1.fp+16383L, 0x1p-16494L, 11356.49165759582936919077408168801636572L, plus_zero, UNDERFLOW_EXCEPTION);
2471   TEST_c_c (clog, 0x1.fp+16383L, -0x1p-16494L, 11356.49165759582936919077408168801636572L, minus_zero, UNDERFLOW_EXCEPTION);
2472 # endif
2473 #endif
2474
2475   TEST_c_c (clog, 1.0L, 0x1.234566p-10L, 6.172834701221959432440126967147726538097e-7L, 1.111110564353742042376451655136933182201e-3L);
2476   TEST_c_c (clog, -1.0L, 0x1.234566p-20L, 5.886877547844618300918562490463748605537e-13L, 3.141591568520436206990380699322226378452L);
2477   TEST_c_c (clog, 0x1.234566p-30L, 1.0L, 5.614163921211322622623353961365728040115e-19L, 1.570796325735258575254858696548386439740L);
2478   TEST_c_c (clog, -0x1.234566p-40L, -1.0L, 5.354083939753840089583620652120903838944e-25L, -1.570796326795931422008642456283782656359L);
2479   TEST_c_c (clog, 0x1.234566p-50L, 1.0L, 5.106052341226425256332038420428899201070e-31L, 1.570796326794895608681734464330528755366L);
2480   TEST_c_c (clog, 0x1.234566p-60L, 1.0L, 4.869510976053643471080816669875627875933e-37L, 1.570796326794896618244456860363082279319L);
2481   TEST_c_c (clog, 0x1p-62L, 1.0L, 2.350988701644575015937473074444491355582e-38L, 1.570796326794896619014481257142650555297L);
2482   TEST_c_c (clog, 0x1p-63L, 1.0L, 5.877471754111437539843682686111228389059e-39L, 1.570796326794896619122901474391200998698L, UNDERFLOW_EXCEPTION_FLOAT);
2483   TEST_c_c (clog, 0x1p-64L, 1.0L, 1.469367938527859384960920671527807097271e-39L, 1.570796326794896619177111583015476220398L, UNDERFLOW_EXCEPTION_FLOAT);
2484 #ifndef TEST_FLOAT
2485   TEST_c_c (clog, 0x1p-510L, 1.0L, 4.450147717014402766180465434664808128438e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2486   TEST_c_c (clog, 0x1p-511L, 1.0L, 1.112536929253600691545116358666202032110e-308L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2487   TEST_c_c (clog, 0x1p-512L, 1.0L, 2.781342323134001728862790896665505080274e-309L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION_DOUBLE);
2488 #endif
2489 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2490   TEST_c_c (clog, 0x1p-8190L, 1.0L, 6.724206286224187012525355634643505205196e-4932L, 1.570796326794896619231321691639751442099L);
2491   TEST_c_c (clog, 0x1p-8191L, 1.0L, 1.681051571556046753131338908660876301299e-4932L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2492   TEST_c_c (clog, 0x1p-8192L, 1.0L, 4.202628928890116882828347271652190753248e-4933L, 1.570796326794896619231321691639751442099L, UNDERFLOW_EXCEPTION);
2493 #endif
2494
2495   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-10L, 8.298731898331237038231468223024422855654e-5L, 1.110938609507128729312743251313024793990e-3L);
2496   TEST_c_c (clog, 0x1.000566p0L, 0x1.234p-100L, 8.237022655933121125560939513260027133767e-5L, 8.974094312218060110948251664314290484113e-31L);
2497 #ifndef TEST_FLOAT
2498   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-30L, 2.649094282537168795982991778475646793277e-10L, 3.141592652530155111500161671113150737892L);
2499   TEST_c_c (clog, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 2.649094276923003995420209214900915462737e-10L, 3.141592653589793238462643383279502884197L);
2500 #endif
2501 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2502   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 9.868649107778739757272772275265050767867e-19L, 9.868649106423871142816660980898339912137e-19L);
2503   TEST_c_c (clog, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 9.868649107778739752403260515979017248596e-19L, 1.061846605795612822522063052130030717368e-301L);
2504 #endif
2505
2506   TEST_c_c (clog, 0x0.ffffffp0L, 0x0.ffffffp-100L, -5.960464655174753498633255797994360530379e-8L, 7.888609052210118054117285652827862296732e-31L);
2507 #ifndef TEST_FLOAT
2508   TEST_c_c (clog, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -1.110223024625156602053389888482372171810e-16L, 9.332636185032188789900895447238171696171e-302L);
2509 #endif
2510 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2511   TEST_c_c (clog, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -5.421010862427522170184200798202494495630e-20L, 3.548665303440282824232502561095699343814e-4516L);
2512 #endif
2513
2514   TEST_c_c (clog, 0x1a6p-10L, 0x3a5p-10L, -1.4305135209763571252847059962654228661815e-06L, 1.1460277178115757370775644871674016684074L);
2515   TEST_c_c (clog, 0xf2p-10L, 0x3e3p-10L, 6.1988446308070710970664736815277450078106e-06L, 1.3322126499153926210226335249558203898460L);
2516   TEST_c_c (clog, 0x4d4ep-15L, 0x6605p-15L, -1.6298145321400412054744424587143483169412e-08L, 0.9223574537155056772124552172295398141249L);
2517   TEST_c_c (clog, 0x2818p-15L, 0x798fp-15L, 1.5366822245016167178749091974664853785194e-08L, 1.2522014929038946066987318471922169174157L);
2518   TEST_c_c (clog, 0x9b57bp-20L, 0xcb7b4p-20L, -3.9563019528687610863490232935890272740908e-11L, 0.9187593477446338910857133065497364950682L);
2519   TEST_c_c (clog, 0x2731p-20L, 0xfffd0p-20L, 4.4110493034041283943115971658295280288115e-11L, 1.5612279663766352262688735061954290528838L);
2520   TEST_c_c (clog, 0x2ede88p-23L, 0x771c3fp-23L, -4.4764192352906350039050902870893173560494e-13L, 1.1959106857549200806818600493552847793381L);
2521   TEST_c_c (clog, 0x11682p-23L, 0x7ffed1p-23L, 1.1723955140027907954461000991619077811832e-12L, 1.5622968405332756349813737986164832897108L);
2522   TEST_c_c (clog, 0xa1f2c1p-24L, 0xc643aep-24L, -1.0480505352462576151523512837107080269981e-13L, 0.8858771987699967480545613322309315260313L);
2523   TEST_c_c (clog, 0x659feap-24L, 0xeaf6f9p-24L, 3.7303493627403868207597214252239749960738e-14L, 1.1625816408046866464773042283673653469061L);
2524 #ifndef TEST_FLOAT
2525   TEST_c_c (clog, 0x4447d7175p-35L, 0x6c445e00ap-35L, -1.4823076576950255933915367361099865652625e-20L, 1.0081311552703893116404606212158840190615L);
2526   TEST_c_c (clog, 0x2dd46725bp-35L, 0x7783a1284p-35L, 4.4469229730850767799109418892826021157328e-20L, 1.2046235979300843056806465045930070146351L);
2527   TEST_c_c (clog, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -3.0292258760486853327810377824479932031744e-26L, 0.7998237934177411746093524982030330293980L);
2528   TEST_c_c (clog, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 5.3718272201930019901317065495843842735179e-26L, 1.0503831592447830576186444373011142397404L);
2529   TEST_c_c (clog, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -6.2122796286154679676173624516405339768606e-30L, 1.4904138780720095276446375492434049214172L);
2530   TEST_c_c (clog, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 3.2047474274603604594851472963586149973093e-29L, 1.4422922682185099608731642353544207976604L);
2531   TEST_c_c (clog, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -9.7375017988218644730510244778042114638107e-30L, 0.9790637929494922564724108399524154766631L);
2532   TEST_c_c (clog, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 8.3076914081087805757422664530653247447136e-30L, 1.2072712126771536614482822173033535043206L);
2533   TEST_c_c (clog, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -2.5083311595699359750201056724289010648701e-30L, 1.3710185432462268491534742969536240564640L);
2534   TEST_c_c (clog, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 1.0168910106364605304135563536838075568606e-30L, 0.8208373755522359859870890246475340086663L);
2535   TEST_c_c (clog, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 5.0844550531823026520677817684239496041087e-32L, 1.2627468605458094918919206628466016525397L);
2536   TEST_c_c (clog, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -5.2000108498455368032511404449795741611813e-32L, 1.5288921536982513453421343495466824420259L);
2537 #endif
2538 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2539   TEST_c_c (clog, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -1.1931267660846218205882675852805793644095e-36L, 1.2402109774337032400594953899784058127412L);
2540   TEST_c_c (clog, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 6.4064442119814669184296141278612389400075e-37L, 0.9193591364645830864185131402313014890145L);
2541   TEST_c_c (clog, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -2.3362950222592964220878638677292132852104e-37L, 1.1856121127236268105413184264288408265852L);
2542   TEST_c_c (clog, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 2.4244570985709679851855191080208817099132e-37L, 1.1393074519572050614551047548718495655972L);
2543   TEST_c_c (clog, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -9.9182335850630508484862145328126979066934e-39L, 1.3146479888794807046338799047003947008804L);
2544 #endif
2545 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2546   TEST_c_c (clog, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -1.0509738482436128031927971874674370984602e-45L, 1.0509191467640012308402149909370784281448L);
2547   TEST_c_c (clog, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 1.3487497719126364307640897239165442763573e-43L, 1.1750493008528425228929764149024375035382L);
2548   TEST_c_c (clog, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -4.7775669192897997174762089350332738583822e-50L, 0.8393953487996880419413728440067635213372L);
2549   TEST_c_c (clog, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 2.8398125044729578740243199963484494962411e-50L, 0.9149964976334130461795060758257083099706L);
2550   TEST_c_c (clog, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -3.5048022044913950094635368750889659723004e-57L, 1.3345633256521815205858155673950177421079L);
2551   TEST_c_c (clog, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 4.1101771307217268747345114262406964584250e-56L, 1.4596065864518742494094402406719567059585L);
2552   TEST_c_c (clog, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -1.4281333889622737316199756373421183559948e-62L, 1.3673546561165378090903506783353927980633L);
2553   TEST_c_c (clog, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 1.0027319539522347477331743836657426754857e-62L, 0.8193464073721167323313606647411269414759L);
2554   TEST_c_c (clog, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -1.7471844652198029695350765775994001163767e-63L, 1.1789110097072986038243729592318526094314L);
2555   TEST_c_c (clog, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 4.3299788920664682288477984749202524623248e-63L, 1.4746938237585656250866370987773473745867L);
2556 #endif
2557 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2558   TEST_c_c (clog, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -1.1683999374665377365054966073875064467108e-66L, 1.3257197596350832748781065387304444940172L);
2559   TEST_c_c (clog, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 1.5077923002544367932999503838191154621839e-65L, 1.2897445708311412721399861948957141824914L);
2560   TEST_c_c (clog, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -7.1865869169568789348552370692485515571497e-67L, 0.8730167479365994646287897223471819363668L);
2561   TEST_c_c (clog, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 6.6255694866654064502633121109394710807528e-66L, 1.0526409614996288387567810726095850312049L);
2562   TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L);
2563   TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L);
2564 #endif
2565
2566   END (clog, complex);
2567 }
2568
2569
2570 static void
2571 clog10_test (void)
2572 {
2573   errno = 0;
2574   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2575   if (errno == ENOSYS)
2576     /* Function not implemented.  */
2577     return;
2578
2579   START (clog10);
2580
2581   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2582   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2583
2584   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2585   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2586
2587   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2588
2589   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2590   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2591
2592   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2593   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2594   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2595   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2596   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2597   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2598   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2599   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2600
2601   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2602   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2603   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2604   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2605
2606   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2607   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2608   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2609   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2610
2611   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2612   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2613
2614   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2615   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2616
2617   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2618   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2619   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2620   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2621
2622   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2623   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2624   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2625   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2626
2627   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2628
2629   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2630   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2631
2632   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2633   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2634   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2635   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2636
2637 #ifndef TEST_FLOAT
2638   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2639   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2640   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2641   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2642 #endif
2643
2644 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2645   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2646   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2647   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2648 #endif
2649
2650   TEST_c_c (clog10, 0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2651   TEST_c_c (clog10, -0x1p-149L, 0x1.fp+127L, 38.51805116050395969095658815123105801479L, 0.6821881769209206737428918127156778851051L);
2652   TEST_c_c (clog10, 0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2653   TEST_c_c (clog10, -0x1p-149L, -0x1.fp+127L, 38.51805116050395969095658815123105801479L, -0.6821881769209206737428918127156778851051L);
2654   TEST_c_c (clog10, -0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, 1.364376353841841347485783625431355770210L);
2655   TEST_c_c (clog10, -0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, -1.364376353841841347485783625431355770210L);
2656 #ifdef TEST_FLOAT
2657   TEST_c_c (clog10, 0x1.fp+127L, 0x1p-149L, 38.51805116050395969095658815123105801479L, plus_zero, UNDERFLOW_EXCEPTION);
2658   TEST_c_c (clog10, 0x1.fp+127L, -0x1p-149L, 38.51805116050395969095658815123105801479L, minus_zero, UNDERFLOW_EXCEPTION);
2659 #endif
2660
2661 #ifndef TEST_FLOAT
2662   TEST_c_c (clog10, 0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2663   TEST_c_c (clog10, -0x1p-1074L, 0x1.fp+1023L, 308.2409272754311106024666378243768099991L, 0.6821881769209206737428918127156778851051L);
2664   TEST_c_c (clog10, 0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2665   TEST_c_c (clog10, -0x1p-1074L, -0x1.fp+1023L, 308.2409272754311106024666378243768099991L, -0.6821881769209206737428918127156778851051L);
2666   TEST_c_c (clog10, -0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, 1.364376353841841347485783625431355770210L);
2667   TEST_c_c (clog10, -0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, -1.364376353841841347485783625431355770210L);
2668 #endif
2669 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
2670   TEST_c_c (clog10, 0x1.fp+1023L, 0x1p-1074L, 308.2409272754311106024666378243768099991L, plus_zero, UNDERFLOW_EXCEPTION);
2671   TEST_c_c (clog10, 0x1.fp+1023L, -0x1p-1074L, 308.2409272754311106024666378243768099991L, minus_zero, UNDERFLOW_EXCEPTION);
2672 #endif
2673
2674 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2675   TEST_c_c (clog10, 0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2676   TEST_c_c (clog10, -0x1p-16445L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2677   TEST_c_c (clog10, 0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2678   TEST_c_c (clog10, -0x1p-16445L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2679   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2680   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2681   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16445L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2682   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16445L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2683 # if LDBL_MANT_DIG >= 113
2684   TEST_c_c (clog10, 0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2685   TEST_c_c (clog10, -0x1p-16494L, 0x1.fp+16383L, 4932.061660674182269085496060792589701158L, 0.6821881769209206737428918127156778851051L);
2686   TEST_c_c (clog10, 0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2687   TEST_c_c (clog10, -0x1p-16494L, -0x1.fp+16383L, 4932.061660674182269085496060792589701158L, -0.6821881769209206737428918127156778851051L);
2688   TEST_c_c (clog10, -0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, 1.364376353841841347485783625431355770210L);
2689   TEST_c_c (clog10, -0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, -1.364376353841841347485783625431355770210L);
2690   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p-16494L, 4932.061660674182269085496060792589701158L, plus_zero, UNDERFLOW_EXCEPTION);
2691   TEST_c_c (clog10, 0x1.fp+16383L, -0x1p-16494L, 4932.061660674182269085496060792589701158L, minus_zero, UNDERFLOW_EXCEPTION);
2692 # endif
2693 #endif
2694
2695   TEST_c_c (clog10, 1.0L, 0x1.234566p-10L, 2.680828048441605163181684680300513080769e-7L, 4.825491868832381486767558728169977751564e-4L);
2696   TEST_c_c (clog10, -1.0L, 0x1.234566p-20L, 2.556638434669064077889576526006849923281e-13L, 1.364375882602207106407956770293808181427L);
2697   TEST_c_c (clog10, 0x1.234566p-30L, 1.0L, 2.438200411482400072282924063740535840474e-19L, 6.821881764607257184291586401763604544928e-1L);
2698   TEST_c_c (clog10, -0x1.234566p-40L, -1.0L, 2.325249110681915353442924915876654139373e-25L, -6.821881769213700828789403802671540158935e-1L);
2699   TEST_c_c (clog10, 0x1.234566p-50L, 1.0L, 2.217530356103816369479108963807448194409e-31L, 6.821881769209202348667823902864283966959e-1L);
2700   TEST_c_c (clog10, 0x1.234566p-60L, 1.0L, 2.114801746467415208319767917450504756866e-37L, 6.821881769209206733143018621078368211515e-1L);
2701   TEST_c_c (clog10, 0x1p-61L, 1.0L, 4.084085680564517578238994467153626207224e-38L, 6.821881769209206735545466044044889962925e-1L);
2702   TEST_c_c (clog10, 0x1p-62L, 1.0L, 1.021021420141129394559748616788406551878e-38L, 6.821881769209206736487192085600834406988e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2703   TEST_c_c (clog10, 0x1p-63L, 1.0L, 2.552553550352823486399371541971016379740e-39L, 6.821881769209206736958055106378806629019e-1L, UNDERFLOW_EXCEPTION_FLOAT);
2704 #ifndef TEST_FLOAT
2705   TEST_c_c (clog10, 0x1p-509L, 1.0L, 7.730698388614835910296270976605350994446e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
2706   TEST_c_c (clog10, 0x1p-510L, 1.0L, 1.932674597153708977574067744151337748612e-308L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2707   TEST_c_c (clog10, 0x1p-511L, 1.0L, 4.831686492884272443935169360378344371529e-309L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION_DOUBLE);
2708 #endif
2709 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2710   TEST_c_c (clog10, 0x1p-8189L, 1.0L, 1.168114274114528946314738738025008370069e-4931L, 6.821881769209206737428918127156778851051e-1L);
2711   TEST_c_c (clog10, 0x1p-8190L, 1.0L, 2.920285685286322365786846845062520925172e-4932L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2712   TEST_c_c (clog10, 0x1p-8191L, 1.0L, 7.300714213215805914467117112656302312931e-4933L, 6.821881769209206737428918127156778851051e-1L, UNDERFLOW_EXCEPTION);
2713 #endif
2714
2715   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-10L, 3.604093470239754109961125085078190708674e-5L, 4.824745078422174667425851670822596859720e-4L);
2716   TEST_c_c (clog10, 0x1.000566p0L, 0x1.234p-100L, 3.577293486783822178310971763308187385546e-5L, 3.897399639875661463735636919790792140598e-31L);
2717 #ifndef TEST_FLOAT
2718   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-30L, 1.150487028947346337782682105935961875822e-10L, 1.364376353381646356131680448946397884147L);
2719   TEST_c_c (clog10, -0x1.0000000123456p0L, 0x1.2345678p-1000L, 1.150487026509145544402795327729455391948e-10L, 1.364376353841841347485783625431355770210L);
2720 #endif
2721 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2722   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-60L, 4.285899851347756188767674032946882584784e-19L, 4.285899850759344225805480528847018395861e-19L);
2723   TEST_c_c (clog10, 0x1.00000000000000123456789abcp0L, 0x1.23456789p-1000L, 4.285899851347756186652871946325962330640e-19L, 4.611541215247321502041995872887317363241e-302L);
2724 #endif
2725
2726   TEST_c_c (clog10, 0x0.ffffffp0L, 0x0.ffffffp-100L, -2.588596909321764128428416045209904492216e-8L, 3.425979381266895667295625489912064603415e-31L);
2727 #ifndef TEST_FLOAT
2728   TEST_c_c (clog10, 0x0.fffffffffffff8p0L, 0x0.fffffffffffff8p-1000L, -4.821637332766435821255375046554377090472e-17L, 4.053112396770095089737411317782466262176e-302L);
2729 #endif
2730 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
2731   TEST_c_c (clog10, 0x0.ffffffffffffffffp0L, 0x0.ffffffffffffffffp-15000L, -2.354315103889861110220423157644627849164e-20L, 1.541165759405643564697852372112893034397e-4516L);
2732 #endif
2733
2734   TEST_c_c (clog10, 0x1a6p-10L, 0x3a5p-10L, -6.2126412844802358329771948751248003038444e-07L, 0.4977135139537443711784513409096950995985L);
2735   TEST_c_c (clog10, 0xf2p-10L, 0x3e3p-10L, 2.6921240173351112953324592659528481616879e-06L, 0.5785726025799636431142862788413361783862L);
2736   TEST_c_c (clog10, 0x4d4ep-15L, 0x6605p-15L, -7.0781945783414996953799915941870192015212e-09L, 0.4005747524909781155537088181659175147564L);
2737   TEST_c_c (clog10, 0x2818p-15L, 0x798fp-15L, 6.6737261053986614395049481326819059203910e-09L, 0.5438241985991753781478398141908629586460L);
2738   TEST_c_c (clog10, 0x9b57bp-20L, 0xcb7b4p-20L, -1.7182001068739620267773842120965071561416e-11L, 0.3990121149225253562859800593935899629087L);
2739   TEST_c_c (clog10, 0x2731p-20L, 0xfffd0p-20L, 1.9156943718715958194239364991329064049438e-11L, 0.6780326907904082601285090019969008967595L);
2740   TEST_c_c (clog10, 0x2ede88p-23L, 0x771c3fp-23L, -1.9440841725722970687903291200493082253766e-13L, 0.5193774116724956222518530053006822210323L);
2741   TEST_c_c (clog10, 0x11682p-23L, 0x7ffed1p-23L, 5.0916490233953865181284669870035717560498e-13L, 0.6784968969384861816694467029319146542069L);
2742   TEST_c_c (clog10, 0xa1f2c1p-24L, 0xc643aep-24L, -4.5516256421319921959681423447271490869664e-14L, 0.3847315790697197749315054516562206543710L);
2743   TEST_c_c (clog10, 0x659feap-24L, 0xeaf6f9p-24L, 1.6200701438094619117335617123525612051457e-14L, 0.5049027913635038013499728086604870749732L);
2744 #ifndef TEST_FLOAT
2745   TEST_c_c (clog10, 0x4447d7175p-35L, 0x6c445e00ap-35L, -6.4375803621988389731799033530075237868110e-21L, 0.4378257977686804492768642780897650927167L);
2746   TEST_c_c (clog10, 0x2dd46725bp-35L, 0x7783a1284p-35L, 1.9312741086596516918394613098872836703188e-20L, 0.5231613813514771042838490538484014771862L);
2747   TEST_c_c (clog10, 0x164c74eea876p-45L, 0x16f393482f77p-45L, -1.3155760824064879362415202279780039150764e-26L, 0.3473590599762514228227328130640352044313L);
2748   TEST_c_c (clog10, 0xfe961079616p-45L, 0x1bc37e09e6d1p-45L, 2.3329549194675052736016290082882121135546e-26L, 0.4561756099441139182878993697611751382976L);
2749   TEST_c_c (clog10, 0xa4722f19346cp-51L, 0x7f9631c5e7f07p-51L, -2.6979587627476803379953050733225113494503e-30L, 0.6472785229986997177606324374555347813105L);
2750   TEST_c_c (clog10, 0x10673dd0f2481p-51L, 0x7ef1d17cefbd2p-51L, 1.3918041236396763648388478552321724382899e-29L, 0.6263795733790237053262025311642907438291L);
2751   TEST_c_c (clog10, 0x8ecbf810c4ae6p-52L, 0xd479468b09a37p-52L, -4.2289432987513243393180377141513840878196e-30L, 0.4252020027092323591068799049905597805296L);
2752   TEST_c_c (clog10, 0x5b06b680ea2ccp-52L, 0xef452b965da9fp-52L, 3.6079845358966994996207055940336690133424e-30L, 0.5243112258263349992771652393178033846555L);
2753   TEST_c_c (clog10, 0x659b70ab7971bp-53L, 0x1f5d111e08abecp-53L, -1.0893543813872082317104059174982092534059e-30L, 0.5954257879188711495921161433751775633232L);
2754   TEST_c_c (clog10, 0x15cfbd1990d1ffp-53L, 0x176a3973e09a9ap-53L, 4.4163015461643576961232672330852798804976e-31L, 0.3564851427422832755956993418877523303529L);
2755   TEST_c_c (clog10, 0x1367a310575591p-54L, 0x3cfcc0a0541f60p-54L, 2.2081507730821788480616336165447731164865e-32L, 0.5484039935757001196548030312819898864760L);
2756   TEST_c_c (clog10, 0x55cb6d0c83af5p-55L, 0x7fe33c0c7c4e90p-55L, -2.2583360179249556400630343805573865814771e-32L, 0.6639894257763289307423302343317622430835L);
2757 #endif
2758 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64
2759   TEST_c_c (clog10, 0x298c62cb546588a7p-63L, 0x7911b1dfcc4ecdaep-63L, -5.1816837072162316773907242302011632570857e-37L, 0.5386167838952956925896424154370364458140L);
2760   TEST_c_c (clog10, 0x4d9c37e2b5cb4533p-63L, 0x65c98be2385a042ep-63L, 2.7822833698845776001753149807484078521508e-37L, 0.3992725998539071066769046272515417679815L);
2761   TEST_c_c (clog10, 0x602fd5037c4792efp-64L, 0xed3e2086dcca80b8p-64L, -1.0146400362652473358437501879334790111898e-37L, 0.5149047982335273098246594109614460842099L);
2762   TEST_c_c (clog10, 0x6b10b4f3520217b6p-64L, 0xe8893cbb449253a1p-64L, 1.0529283395205396881397407610630442563938e-37L, 0.4947949395762683446121140513971996916447L);
2763   TEST_c_c (clog10, 0x81b7efa81fc35ad1p-65L, 0x1ef4b835f1c79d812p-65L, -4.3074341162203896332989394770760901408798e-39L, 0.5709443672155660428417571212549720987784L);
2764 #endif
2765 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 106
2766   TEST_c_c (clog10, 0x3f96469050f650869c2p-75L, 0x6f16b2c9c8b05988335p-75L, -4.5643214291682663316715446865040356750881e-46L, 0.4564083863660793840592614609053162690362L);
2767   TEST_c_c (clog10, 0x3157fc1d73233e580c8p-75L, 0x761b52ccd435d7c7f5fp-75L, 5.8575458340992751256451490143468457830297e-44L, 0.5103174273246635294300470585396890237265L);
2768   TEST_c_c (clog10, 0x155f8afc4c48685bf63610p-85L, 0x17d0cf2652cdbeb1294e19p-85L, -2.0748709499710785084693619097712106753591e-50L, 0.3645447681189598740620098186365764884771L);
2769   TEST_c_c (clog10, 0x13836d58a13448d750b4b9p-85L, 0x195ca7bc3ab4f9161edbe6p-85L, 1.2333149003324592532859843519619084433953e-50L, 0.3973779298829931059309198145608711073016L);
2770   TEST_c_c (clog10, 0x1df515eb171a808b9e400266p-95L, 0x7c71eb0cd4688dfe98581c77p-95L, -1.5221162575729652613635150540947625639689e-57L, 0.5795934880811949230121092882659698986043L);
2771   TEST_c_c (clog10, 0xe33f66c9542ca25cc43c867p-95L, 0x7f35a68ebd3704a43c465864p-95L, 1.7850272475173865337808494725293124613817e-56L, 0.6338990862456906754888183278564382516852L);
2772   TEST_c_c (clog10, 0x6771f22c64ed551b857c128b4cp-105L, 0x1f570e7a13cc3cf2f44fd793ea1p-105L, -6.2023045024810589256360494043570293518879e-63L, 0.5938345819561308555003145899438513900776L);
2773   TEST_c_c (clog10, 0x15d8ab6ed05ca514086ac3a1e84p-105L, 0x1761e480aa094c0b10b34b09ce9p-105L, 4.3548095442952115860848857519953610343042e-63L, 0.3558376234889641500775150477035448866763L);
2774   TEST_c_c (clog10, 0x187190c1a334497bdbde5a95f48p-106L, 0x3b25f08062d0a095c4cfbbc338dp-106L, -7.5879257211204444302994221436282805900756e-64L, 0.5119945461708707332160859198685423099187L);
2775   TEST_c_c (clog10, 0x6241ef0da53f539f02fad67dabp-106L, 0x3fb46641182f7efd9caa769dac0p-106L, 1.8804859395820231849002915747252695375405e-63L, 0.6404513901551516189871978418046651877394L);
2776 #endif
2777 #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 113
2778   TEST_c_c (clog10, 0x3e1d0a105ac4ebeacd9c6952d34cp-112L, 0xf859b3d1b06d005dcbb5516d5479p-112L, -5.0742964549782184008668435276046798273476e-67L, 0.5757527761596220360985719127090110408283L);
2779   TEST_c_c (clog10, 0x47017a2e36807acb1e5214b209dep-112L, 0xf5f4a550c9d75e3bb1839d865f0dp-112L, 6.5482587585671294601662599808612773010057e-66L, 0.5601289501766423782280643144987875760229L);
2780   TEST_c_c (clog10, 0x148f818cb7a9258fca942ade2a0cap-113L, 0x18854a34780b8333ec53310ad7001p-113L, -3.1210950417524756037077807411854181477733e-67L, 0.3791463562379872585396164879981280044658L);
2781   TEST_c_c (clog10, 0xfd95243681c055c2632286921092p-113L, 0x1bccabcd29ca2152860ec29e34ef7p-113L, 2.8774482675253468630312378575186855052697e-66L, 0.4571561610046221605554903008571429975493L);
2782   TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L);
2783   TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L);
2784 #endif
2785
2786   END (clog10, complex);
2787 }
2788
2789
2790 static void
2791 conj_test (void)
2792 {
2793   START (conj);
2794   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2795   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2796   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2797   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2798   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2799   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2800   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2801
2802   END (conj, complex);
2803 }
2804
2805
2806 static void
2807 copysign_test (void)
2808 {
2809   START (copysign);
2810
2811   TEST_ff_f (copysign, 0, 4, 0);
2812   TEST_ff_f (copysign, 0, -4, minus_zero);
2813   TEST_ff_f (copysign, minus_zero, 4, 0);
2814   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2815
2816   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2817   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2818   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2819   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2820
2821   TEST_ff_f (copysign, 0, plus_infty, 0);
2822   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2823   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2824   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2825
2826   /* XXX More correctly we would have to check the sign of the NaN.  */
2827   TEST_ff_f (copysign, nan_value, 0, nan_value);
2828   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2829   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2830   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2831
2832   END (copysign);
2833 }
2834
2835
2836 static void
2837 cos_test (void)
2838 {
2839   errno = 0;
2840   FUNC(cos) (0);
2841   if (errno == ENOSYS)
2842     /* Function not implemented.  */
2843     return;
2844
2845   START (cos);
2846
2847   TEST_f_f (cos, 0, 1);
2848   TEST_f_f (cos, minus_zero, 1);
2849   errno = 0;
2850   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2851   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2852   errno = 0;
2853   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2854   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2855   errno = 0;
2856   TEST_f_f (cos, nan_value, nan_value);
2857   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2858
2859   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2860   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2861   TEST_f_f (cos, M_PI_2l, 0);
2862
2863   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2864
2865   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2866   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2867
2868 #ifdef TEST_DOUBLE
2869   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2870 #endif
2871
2872   TEST_f_f (cos, 0x1.442f74p+15, 2.4407839902314016628485779006274989801517e-06L);
2873
2874 #ifndef TEST_FLOAT
2875   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2876   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2877 #endif
2878
2879 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2880   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2881 #endif
2882
2883   TEST_f_f (cos, 0x1p+120, -9.25879022854837867303861764107414946730833e-01L);
2884   TEST_f_f (cos, 0x1p+127, 7.81914638714960072263910298466369236613162e-01L);
2885   TEST_f_f (cos, 0x1.fffff8p+127, 9.98819362551949040703862043664101081064641e-01L);
2886   TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L);
2887   TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L);
2888   TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L);
2889
2890   END (cos);
2891 }
2892
2893
2894 static void
2895 cos_test_tonearest (void)
2896 {
2897   int save_round_mode;
2898   errno = 0;
2899   FUNC(cos) (0);
2900   if (errno == ENOSYS)
2901     /* Function not implemented.  */
2902     return;
2903
2904   START (cos_tonearest);
2905
2906   save_round_mode = fegetround ();
2907
2908   if (!fesetround (FE_TONEAREST))
2909     {
2910       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2911       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2912       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2913       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2914       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2915       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2916       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2917       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2918       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2919       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2920     }
2921
2922   fesetround (save_round_mode);
2923
2924   END (cos_tonearest);
2925 }
2926
2927
2928 static void
2929 cos_test_towardzero (void)
2930 {
2931   int save_round_mode;
2932   errno = 0;
2933   FUNC(cos) (0);
2934   if (errno == ENOSYS)
2935     /* Function not implemented.  */
2936     return;
2937
2938   START (cos_towardzero);
2939
2940   save_round_mode = fegetround ();
2941
2942   if (!fesetround (FE_TOWARDZERO))
2943     {
2944       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2945       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2946       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2947       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2948       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2949       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2950       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2951       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2952       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2953       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2954     }
2955
2956   fesetround (save_round_mode);
2957
2958   END (cos_towardzero);
2959 }
2960
2961
2962 static void
2963 cos_test_downward (void)
2964 {
2965   int save_round_mode;
2966   errno = 0;
2967   FUNC(cos) (0);
2968   if (errno == ENOSYS)
2969     /* Function not implemented.  */
2970     return;
2971
2972   START (cos_downward);
2973
2974   save_round_mode = fegetround ();
2975
2976   if (!fesetround (FE_DOWNWARD))
2977     {
2978       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2979       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2980       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2981       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2982       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2983       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2984       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2985       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2986       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2987       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2988     }
2989
2990   fesetround (save_round_mode);
2991
2992   END (cos_downward);
2993 }
2994
2995
2996 static void
2997 cos_test_upward (void)
2998 {
2999   int save_round_mode;
3000   errno = 0;
3001   FUNC(cos) (0);
3002   if (errno == ENOSYS)
3003     /* Function not implemented.  */
3004     return;
3005
3006   START (cos_upward);
3007
3008   save_round_mode = fegetround ();
3009
3010   if (!fesetround (FE_UPWARD))
3011     {
3012       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
3013       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
3014       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
3015       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
3016       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
3017       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
3018       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
3019       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
3020       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
3021       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
3022     }
3023
3024   fesetround (save_round_mode);
3025
3026   END (cos_upward);
3027 }
3028
3029
3030 static void
3031 cosh_test (void)
3032 {
3033   errno = 0;
3034   FUNC(cosh) (0.7L);
3035   if (errno == ENOSYS)
3036     /* Function not implemented.  */
3037     return;
3038
3039   START (cosh);
3040   TEST_f_f (cosh, 0, 1);
3041   TEST_f_f (cosh, minus_zero, 1);
3042
3043 #ifndef TEST_INLINE
3044   TEST_f_f (cosh, plus_infty, plus_infty);
3045   TEST_f_f (cosh, minus_infty, plus_infty);
3046 #endif
3047   TEST_f_f (cosh, nan_value, nan_value);
3048
3049   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
3050
3051 #ifndef TEST_FLOAT
3052   TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3053   TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L);
3054 #endif
3055
3056   END (cosh);
3057 }
3058
3059
3060 static void
3061 cosh_test_tonearest (void)
3062 {
3063   int save_round_mode;
3064   errno = 0;
3065   FUNC(cosh) (0);
3066   if (errno == ENOSYS)
3067     /* Function not implemented.  */
3068     return;
3069
3070   START (cosh_tonearest);
3071
3072   save_round_mode = fegetround ();
3073
3074   if (!fesetround (FE_TONEAREST))
3075     {
3076       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3077       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3078       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3079     }
3080
3081   fesetround (save_round_mode);
3082
3083   END (cosh_tonearest);
3084 }
3085
3086
3087 static void
3088 cosh_test_towardzero (void)
3089 {
3090   int save_round_mode;
3091   errno = 0;
3092   FUNC(cosh) (0);
3093   if (errno == ENOSYS)
3094     /* Function not implemented.  */
3095     return;
3096
3097   START (cosh_towardzero);
3098
3099   save_round_mode = fegetround ();
3100
3101   if (!fesetround (FE_TOWARDZERO))
3102     {
3103       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3104       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3105       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3106     }
3107
3108   fesetround (save_round_mode);
3109
3110   END (cosh_towardzero);
3111 }
3112
3113
3114 static void
3115 cosh_test_downward (void)
3116 {
3117   int save_round_mode;
3118   errno = 0;
3119   FUNC(cosh) (0);
3120   if (errno == ENOSYS)
3121     /* Function not implemented.  */
3122     return;
3123
3124   START (cosh_downward);
3125
3126   save_round_mode = fegetround ();
3127
3128   if (!fesetround (FE_DOWNWARD))
3129     {
3130       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3131       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3132       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3133     }
3134
3135   fesetround (save_round_mode);
3136
3137   END (cosh_downward);
3138 }
3139
3140
3141 static void
3142 cosh_test_upward (void)
3143 {
3144   int save_round_mode;
3145   errno = 0;
3146   FUNC(cosh) (0);
3147   if (errno == ENOSYS)
3148     /* Function not implemented.  */
3149     return;
3150
3151   START (cosh_upward);
3152
3153   save_round_mode = fegetround ();
3154
3155   if (!fesetround (FE_UPWARD))
3156     {
3157       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
3158       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
3159       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
3160     }
3161
3162   fesetround (save_round_mode);
3163
3164   END (cosh_upward);
3165 }
3166
3167
3168 static void
3169 cpow_test (void)
3170 {
3171   errno = 0;
3172   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
3173   if (errno == ENOSYS)
3174     /* Function not implemented.  */
3175     return;
3176
3177   START (cpow);
3178
3179   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
3180   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
3181
3182   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
3183   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
3184
3185   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
3186
3187   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
3188   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
3189   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
3190   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
3191
3192   END (cpow, complex);
3193 }
3194
3195
3196 static void
3197 cproj_test (void)
3198 {
3199   START (cproj);
3200   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
3201   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
3202   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
3203   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
3204
3205   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
3206
3207   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
3208   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
3209   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
3210   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
3211
3212   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
3213   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
3214
3215   END (cproj, complex);
3216 }
3217
3218
3219 static void
3220 creal_test (void)
3221 {
3222   START (creal);
3223   TEST_c_f (creal, 0.0, 1.0, 0.0);
3224   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
3225   TEST_c_f (creal, nan_value, 1.0, nan_value);
3226   TEST_c_f (creal, nan_value, nan_value, nan_value);
3227   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
3228   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
3229   TEST_c_f (creal, 2.0, 3.0, 2.0);
3230
3231   END (creal);
3232 }
3233
3234 static void
3235 csin_test (void)
3236 {
3237   errno = 0;
3238   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
3239   if (errno == ENOSYS)
3240     /* Function not implemented.  */
3241     return;
3242
3243   START (csin);
3244
3245   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
3246   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
3247   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
3248   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
3249
3250   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
3251   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
3252   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
3253   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
3254
3255   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3256   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3257   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3258   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3259
3260   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3261   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3262   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3263   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3264
3265   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3266   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
3267   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
3268   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
3269
3270   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
3271   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
3272   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
3273   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
3274
3275   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3276   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
3277
3278   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3279   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3280
3281   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3282   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3283
3284   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
3285   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
3286
3287   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3288   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3289
3290   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3291   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3292
3293   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3294
3295   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3296   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3297
3298   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3299   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3300   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3301   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3302
3303 #ifndef TEST_FLOAT
3304   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3305   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3306   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3307   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3308 #endif
3309
3310 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3311   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3312   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3313   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3314   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3315 #endif
3316
3317 #ifdef TEST_FLOAT
3318   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3319 #endif
3320
3321 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3322   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3323 #endif
3324
3325 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3326   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3327 #endif
3328
3329   END (csin, complex);
3330 }
3331
3332
3333 static void
3334 csinh_test (void)
3335 {
3336   errno = 0;
3337   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3338   if (errno == ENOSYS)
3339     /* Function not implemented.  */
3340     return;
3341
3342   START (csinh);
3343
3344   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3345   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3346   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3347   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3348
3349   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3350   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3351   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3352   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3353
3354   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3355   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3356   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3357   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3358
3359   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3360   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3361   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3362   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3363
3364   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3365   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3366   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3367   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3368
3369   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3370   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3371   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3372   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3373
3374   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3375   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3376
3377   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3378   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3379
3380   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3381   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3382
3383   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3384   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3385
3386   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3387   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3388
3389   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3390   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3391
3392   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3393
3394   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3395   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3396
3397   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3398   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3399   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3400   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3401
3402 #ifndef TEST_FLOAT
3403   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3404   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3405   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3406   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3407 #endif
3408
3409 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3410   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3411   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3412   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3413   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3414 #endif
3415
3416 #ifdef TEST_FLOAT
3417   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3418 #endif
3419
3420 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3421   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3422 #endif
3423
3424 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3425   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3426 #endif
3427
3428   END (csinh, complex);
3429 }
3430
3431
3432 static void
3433 csqrt_test (void)
3434 {
3435   errno = 0;
3436   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3437   if (errno == ENOSYS)
3438     /* Function not implemented.  */
3439     return;
3440
3441   START (csqrt);
3442
3443   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3444   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3445   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3446   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3447
3448   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3449   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3450   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3451   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3452
3453   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3454   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3455   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3456   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3457
3458   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3459   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3460   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3461   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3462   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3463   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3464   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3465   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3466   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3467   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3468   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3469   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3470
3471   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3472
3473   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3474
3475   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3476   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3477   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3478   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3479
3480   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3481   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3482   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3483   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3484
3485   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3486
3487   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3488   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3489   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3490   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3491   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3492   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3493   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3494   /* Principal square root should be returned (i.e., non-negative real
3495      part).  */
3496   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3497
3498   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3499   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3500   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3501   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3502
3503   TEST_c_c (csqrt, plus_zero, 0x1p-149L, 2.646977960169688559588507814623881131411e-23L, 2.646977960169688559588507814623881131411e-23L);
3504   TEST_c_c (csqrt, 0x1p-50L, 0x1p-149L, 2.980232238769531250000000000000000000000e-8L, 2.350988701644575015937473074444491355637e-38L);
3505 #ifdef TEST_FLOAT
3506   TEST_c_c (csqrt, 0x1p+127L, 0x1p-149L, 1.304381782533278221234957180625250836888e19L, plus_zero, UNDERFLOW_EXCEPTION);
3507 #endif
3508   TEST_c_c (csqrt, 0x1p-149L, 0x1p+127L, 9.223372036854775808000000000000000000000e18L, 9.223372036854775808000000000000000000000e18L);
3509   TEST_c_c (csqrt, 0x1.000002p-126L, 0x1.000002p-126L, 1.191195773697904627170323731331667740087e-19L, 4.934094449071842328766868579214125217132e-20L);
3510   TEST_c_c (csqrt, -0x1.000002p-126L, -0x1.000002p-126L, 4.934094449071842328766868579214125217132e-20L, -1.191195773697904627170323731331667740087e-19L);
3511
3512 #ifndef TEST_FLOAT
3513   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3514   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3515   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
3516   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3517
3518   TEST_c_c (csqrt, plus_zero, 0x1p-1074L, 1.571727784702628688909515672805082228285e-162L, 1.571727784702628688909515672805082228285e-162L);
3519   TEST_c_c (csqrt, 0x1p-500L, 0x1p-1074L, 5.527147875260444560247265192192255725514e-76L, 4.469444793151709302716387622440056066334e-249L);
3520 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3521   TEST_c_c (csqrt, 0x1p+1023L, 0x1p-1074L, 9.480751908109176726832526455652159260085e153L, plus_zero, UNDERFLOW_EXCEPTION);
3522 #endif
3523   TEST_c_c (csqrt, 0x1p-1074L, 0x1p+1023L, 6.703903964971298549787012499102923063740e153L, 6.703903964971298549787012499102923063740e153L);
3524   TEST_c_c (csqrt, 0x1.0000000000001p-1022L, 0x1.0000000000001p-1022L, 1.638872094839911521020410942677082920935e-154L, 6.788430486774966350907249113759995429568e-155L);
3525   TEST_c_c (csqrt, -0x1.0000000000001p-1022L, -0x1.0000000000001p-1022L, 6.788430486774966350907249113759995429568e-155L, -1.638872094839911521020410942677082920935e-154L);
3526 #endif
3527
3528 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3529   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3530   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3531   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3532
3533   TEST_c_c (csqrt, plus_zero, 0x1p-16445L, 4.269191686890197837775136325621239761720e-2476L, 4.269191686890197837775136325621239761720e-2476L);
3534   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16445L, 2.660791472672778409283210520357607795518e-753L, 6.849840675828785164910701384823702064234e-4199L);
3535   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16445L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3536   TEST_c_c (csqrt, 0x1p-16445L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3537   TEST_c_c (csqrt, 0x1.0000000000000002p-16382L, 0x1.0000000000000002p-16382L, 2.014551439675644900131815801350165472778e-2466L, 8.344545284118961664300307045791497724440e-2467L);
3538   TEST_c_c (csqrt, -0x1.0000000000000002p-16382L, -0x1.0000000000000002p-16382L, 8.344545284118961664300307045791497724440e-2467L, -2.014551439675644900131815801350165472778e-2466L);
3539
3540 # if LDBL_MANT_DIG >= 113
3541   TEST_c_c (csqrt, plus_zero, 0x1p-16494L, 1.799329752913293143453817328207572571442e-2483L, 1.799329752913293143453817328207572571442e-2483L);
3542   TEST_c_c (csqrt, 0x1p-5000L, 0x1p-16494L, 2.660791472672778409283210520357607795518e-753L, 1.216776133331049643422030716668249905907e-4213L);
3543   TEST_c_c (csqrt, 0x1p+16383L, 0x1p-16494L, 7.712754032630730034273323365543179095045e2465L, plus_zero, UNDERFLOW_EXCEPTION);
3544   TEST_c_c (csqrt, 0x1p-16494L, 0x1p+16383L, 5.453740678097079647314921223668914312241e2465L, 5.453740678097079647314921223668914312241e2465L);
3545   TEST_c_c (csqrt, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-16382L, 2.014551439675644900022606748976158925145e-2466L, 8.344545284118961663847948339519226074126e-2467L);
3546   TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L);
3547 # endif
3548 #endif
3549
3550   END (csqrt, complex);
3551 }
3552
3553 static void
3554 ctan_test (void)
3555 {
3556   errno = 0;
3557   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3558   if (errno == ENOSYS)
3559     /* Function not implemented.  */
3560     return;
3561
3562   START (ctan);
3563
3564   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3565   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3566   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3567   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3568
3569   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3570   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3571   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3572   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3573
3574   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3575   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3576   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3577   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3578
3579   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3580   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3581   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3582   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3583   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3584   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3585   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3586   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3587
3588   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3589   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3590
3591   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3592   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3593
3594   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3595   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3596
3597   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3598   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3599   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3600   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3601
3602   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3603
3604   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3605   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3606
3607   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3608   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3609
3610 #ifndef TEST_FLOAT
3611   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3612   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3613 #endif
3614
3615 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3616   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3617   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3618 #endif
3619
3620   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3621
3622   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3623
3624 #ifndef TEST_FLOAT
3625   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3626 #endif
3627
3628 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3629   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3630 #endif
3631
3632   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3633   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3634   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3635   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3636
3637   END (ctan, complex);
3638 }
3639
3640
3641 static void
3642 ctan_test_tonearest (void)
3643 {
3644   int save_round_mode;
3645   errno = 0;
3646   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3647   if (errno == ENOSYS)
3648     /* Function not implemented.  */
3649     return;
3650
3651   START (ctan_tonearest);
3652
3653   save_round_mode = fegetround ();
3654
3655   if (!fesetround (FE_TONEAREST))
3656     {
3657       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3658
3659 #ifndef TEST_FLOAT
3660       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3661 #endif
3662
3663 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3664       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3665 #endif
3666     }
3667
3668   fesetround (save_round_mode);
3669
3670   END (ctan_tonearest, complex);
3671 }
3672
3673
3674 static void
3675 ctan_test_towardzero (void)
3676 {
3677   int save_round_mode;
3678   errno = 0;
3679   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3680   if (errno == ENOSYS)
3681     /* Function not implemented.  */
3682     return;
3683
3684   START (ctan_towardzero);
3685
3686   save_round_mode = fegetround ();
3687
3688   if (!fesetround (FE_TOWARDZERO))
3689     {
3690       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3691
3692 #ifndef TEST_FLOAT
3693       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3694 #endif
3695
3696 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3697       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3698 #endif
3699     }
3700
3701   fesetround (save_round_mode);
3702
3703   END (ctan_towardzero, complex);
3704 }
3705
3706
3707 static void
3708 ctan_test_downward (void)
3709 {
3710   int save_round_mode;
3711   errno = 0;
3712   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3713   if (errno == ENOSYS)
3714     /* Function not implemented.  */
3715     return;
3716
3717   START (ctan_downward);
3718
3719   save_round_mode = fegetround ();
3720
3721   if (!fesetround (FE_DOWNWARD))
3722     {
3723       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3724
3725 #ifndef TEST_FLOAT
3726       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3727 #endif
3728
3729 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3730       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3731 #endif
3732     }
3733
3734   fesetround (save_round_mode);
3735
3736   END (ctan_downward, complex);
3737 }
3738
3739
3740 static void
3741 ctan_test_upward (void)
3742 {
3743   int save_round_mode;
3744   errno = 0;
3745   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3746   if (errno == ENOSYS)
3747     /* Function not implemented.  */
3748     return;
3749
3750   START (ctan_upward);
3751
3752   save_round_mode = fegetround ();
3753
3754   if (!fesetround (FE_UPWARD))
3755     {
3756       TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L);
3757
3758 #ifndef TEST_FLOAT
3759       TEST_c_c (ctan, 0x1.921fb54442d18p+0, 0x1p-1074, 1.633123935319536975596773704152891653086e16L, 1.317719414943508315995636961402669067843e-291L);
3760 #endif
3761
3762 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3763       TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L);
3764 #endif
3765     }
3766
3767   fesetround (save_round_mode);
3768
3769   END (ctan_upward, complex);
3770 }
3771
3772
3773 static void
3774 ctanh_test (void)
3775 {
3776   errno = 0;
3777   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
3778   if (errno == ENOSYS)
3779     /* Function not implemented.  */
3780     return;
3781
3782   START (ctanh);
3783
3784   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
3785   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
3786   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
3787   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
3788
3789   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
3790   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
3791   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
3792   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
3793   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
3794   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
3795   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
3796   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
3797
3798   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3799   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3800   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3801   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3802   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3803   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3804   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3805   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3806
3807   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3808   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3809
3810   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
3811   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
3812
3813   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3814   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3815
3816   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3817   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3818   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3819   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3820
3821   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
3822
3823   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
3824
3825   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
3826   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
3827
3828   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
3829   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
3830
3831 #ifndef TEST_FLOAT
3832   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
3833   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
3834 #endif
3835
3836 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3837   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
3838   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
3839 #endif
3840
3841   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
3842
3843   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
3844
3845 #ifndef TEST_FLOAT
3846   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
3847 #endif
3848
3849 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3850   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
3851 #endif
3852
3853   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
3854   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
3855   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
3856   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
3857
3858   END (ctanh, complex);
3859 }
3860
3861
3862 static void
3863 ctanh_test_tonearest (void)
3864 {
3865   int save_round_mode;
3866   errno = 0;
3867   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3868   if (errno == ENOSYS)
3869     /* Function not implemented.  */
3870     return;
3871
3872   START (ctanh_tonearest);
3873
3874   save_round_mode = fegetround ();
3875
3876   if (!fesetround (FE_TONEAREST))
3877     {
3878       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3879
3880 #ifndef TEST_FLOAT
3881       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3882 #endif
3883
3884 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3885       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3886 #endif
3887     }
3888
3889   fesetround (save_round_mode);
3890
3891   END (ctanh_tonearest, complex);
3892 }
3893
3894
3895 static void
3896 ctanh_test_towardzero (void)
3897 {
3898   int save_round_mode;
3899   errno = 0;
3900   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3901   if (errno == ENOSYS)
3902     /* Function not implemented.  */
3903     return;
3904
3905   START (ctanh_towardzero);
3906
3907   save_round_mode = fegetround ();
3908
3909   if (!fesetround (FE_TOWARDZERO))
3910     {
3911       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3912
3913 #ifndef TEST_FLOAT
3914       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3915 #endif
3916
3917 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3918       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3919 #endif
3920     }
3921
3922   fesetround (save_round_mode);
3923
3924   END (ctanh_towardzero, complex);
3925 }
3926
3927
3928 static void
3929 ctanh_test_downward (void)
3930 {
3931   int save_round_mode;
3932   errno = 0;
3933   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3934   if (errno == ENOSYS)
3935     /* Function not implemented.  */
3936     return;
3937
3938   START (ctanh_downward);
3939
3940   save_round_mode = fegetround ();
3941
3942   if (!fesetround (FE_DOWNWARD))
3943     {
3944       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3945
3946 #ifndef TEST_FLOAT
3947       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3948 #endif
3949
3950 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3951       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3952 #endif
3953     }
3954
3955   fesetround (save_round_mode);
3956
3957   END (ctanh_downward, complex);
3958 }
3959
3960
3961 static void
3962 ctanh_test_upward (void)
3963 {
3964   int save_round_mode;
3965   errno = 0;
3966   FUNC(ctanh) (BUILD_COMPLEX (0.7L, 1.2L));
3967   if (errno == ENOSYS)
3968     /* Function not implemented.  */
3969     return;
3970
3971   START (ctanh_upward);
3972
3973   save_round_mode = fegetround ();
3974
3975   if (!fesetround (FE_UPWARD))
3976     {
3977       TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L);
3978
3979 #ifndef TEST_FLOAT
3980       TEST_c_c (ctanh, 0x1p-1074, 0x1.921fb54442d18p+0, 1.317719414943508315995636961402669067843e-291L, 1.633123935319536975596773704152891653086e16L);
3981 #endif
3982
3983 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
3984       TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L);
3985 #endif
3986     }
3987
3988   fesetround (save_round_mode);
3989
3990   END (ctanh_upward, complex);
3991 }
3992
3993
3994 static void
3995 erf_test (void)
3996 {
3997   errno = 0;
3998   FUNC(erf) (0);
3999   if (errno == ENOSYS)
4000     /* Function not implemented.  */
4001     return;
4002
4003   START (erf);
4004
4005   TEST_f_f (erf, 0, 0);
4006   TEST_f_f (erf, minus_zero, minus_zero);
4007   TEST_f_f (erf, plus_infty, 1);
4008   TEST_f_f (erf, minus_infty, -1);
4009   TEST_f_f (erf, nan_value, nan_value);
4010
4011   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
4012   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
4013   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
4014   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
4015   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
4016   TEST_f_f (erf, 27.0L, 1.0L);
4017
4018   END (erf);
4019 }
4020
4021
4022 static void
4023 erfc_test (void)
4024 {
4025   errno = 0;
4026   FUNC(erfc) (0);
4027   if (errno == ENOSYS)
4028     /* Function not implemented.  */
4029     return;
4030
4031   START (erfc);
4032
4033   TEST_f_f (erfc, plus_infty, 0.0);
4034   TEST_f_f (erfc, minus_infty, 2.0);
4035   TEST_f_f (erfc, 0.0, 1.0);
4036   TEST_f_f (erfc, minus_zero, 1.0);
4037   TEST_f_f (erfc, nan_value, nan_value);
4038
4039   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
4040   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
4041   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
4042   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
4043   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
4044   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
4045   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
4046   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
4047 #ifdef TEST_LDOUBLE
4048   /* The result can only be represented in long double.  */
4049 # if LDBL_MIN_10_EXP < -319
4050   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
4051 # endif
4052 # if LDBL_MANT_DIG >= 106
4053   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
4054 # endif
4055 #endif
4056
4057   END (erfc);
4058 }
4059
4060
4061 static void
4062 exp_test (void)
4063 {
4064   errno = 0;
4065   FUNC(exp) (0);
4066   if (errno == ENOSYS)
4067     /* Function not implemented.  */
4068     return;
4069
4070   START (exp);
4071
4072   TEST_f_f (exp, 0, 1);
4073   TEST_f_f (exp, minus_zero, 1);
4074
4075 #ifndef TEST_INLINE
4076   TEST_f_f (exp, plus_infty, plus_infty);
4077   TEST_f_f (exp, minus_infty, 0);
4078 #endif
4079   TEST_f_f (exp, nan_value, nan_value);
4080   TEST_f_f (exp, 1, M_El);
4081
4082   TEST_f_f (exp, 2, M_E2l);
4083   TEST_f_f (exp, 3, M_E3l);
4084   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
4085   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
4086   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
4087 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
4088   /* The result can only be represented in sane long double.  */
4089   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
4090 #endif
4091
4092 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
4093   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
4094   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
4095 #endif
4096   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
4097   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
4098   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
4099
4100   END (exp);
4101 }
4102
4103
4104 static void
4105 exp_test_tonearest (void)
4106 {
4107   int save_round_mode;
4108   errno = 0;
4109   FUNC(exp) (0);
4110   if (errno == ENOSYS)
4111     /* Function not implemented.  */
4112     return;
4113
4114   START (exp_tonearest);
4115
4116   save_round_mode = fegetround ();
4117
4118   if (!fesetround (FE_TONEAREST))
4119     {
4120       TEST_f_f (exp, 1, M_El);
4121       TEST_f_f (exp, 2, M_E2l);
4122       TEST_f_f (exp, 3, M_E3l);
4123     }
4124
4125   fesetround (save_round_mode);
4126
4127   END (exp_tonearest);
4128 }
4129
4130
4131 static void
4132 exp_test_towardzero (void)
4133 {
4134   int save_round_mode;
4135   errno = 0;
4136   FUNC(exp) (0);
4137   if (errno == ENOSYS)
4138     /* Function not implemented.  */
4139     return;
4140
4141   START (exp_towardzero);
4142
4143   save_round_mode = fegetround ();
4144
4145   if (!fesetround (FE_TOWARDZERO))
4146     {
4147       TEST_f_f (exp, 1, M_El);
4148       TEST_f_f (exp, 2, M_E2l);
4149       TEST_f_f (exp, 3, M_E3l);
4150     }
4151
4152   fesetround (save_round_mode);
4153
4154   END (exp_towardzero);
4155 }
4156
4157
4158 static void
4159 exp_test_downward (void)
4160 {
4161   int save_round_mode;
4162   errno = 0;
4163   FUNC(exp) (0);
4164   if (errno == ENOSYS)
4165     /* Function not implemented.  */
4166     return;
4167
4168   START (exp_downward);
4169
4170   save_round_mode = fegetround ();
4171
4172   if (!fesetround (FE_DOWNWARD))
4173     {
4174       TEST_f_f (exp, 1, M_El);
4175       TEST_f_f (exp, 2, M_E2l);
4176       TEST_f_f (exp, 3, M_E3l);
4177     }
4178
4179   fesetround (save_round_mode);
4180
4181   END (exp_downward);
4182 }
4183
4184
4185 static void
4186 exp_test_upward (void)
4187 {
4188   int save_round_mode;
4189   errno = 0;
4190   FUNC(exp) (0);
4191   if (errno == ENOSYS)
4192     /* Function not implemented.  */
4193     return;
4194
4195   START (exp_upward);
4196
4197   save_round_mode = fegetround ();
4198
4199   if (!fesetround (FE_UPWARD))
4200     {
4201       TEST_f_f (exp, 1, M_El);
4202       TEST_f_f (exp, 2, M_E2l);
4203       TEST_f_f (exp, 3, M_E3l);
4204     }
4205
4206   fesetround (save_round_mode);
4207
4208   END (exp_upward);
4209 }
4210
4211
4212 static void
4213 exp10_test (void)
4214 {
4215   errno = 0;
4216   FUNC(exp10) (0);
4217   if (errno == ENOSYS)
4218     /* Function not implemented.  */
4219     return;
4220
4221   START (exp10);
4222
4223   TEST_f_f (exp10, 0, 1);
4224   TEST_f_f (exp10, minus_zero, 1);
4225
4226   TEST_f_f (exp10, plus_infty, plus_infty);
4227   TEST_f_f (exp10, minus_infty, 0);
4228   TEST_f_f (exp10, nan_value, nan_value);
4229   TEST_f_f (exp10, 3, 1000);
4230   TEST_f_f (exp10, -1, 0.1L);
4231   TEST_f_f (exp10, 36, 1.0e36L);
4232   TEST_f_f (exp10, -36, 1.0e-36L);
4233 #ifndef TEST_FLOAT
4234   TEST_f_f (exp10, 305, 1.0e305L);
4235   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
4236 #endif
4237 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
4238   TEST_f_f (exp10, 4932, 1.0e4932L);
4239   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
4240 #endif
4241   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4242   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
4243   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
4244   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
4245   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
4246
4247   END (exp10);
4248 }
4249
4250
4251 static void
4252 exp2_test (void)
4253 {
4254   errno = 0;
4255   FUNC(exp2) (0);
4256   if (errno == ENOSYS)
4257     /* Function not implemented.  */
4258     return;
4259
4260   START (exp2);
4261
4262   TEST_f_f (exp2, 0, 1);
4263   TEST_f_f (exp2, minus_zero, 1);
4264   TEST_f_f (exp2, plus_infty, plus_infty);
4265   TEST_f_f (exp2, minus_infty, 0);
4266   TEST_f_f (exp2, nan_value, nan_value);
4267
4268   TEST_f_f (exp2, 10, 1024);
4269   TEST_f_f (exp2, -1, 0.5);
4270   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
4271   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
4272   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
4273   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
4274   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
4275
4276   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
4277   TEST_f_f (exp2, 127, 0x1p127);
4278   TEST_f_f (exp2, -149, 0x1p-149);
4279
4280 #ifndef TEST_FLOAT
4281   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
4282   TEST_f_f (exp2, 1023, 0x1p1023);
4283   TEST_f_f (exp2, -1074, 0x1p-1074);
4284 #endif
4285
4286 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4287   TEST_f_f (exp2, 16383, 0x1p16383L);
4288   TEST_f_f (exp2, -16400, 0x1p-16400L);
4289 #endif
4290
4291   END (exp2);
4292 }
4293
4294
4295 static void
4296 expm1_test (void)
4297 {
4298   errno = 0;
4299   FUNC(expm1) (0);
4300   if (errno == ENOSYS)
4301     /* Function not implemented.  */
4302     return;
4303
4304   START (expm1);
4305
4306   TEST_f_f (expm1, 0, 0);
4307   TEST_f_f (expm1, minus_zero, minus_zero);
4308
4309 #ifndef TEST_INLINE
4310   TEST_f_f (expm1, plus_infty, plus_infty);
4311   TEST_f_f (expm1, minus_infty, -1);
4312 #endif
4313   TEST_f_f (expm1, nan_value, nan_value);
4314
4315   TEST_f_f (expm1, 1, M_El - 1.0);
4316   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
4317
4318   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
4319
4320 #ifndef TEST_FLOAT
4321   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
4322   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
4323 #endif
4324
4325 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
4326   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
4327 #endif
4328
4329   TEST_f_f (expm1, -10.0, -0.9999546000702375151484644084844394493898L);
4330   TEST_f_f (expm1, -16.0, -0.9999998874648252807408854862248209398728L);
4331   TEST_f_f (expm1, -17.0, -0.9999999586006228121483334034897228104472L);
4332   TEST_f_f (expm1, -18.0, -0.9999999847700202552873715638633707664826L);
4333   TEST_f_f (expm1, -36.0, -0.9999999999999997680477169756430611687736L);
4334   TEST_f_f (expm1, -37.0, -0.9999999999999999146695237425593420572195L);
4335   TEST_f_f (expm1, -38.0, -0.9999999999999999686086720795197037129104L);
4336   TEST_f_f (expm1, -44.0, -0.9999999999999999999221886775886620348429L);
4337   TEST_f_f (expm1, -45.0, -0.9999999999999999999713748141945060635553L);
4338   TEST_f_f (expm1, -46.0, -0.9999999999999999999894693826424461876212L);
4339   TEST_f_f (expm1, -73.0, -0.9999999999999999999999999999999802074012L);
4340   TEST_f_f (expm1, -74.0, -0.9999999999999999999999999999999927187098L);
4341   TEST_f_f (expm1, -75.0, -0.9999999999999999999999999999999973213630L);
4342   TEST_f_f (expm1, -78.0, -0.9999999999999999999999999999999998666385L);
4343   TEST_f_f (expm1, -79.0, -0.9999999999999999999999999999999999509391L);
4344   TEST_f_f (expm1, -80.0, -0.9999999999999999999999999999999999819515L);
4345   TEST_f_f (expm1, -100.0, -1.0);
4346   TEST_f_f (expm1, -1000.0, -1.0);
4347   TEST_f_f (expm1, -10000.0, -1.0);
4348   TEST_f_f (expm1, -100000.0, -1.0);
4349
4350   errno = 0;
4351   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
4352   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
4353   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
4354   TEST_f_f (expm1, -max_value, -1);
4355
4356   END (expm1);
4357 }
4358
4359
4360 static void
4361 fabs_test (void)
4362 {
4363   START (fabs);
4364
4365   TEST_f_f (fabs, 0, 0);
4366   TEST_f_f (fabs, minus_zero, 0);
4367
4368   TEST_f_f (fabs, plus_infty, plus_infty);
4369   TEST_f_f (fabs, minus_infty, plus_infty);
4370   TEST_f_f (fabs, nan_value, nan_value);
4371
4372   TEST_f_f (fabs, 38.0, 38.0);
4373   TEST_f_f (fabs, -M_El, M_El);
4374
4375   END (fabs);
4376 }
4377
4378
4379 static void
4380 fdim_test (void)
4381 {
4382   START (fdim);
4383
4384   TEST_ff_f (fdim, 0, 0, 0);
4385   TEST_ff_f (fdim, 9, 0, 9);
4386   TEST_ff_f (fdim, 0, 9, 0);
4387   TEST_ff_f (fdim, -9, 0, 0);
4388   TEST_ff_f (fdim, 0, -9, 9);
4389
4390   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
4391   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
4392   TEST_ff_f (fdim, minus_infty, 9, 0);
4393   TEST_ff_f (fdim, minus_infty, -9, 0);
4394   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
4395   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
4396   TEST_ff_f (fdim, 9, plus_infty, 0);
4397   TEST_ff_f (fdim, -9, plus_infty, 0);
4398
4399   TEST_ff_f (fdim, 0, nan_value, nan_value);
4400   TEST_ff_f (fdim, 9, nan_value, nan_value);
4401   TEST_ff_f (fdim, -9, nan_value, nan_value);
4402   TEST_ff_f (fdim, nan_value, 9, nan_value);
4403   TEST_ff_f (fdim, nan_value, -9, nan_value);
4404   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
4405   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
4406   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
4407   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
4408   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
4409
4410   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
4411
4412   END (fdim);
4413 }
4414
4415
4416 static void
4417 floor_test (void)
4418 {
4419   START (floor);
4420
4421   TEST_f_f (floor, 0.0, 0.0);
4422   TEST_f_f (floor, minus_zero, minus_zero);
4423   TEST_f_f (floor, plus_infty, plus_infty);
4424   TEST_f_f (floor, minus_infty, minus_infty);
4425   TEST_f_f (floor, nan_value, nan_value);
4426
4427   TEST_f_f (floor, M_PIl, 3.0);
4428   TEST_f_f (floor, -M_PIl, -4.0);
4429
4430   TEST_f_f (floor, 0.1, 0.0);
4431   TEST_f_f (floor, 0.25, 0.0);
4432   TEST_f_f (floor, 0.625, 0.0);
4433   TEST_f_f (floor, -0.1, -1.0);
4434   TEST_f_f (floor, -0.25, -1.0);
4435   TEST_f_f (floor, -0.625, -1.0);
4436
4437 #ifdef TEST_LDOUBLE
4438   /* The result can only be represented in long double.  */
4439   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
4440   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
4441   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
4442   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
4443   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
4444 # if LDBL_MANT_DIG > 100
4445   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
4446   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
4447   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
4448 # endif
4449
4450   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
4451   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
4452   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
4453   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
4454   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
4455 # if LDBL_MANT_DIG > 100
4456   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
4457   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
4458   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
4459 # endif
4460
4461   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
4462   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
4463   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
4464   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
4465   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
4466
4467 # if LDBL_MANT_DIG > 100
4468   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
4469   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
4470   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
4471   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
4472   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
4473   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
4474 # endif
4475
4476   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
4477   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
4478   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
4479   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
4480   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
4481
4482 # if LDBL_MANT_DIG > 100
4483   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
4484   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
4485   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
4486   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
4487   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
4488   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
4489 # endif
4490
4491   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
4492   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
4493   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
4494   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
4495   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
4496
4497   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
4498   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
4499   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
4500   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
4501   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
4502
4503   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4504   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4505   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4506   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4507   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4508
4509   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
4510   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
4511 #endif
4512
4513   END (floor);
4514 }
4515
4516
4517 static void
4518 fma_test (void)
4519 {
4520   START (fma);
4521
4522   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
4523   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
4524   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
4525   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4526   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4527   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
4528   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4529   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
4530   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4531   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
4532   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4533   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
4534
4535   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4536   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4537   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4538   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4539   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4540   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
4541   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
4542   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
4543
4544   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
4545
4546   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4547                          LDBL_MAX, DBL_MAX, FLT_MAX);
4548   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
4549   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
4550   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
4551   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
4552   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
4553   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
4554   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
4555   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
4556
4557   TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4558   TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4559   TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4560   TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4561   TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4562   TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4563   TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4564   TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4565   TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4566   TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4567   TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4568   TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4569   TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4570   TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4571   TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4572   TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4573   TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4574   TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4575   TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4576   TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4577   TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4578   TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4579   TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4580   TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4581
4582   TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4583   TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4584   TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4585   TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4586
4587   TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4588   TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4589   TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4590   TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4591   TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4592   TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4593   TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4594   TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4595
4596 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
4597   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
4598   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
4599   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
4600   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
4601   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
4602   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
4603   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
4604 #endif
4605 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
4606   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
4607   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
4608   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
4609   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
4610   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
4611   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
4612   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
4613   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
4614   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
4615   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
4616   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
4617   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
4618   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
4619   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
4620   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
4621   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
4622   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
4623   /* Sometimes the FE_UNDERFLOW is not set, so be prepared.  See Bug 14152.  */
4624   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION_OK);
4625   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
4626   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
4627 #endif
4628 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
4629   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
4630   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
4631   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
4632   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
4633   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
4634   /* Bug 14152: underflow exception may be missing.  */
4635   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION_OK);
4636 #endif
4637 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
4638   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
4639   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
4640   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
4641   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
4642   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
4643   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
4644   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
4645   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
4646   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
4647   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
4648   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
4649   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
4650   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
4651 #endif
4652
4653   END (fma);
4654 }
4655
4656
4657 static void
4658 fma_test_towardzero (void)
4659 {
4660   int save_round_mode;
4661   START (fma_towardzero);
4662
4663   save_round_mode = fegetround ();
4664
4665   if (!fesetround (FE_TOWARDZERO))
4666     {
4667       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4668       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4669       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4670       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4671       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4672       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4673       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4674       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4675       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4676       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4677       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4678       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4679       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4680       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4681       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4682       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4683       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4684       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4685       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4686       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4687       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4688       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4689       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4690       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4691
4692       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4693       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4694       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4695       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4696
4697       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4698       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4699       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4700       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4701       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4702       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4703       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4704       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4705     }
4706
4707   fesetround (save_round_mode);
4708
4709   END (fma_towardzero);
4710 }
4711
4712
4713 static void
4714 fma_test_downward (void)
4715 {
4716   int save_round_mode;
4717   START (fma_downward);
4718
4719   save_round_mode = fegetround ();
4720
4721   if (!fesetround (FE_DOWNWARD))
4722     {
4723       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4724       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero);
4725       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero);
4726       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4727       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, minus_zero);
4728       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4729       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4730       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, minus_zero);
4731       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4732       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, minus_zero);
4733       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, minus_zero);
4734       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4735       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, minus_zero);
4736       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4737       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4738       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, minus_zero);
4739       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4740       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, minus_zero);
4741       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, minus_zero);
4742       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4743       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, minus_zero);
4744       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4745       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4746       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, minus_zero);
4747
4748       TEST_fff_f (fma, 1.0, 1.0, -1.0, minus_zero);
4749       TEST_fff_f (fma, 1.0, -1.0, 1.0, minus_zero);
4750       TEST_fff_f (fma, -1.0, 1.0, 1.0, minus_zero);
4751       TEST_fff_f (fma, -1.0, -1.0, -1.0, minus_zero);
4752
4753       TEST_fff_f (fma, min_value, min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4754       TEST_fff_f (fma, min_value, min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4755       TEST_fff_f (fma, min_value, -min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
4756       TEST_fff_f (fma, min_value, -min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
4757       TEST_fff_f (fma, -min_value, min_value, plus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
4758       TEST_fff_f (fma, -min_value, min_value, minus_zero, -min_subnorm_value, UNDERFLOW_EXCEPTION);
4759       TEST_fff_f (fma, -min_value, -min_value, plus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4760       TEST_fff_f (fma, -min_value, -min_value, minus_zero, plus_zero, UNDERFLOW_EXCEPTION);
4761     }
4762
4763   fesetround (save_round_mode);
4764
4765   END (fma_downward);
4766 }
4767
4768
4769 static void
4770 fma_test_upward (void)
4771 {
4772   int save_round_mode;
4773   START (fma_upward);
4774
4775   save_round_mode = fegetround ();
4776
4777   if (!fesetround (FE_UPWARD))
4778     {
4779       TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero);
4780       TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero);
4781       TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero);
4782       TEST_fff_f (fma, plus_zero, minus_zero, minus_zero, minus_zero);
4783       TEST_fff_f (fma, minus_zero, plus_zero, plus_zero, plus_zero);
4784       TEST_fff_f (fma, minus_zero, plus_zero, minus_zero, minus_zero);
4785       TEST_fff_f (fma, minus_zero, minus_zero, plus_zero, plus_zero);
4786       TEST_fff_f (fma, minus_zero, minus_zero, minus_zero, plus_zero);
4787       TEST_fff_f (fma, 1.0, plus_zero, plus_zero, plus_zero);
4788       TEST_fff_f (fma, 1.0, plus_zero, minus_zero, plus_zero);
4789       TEST_fff_f (fma, 1.0, minus_zero, plus_zero, plus_zero);
4790       TEST_fff_f (fma, 1.0, minus_zero, minus_zero, minus_zero);
4791       TEST_fff_f (fma, -1.0, plus_zero, plus_zero, plus_zero);
4792       TEST_fff_f (fma, -1.0, plus_zero, minus_zero, minus_zero);
4793       TEST_fff_f (fma, -1.0, minus_zero, plus_zero, plus_zero);
4794       TEST_fff_f (fma, -1.0, minus_zero, minus_zero, plus_zero);
4795       TEST_fff_f (fma, plus_zero, 1.0, plus_zero, plus_zero);
4796       TEST_fff_f (fma, plus_zero, 1.0, minus_zero, plus_zero);
4797       TEST_fff_f (fma, plus_zero, -1.0, plus_zero, plus_zero);
4798       TEST_fff_f (fma, plus_zero, -1.0, minus_zero, minus_zero);
4799       TEST_fff_f (fma, minus_zero, 1.0, plus_zero, plus_zero);
4800       TEST_fff_f (fma, minus_zero, 1.0, minus_zero, minus_zero);
4801       TEST_fff_f (fma, minus_zero, -1.0, plus_zero, plus_zero);
4802       TEST_fff_f (fma, minus_zero, -1.0, minus_zero, plus_zero);
4803
4804       TEST_fff_f (fma, 1.0, 1.0, -1.0, plus_zero);
4805       TEST_fff_f (fma, 1.0, -1.0, 1.0, plus_zero);
4806       TEST_fff_f (fma, -1.0, 1.0, 1.0, plus_zero);
4807       TEST_fff_f (fma, -1.0, -1.0, -1.0, plus_zero);
4808
4809       TEST_fff_f (fma, min_value, min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
4810       TEST_fff_f (fma, min_value, min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
4811       TEST_fff_f (fma, min_value, -min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4812       TEST_fff_f (fma, min_value, -min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4813       TEST_fff_f (fma, -min_value, min_value, plus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4814       TEST_fff_f (fma, -min_value, min_value, minus_zero, minus_zero, UNDERFLOW_EXCEPTION);
4815       TEST_fff_f (fma, -min_value, -min_value, plus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
4816       TEST_fff_f (fma, -min_value, -min_value, minus_zero, min_subnorm_value, UNDERFLOW_EXCEPTION);
4817     }
4818
4819   fesetround (save_round_mode);
4820
4821   END (fma_upward);
4822 }
4823
4824
4825 static void
4826 fmax_test (void)
4827 {
4828   START (fmax);
4829
4830   TEST_ff_f (fmax, 0, 0, 0);
4831   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
4832   TEST_ff_f (fmax, 9, 0, 9);
4833   TEST_ff_f (fmax, 0, 9, 9);
4834   TEST_ff_f (fmax, -9, 0, 0);
4835   TEST_ff_f (fmax, 0, -9, 0);
4836
4837   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
4838   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
4839   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
4840   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
4841
4842   TEST_ff_f (fmax, minus_infty, 9, 9);
4843   TEST_ff_f (fmax, minus_infty, -9, -9);
4844   TEST_ff_f (fmax, 9, minus_infty, 9);
4845   TEST_ff_f (fmax, -9, minus_infty, -9);
4846
4847   TEST_ff_f (fmax, 0, nan_value, 0);
4848   TEST_ff_f (fmax, 9, nan_value, 9);
4849   TEST_ff_f (fmax, -9, nan_value, -9);
4850   TEST_ff_f (fmax, nan_value, 0, 0);
4851   TEST_ff_f (fmax, nan_value, 9, 9);
4852   TEST_ff_f (fmax, nan_value, -9, -9);
4853   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
4854   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
4855   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
4856   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
4857   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
4858
4859   END (fmax);
4860 }
4861
4862
4863 static void
4864 fmin_test (void)
4865 {
4866   START (fmin);
4867
4868   TEST_ff_f (fmin, 0, 0, 0);
4869   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
4870   TEST_ff_f (fmin, 9, 0, 0);
4871   TEST_ff_f (fmin, 0, 9, 0);
4872   TEST_ff_f (fmin, -9, 0, -9);
4873   TEST_ff_f (fmin, 0, -9, -9);
4874
4875   TEST_ff_f (fmin, plus_infty, 9, 9);
4876   TEST_ff_f (fmin, 9, plus_infty, 9);
4877   TEST_ff_f (fmin, plus_infty, -9, -9);
4878   TEST_ff_f (fmin, -9, plus_infty, -9);
4879   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
4880   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
4881   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
4882   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
4883
4884   TEST_ff_f (fmin, 0, nan_value, 0);
4885   TEST_ff_f (fmin, 9, nan_value, 9);
4886   TEST_ff_f (fmin, -9, nan_value, -9);
4887   TEST_ff_f (fmin, nan_value, 0, 0);
4888   TEST_ff_f (fmin, nan_value, 9, 9);
4889   TEST_ff_f (fmin, nan_value, -9, -9);
4890   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
4891   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
4892   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
4893   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
4894   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
4895
4896   END (fmin);
4897 }
4898
4899
4900 static void
4901 fmod_test (void)
4902 {
4903   errno = 0;
4904   FUNC(fmod) (6.5, 2.3L);
4905   if (errno == ENOSYS)
4906     /* Function not implemented.  */
4907     return;
4908
4909   START (fmod);
4910
4911   /* fmod (+0, y) == +0 for y != 0.  */
4912   TEST_ff_f (fmod, 0, 3, 0);
4913
4914   /* fmod (-0, y) == -0 for y != 0.  */
4915   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
4916
4917   /* fmod (+inf, y) == NaN plus invalid exception.  */
4918   errno = 0;
4919   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
4920   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
4921   /* fmod (-inf, y) == NaN plus invalid exception.  */
4922   errno = 0;
4923   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
4924   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
4925   /* fmod (x, +0) == NaN plus invalid exception.  */
4926   errno = 0;
4927   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
4928   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
4929   /* fmod (x, -0) == NaN plus invalid exception.  */
4930   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
4931
4932   /* fmod (x, +inf) == x for x not infinite.  */
4933   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
4934   /* fmod (x, -inf) == x for x not infinite.  */
4935   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
4936
4937   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
4938
4939   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
4940   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
4941   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
4942   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
4943
4944   TEST_ff_f (fmod, 0x0.fffffep-126L, 0x1p-149L, plus_zero);
4945 #ifndef TEST_FLOAT
4946   TEST_ff_f (fmod, 0x0.fffffffffffffp-1022L, 0x1p-1074L, plus_zero);
4947 #endif
4948 #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381
4949   TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero);
4950 #endif
4951
4952   END (fmod);
4953 }
4954
4955
4956 static void
4957 fpclassify_test (void)
4958 {
4959   START (fpclassify);
4960
4961   TEST_f_i (fpclassify, nan_value, FP_NAN);
4962   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
4963   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
4964   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
4965   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
4966   TEST_f_i (fpclassify, 1000, FP_NORMAL);
4967
4968   END (fpclassify);
4969 }
4970
4971
4972 static void
4973 frexp_test (void)
4974 {
4975   int x;
4976
4977   START (frexp);
4978
4979   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
4980   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
4981   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
4982
4983   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
4984   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
4985
4986   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
4987   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
4988
4989   END (frexp);
4990 }
4991
4992
4993 static void
4994 gamma_test (void)
4995 {
4996   errno = 0;
4997   FUNC(gamma) (1);
4998
4999   if (errno == ENOSYS)
5000     /* Function not implemented.  */
5001     return;
5002   feclearexcept (FE_ALL_EXCEPT);
5003
5004   START (gamma);
5005
5006   TEST_f_f (gamma, plus_infty, plus_infty);
5007   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5008   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5009   TEST_f_f (gamma, minus_infty, plus_infty);
5010   TEST_f_f (gamma, nan_value, nan_value);
5011
5012   TEST_f_f1 (gamma, 1, 0, 1);
5013   TEST_f_f1 (gamma, 3, M_LN2l, 1);
5014
5015   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
5016   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5017
5018   END (gamma);
5019 }
5020
5021 static void
5022 hypot_test (void)
5023 {
5024   errno = 0;
5025   FUNC(hypot) (0.7L, 12.4L);
5026   if (errno == ENOSYS)
5027     /* Function not implemented.  */
5028     return;
5029
5030   START (hypot);
5031
5032   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5033   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
5034
5035 #ifndef TEST_INLINE
5036   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
5037   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
5038   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
5039   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
5040 #endif
5041
5042   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
5043
5044   /* hypot (x,y) == hypot (+-x, +-y)  */
5045   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
5046   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
5047   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
5048   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
5049   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
5050   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
5051   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
5052   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
5053
5054   /*  hypot (x,0) == fabs (x)  */
5055   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
5056   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
5057   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
5058
5059   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
5060
5061 #if !(defined TEST_FLOAT && defined TEST_INLINE)
5062   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
5063   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
5064 #endif
5065
5066 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
5067   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
5068 #endif
5069
5070 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
5071   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
5072 #endif
5073
5074   END (hypot);
5075 }
5076
5077
5078 static void
5079 ilogb_test (void)
5080 {
5081   START (ilogb);
5082
5083   TEST_f_i (ilogb, 1, 0);
5084   TEST_f_i (ilogb, M_El, 1);
5085   TEST_f_i (ilogb, 1024, 10);
5086   TEST_f_i (ilogb, -2000, 10);
5087
5088   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
5089   errno = 0;
5090   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
5091   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
5092   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
5093   errno = 0;
5094   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
5095   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
5096   /* ilogb (inf) == INT_MAX plus invalid exception  */
5097   errno = 0;
5098   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
5099   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
5100   /* ilogb (-inf) == INT_MAX plus invalid exception  */
5101   errno = 0;
5102   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
5103   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
5104
5105   END (ilogb);
5106 }
5107
5108 static void
5109 isfinite_test (void)
5110 {
5111   START (isfinite);
5112
5113   TEST_f_b (isfinite, 0, 1);
5114   TEST_f_b (isfinite, minus_zero, 1);
5115   TEST_f_b (isfinite, 10, 1);
5116   TEST_f_b (isfinite, plus_infty, 0);
5117   TEST_f_b (isfinite, minus_infty, 0);
5118   TEST_f_b (isfinite, nan_value, 0);
5119
5120   END (isfinite);
5121 }
5122
5123 static void
5124 isnormal_test (void)
5125 {
5126   START (isnormal);
5127
5128   TEST_f_b (isnormal, 0, 0);
5129   TEST_f_b (isnormal, minus_zero, 0);
5130   TEST_f_b (isnormal, 10, 1);
5131   TEST_f_b (isnormal, plus_infty, 0);
5132   TEST_f_b (isnormal, minus_infty, 0);
5133   TEST_f_b (isnormal, nan_value, 0);
5134
5135   END (isnormal);
5136 }
5137
5138 static void
5139 j0_test (void)
5140 {
5141   FLOAT s, c;
5142   errno = 0;
5143   FUNC (sincos) (0, &s, &c);
5144   if (errno == ENOSYS)
5145     /* Required function not implemented.  */
5146     return;
5147   FUNC(j0) (0);
5148   if (errno == ENOSYS)
5149     /* Function not implemented.  */
5150     return;
5151
5152   START (j0);
5153
5154   /* j0 is the Bessel function of the first kind of order 0 */
5155   TEST_f_f (j0, nan_value, nan_value);
5156   TEST_f_f (j0, plus_infty, 0);
5157   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
5158   TEST_f_f (j0, 0.0, 1.0);
5159   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
5160   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
5161   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
5162   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
5163   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
5164   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
5165   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
5166   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
5167   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
5168
5169   /* Bug 14155: spurious exception may occur.  */
5170   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
5171
5172 #ifndef TEST_FLOAT
5173   /* Bug 14155: spurious exception may occur.  */
5174   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
5175 #endif
5176
5177   END (j0);
5178 }
5179
5180
5181 static void
5182 j1_test (void)
5183 {
5184   FLOAT s, c;
5185   errno = 0;
5186   FUNC (sincos) (0, &s, &c);
5187   if (errno == ENOSYS)
5188     /* Required function not implemented.  */
5189     return;
5190   FUNC(j1) (0);
5191   if (errno == ENOSYS)
5192     /* Function not implemented.  */
5193     return;
5194
5195   /* j1 is the Bessel function of the first kind of order 1 */
5196
5197   START (j1);
5198
5199   TEST_f_f (j1, nan_value, nan_value);
5200   TEST_f_f (j1, plus_infty, 0);
5201
5202   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
5203   TEST_f_f (j1, 0.0, 0.0);
5204   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
5205   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
5206   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
5207   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
5208   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
5209   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
5210   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
5211
5212   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
5213
5214 #ifndef TEST_FLOAT
5215   /* Bug 14155: spurious exception may occur.  */
5216   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
5217 #endif
5218
5219   END (j1);
5220 }
5221
5222 static void
5223 jn_test (void)
5224 {
5225   FLOAT s, c;
5226   errno = 0;
5227   FUNC (sincos) (0, &s, &c);
5228   if (errno == ENOSYS)
5229     /* Required function not implemented.  */
5230     return;
5231   FUNC(jn) (1, 1);
5232   if (errno == ENOSYS)
5233     /* Function not implemented.  */
5234     return;
5235
5236   /* jn is the Bessel function of the first kind of order n.  */
5237   START (jn);
5238
5239   /* jn (0, x) == j0 (x)  */
5240   TEST_ff_f (jn, 0, nan_value, nan_value);
5241   TEST_ff_f (jn, 0, plus_infty, 0);
5242   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
5243   TEST_ff_f (jn, 0, 0.0, 1.0);
5244   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
5245   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
5246   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
5247   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
5248   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
5249   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
5250   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
5251   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
5252   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
5253
5254   /* jn (1, x) == j1 (x)  */
5255   TEST_ff_f (jn, 1, nan_value, nan_value);
5256   TEST_ff_f (jn, 1, plus_infty, 0);
5257   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
5258   TEST_ff_f (jn, 1, 0.0, 0.0);
5259   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
5260   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
5261   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
5262   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
5263   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
5264   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
5265   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
5266
5267   /* jn (3, x)  */
5268   TEST_ff_f (jn, 3, nan_value, nan_value);
5269   TEST_ff_f (jn, 3, plus_infty, 0);
5270
5271   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
5272   TEST_ff_f (jn, 3, 0.0, 0.0);
5273   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
5274   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
5275   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
5276   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
5277   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
5278
5279   /*  jn (10, x)  */
5280   TEST_ff_f (jn, 10, nan_value, nan_value);
5281   TEST_ff_f (jn, 10, plus_infty, 0);
5282
5283   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
5284   TEST_ff_f (jn, 10, 0.0, 0.0);
5285   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
5286   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
5287   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
5288   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
5289   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
5290
5291   /* BZ #11589 .*/
5292   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
5293   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
5294   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
5295   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
5296   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
5297   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
5298   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
5299   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
5300
5301   /* Bug 14155: spurious exception may occur.  */
5302   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
5303
5304   END (jn);
5305 }
5306
5307
5308 static void
5309 ldexp_test (void)
5310 {
5311   TEST_ff_f (ldexp, 0, 0, 0);
5312   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
5313
5314   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
5315   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
5316   TEST_ff_f (ldexp, nan_value, 1, nan_value);
5317
5318   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
5319   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
5320
5321   /* ldexp (x, 0) == x.  */
5322   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
5323 }
5324
5325
5326 static void
5327 lgamma_test (void)
5328 {
5329   errno = 0;
5330   FUNC(lgamma) (0);
5331   if (errno == ENOSYS)
5332     /* Function not implemented.  */
5333     return;
5334   feclearexcept (FE_ALL_EXCEPT);
5335
5336   START (lgamma);
5337
5338   TEST_f_f (lgamma, plus_infty, plus_infty);
5339   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5340   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
5341   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5342   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
5343   TEST_f_f (lgamma, nan_value, nan_value);
5344
5345   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
5346   errno = 0;
5347   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5348   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
5349   TEST_f_f (lgamma, minus_infty, plus_infty);
5350   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5351   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
5352
5353   TEST_f_f1 (lgamma, 1, 0, 1);
5354
5355   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
5356
5357   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
5358   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
5359   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
5360   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
5361
5362   END (lgamma);
5363 }
5364
5365
5366 static void
5367 lrint_test (void)
5368 {
5369   /* XXX this test is incomplete.  We need to have a way to specifiy
5370      the rounding method and test the critical cases.  So far, only
5371      unproblematic numbers are tested.  */
5372
5373   START (lrint);
5374
5375   TEST_f_l (lrint, 0.0, 0);
5376   TEST_f_l (lrint, minus_zero, 0);
5377   TEST_f_l (lrint, 0.2L, 0);
5378   TEST_f_l (lrint, -0.2L, 0);
5379
5380   TEST_f_l (lrint, 1.4L, 1);
5381   TEST_f_l (lrint, -1.4L, -1);
5382
5383   TEST_f_l (lrint, 8388600.3L, 8388600);
5384   TEST_f_l (lrint, -8388600.3L, -8388600);
5385
5386   TEST_f_l (lrint, 1071930.0008, 1071930);
5387 #ifndef TEST_FLOAT
5388   TEST_f_l (lrint, 1073741824.01, 1073741824);
5389 # if LONG_MAX > 281474976710656
5390   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
5391 # endif
5392 #endif
5393
5394   END (lrint);
5395 }
5396
5397
5398 static void
5399 lrint_test_tonearest (void)
5400 {
5401   int save_round_mode;
5402   START (lrint_tonearest);
5403
5404   save_round_mode = fegetround ();
5405
5406   if (!fesetround (FE_TONEAREST))
5407     {
5408       TEST_f_l (lrint, 0.0, 0);
5409       TEST_f_l (lrint, minus_zero, 0);
5410       TEST_f_l (lrint, 0.2L, 0);
5411       TEST_f_l (lrint, -0.2L, 0);
5412       TEST_f_l (lrint, 0.5L, 0);
5413       TEST_f_l (lrint, -0.5L, 0);
5414       TEST_f_l (lrint, 0.8L, 1);
5415       TEST_f_l (lrint, -0.8L, -1);
5416
5417       TEST_f_l (lrint, 1.4L, 1);
5418       TEST_f_l (lrint, -1.4L, -1);
5419
5420       TEST_f_l (lrint, 8388600.3L, 8388600);
5421       TEST_f_l (lrint, -8388600.3L, -8388600);
5422
5423       TEST_f_l (lrint, 1071930.0008, 1071930);
5424 #ifndef TEST_FLOAT
5425       TEST_f_l (lrint, 1073741824.01, 1073741824);
5426 # if LONG_MAX > 281474976710656
5427       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
5428 # endif
5429 #endif
5430     }
5431
5432   fesetround (save_round_mode);
5433
5434   END (lrint_tonearest);
5435 }
5436
5437
5438 static void
5439 lrint_test_towardzero (void)
5440 {
5441   int save_round_mode;
5442   START (lrint_towardzero);
5443
5444   save_round_mode = fegetround ();
5445
5446   if (!fesetround (FE_TOWARDZERO))
5447     {
5448       TEST_f_l (lrint, 0.0, 0);
5449       TEST_f_l (lrint, minus_zero, 0);
5450       TEST_f_l (lrint, 0.2L, 0);
5451       TEST_f_l (lrint, -0.2L, 0);
5452       TEST_f_l (lrint, 0.5L, 0);
5453       TEST_f_l (lrint, -0.5L, 0);
5454       TEST_f_l (lrint, 0.8L, 0);
5455       TEST_f_l (lrint, -0.8L, 0);
5456
5457       TEST_f_l (lrint, 1.4L, 1);
5458       TEST_f_l (lrint, -1.4L, -1);
5459
5460       TEST_f_l (lrint, 8388600.3L, 8388600);
5461       TEST_f_l (lrint, -8388600.3L, -8388600);
5462
5463       TEST_f_l (lrint, 1071930.0008, 1071930);
5464 #ifndef TEST_FLOAT
5465       TEST_f_l (lrint, 1073741824.01, 1073741824);
5466 # if LONG_MAX > 281474976710656
5467       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
5468 # endif
5469 #endif
5470     }
5471
5472   fesetround (save_round_mode);
5473
5474   END (lrint_towardzero);
5475 }
5476
5477
5478 static void
5479 lrint_test_downward (void)
5480 {
5481   int save_round_mode;
5482   START (lrint_downward);
5483
5484   save_round_mode = fegetround ();
5485
5486   if (!fesetround (FE_DOWNWARD))
5487     {
5488       TEST_f_l (lrint, 0.0, 0);
5489       TEST_f_l (lrint, minus_zero, 0);
5490       TEST_f_l (lrint, 0.2L, 0);
5491       TEST_f_l (lrint, -0.2L, -1);
5492       TEST_f_l (lrint, 0.5L, 0);
5493       TEST_f_l (lrint, -0.5L, -1);
5494       TEST_f_l (lrint, 0.8L, 0);
5495       TEST_f_l (lrint, -0.8L, -1);
5496
5497       TEST_f_l (lrint, 1.4L, 1);
5498       TEST_f_l (lrint, -1.4L, -2);
5499
5500       TEST_f_l (lrint, 8388600.3L, 8388600);
5501       TEST_f_l (lrint, -8388600.3L, -8388601);
5502
5503       TEST_f_l (lrint, 1071930.0008, 1071930);
5504 #ifndef TEST_FLOAT
5505       TEST_f_l (lrint, 1073741824.01, 1073741824);
5506 # if LONG_MAX > 281474976710656
5507       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
5508 # endif
5509 #endif
5510     }
5511
5512   fesetround (save_round_mode);
5513
5514   END (lrint_downward);
5515 }
5516
5517
5518 static void
5519 lrint_test_upward (void)
5520 {
5521   int save_round_mode;
5522   START (lrint_upward);
5523
5524   save_round_mode = fegetround ();
5525
5526   if (!fesetround (FE_UPWARD))
5527     {
5528       TEST_f_l (lrint, 0.0, 0);
5529       TEST_f_l (lrint, minus_zero, 0);
5530       TEST_f_l (lrint, 0.2L, 1);
5531       TEST_f_l (lrint, -0.2L, 0);
5532       TEST_f_l (lrint, 0.5L, 1);
5533       TEST_f_l (lrint, -0.5L, 0);
5534       TEST_f_l (lrint, 0.8L, 1);
5535       TEST_f_l (lrint, -0.8L, 0);
5536
5537       TEST_f_l (lrint, 1.4L, 2);
5538       TEST_f_l (lrint, -1.4L, -1);
5539
5540       TEST_f_l (lrint, 8388600.3L, 8388601);
5541       TEST_f_l (lrint, -8388600.3L, -8388600);
5542
5543 #ifndef TEST_FLOAT
5544       TEST_f_l (lrint, 1071930.0008, 1071931);
5545       TEST_f_l (lrint, 1073741824.01, 1073741825);
5546 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
5547       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
5548 # endif
5549 #endif
5550     }
5551
5552   fesetround (save_round_mode);
5553
5554   END (lrint_upward);
5555 }
5556
5557
5558 static void
5559 llrint_test (void)
5560 {
5561   /* XXX this test is incomplete.  We need to have a way to specifiy
5562      the rounding method and test the critical cases.  So far, only
5563      unproblematic numbers are tested.  */
5564
5565   START (llrint);
5566
5567   TEST_f_L (llrint, 0.0, 0);
5568   TEST_f_L (llrint, minus_zero, 0);
5569   TEST_f_L (llrint, 0.2L, 0);
5570   TEST_f_L (llrint, -0.2L, 0);
5571
5572   TEST_f_L (llrint, 1.4L, 1);
5573   TEST_f_L (llrint, -1.4L, -1);
5574
5575   TEST_f_L (llrint, 8388600.3L, 8388600);
5576   TEST_f_L (llrint, -8388600.3L, -8388600);
5577
5578   TEST_f_l (llrint, 1071930.0008, 1071930);
5579
5580   /* Test boundary conditions.  */
5581   /* 0x1FFFFF */
5582   TEST_f_L (llrint, 2097151.0,2097151LL);
5583   /* 0x800000 */
5584   TEST_f_L (llrint, 8388608.0, 8388608LL);
5585   /* 0x1000000 */
5586   TEST_f_L (llrint, 16777216.0, 16777216LL);
5587   /* 0x20000000000 */
5588   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5589   /* 0x40000000000 */
5590   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5591   /* 0x1000000000000 */
5592   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5593   /* 0x10000000000000 */
5594   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5595   /* 0x10000080000000 */
5596   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5597   /* 0x20000000000000 */
5598   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5599   /* 0x80000000000000 */
5600   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5601   /* 0x100000000000000 */
5602   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5603 #ifdef TEST_LDOUBLE
5604   /* The input can only be represented in long double.  */
5605   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
5606   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
5607   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
5608   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
5609   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
5610
5611   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
5612   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
5613   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
5614   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
5615   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
5616
5617 # if LDBL_MANT_DIG > 100
5618   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
5619   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
5620   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
5621   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
5622   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
5623   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
5624
5625   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
5626   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
5627   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
5628   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
5629   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
5630   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
5631 #endif
5632
5633   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
5634   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
5635   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
5636   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
5637   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
5638
5639   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
5640   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
5641   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
5642   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
5643   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
5644
5645 # if LDBL_MANT_DIG > 100
5646   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
5647   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
5648   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
5649   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
5650   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
5651   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
5652
5653   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
5654   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
5655   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
5656   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
5657   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
5658   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
5659 #endif
5660
5661   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
5662   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
5663   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
5664   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
5665   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
5666
5667   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
5668   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
5669   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
5670   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
5671   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
5672
5673 # if LDBL_MANT_DIG > 100
5674   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
5675   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
5676   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5677   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5678   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
5679   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
5680   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
5681   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
5682   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
5683   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
5684   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5685   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5686 # endif
5687 #endif
5688
5689   END (llrint);
5690 }
5691
5692 static void
5693 llrint_test_tonearest (void)
5694 {
5695   int save_round_mode;
5696   START (llrint_tonearest);
5697
5698   save_round_mode = fegetround ();
5699
5700   if (!fesetround (FE_TONEAREST))
5701     {
5702       TEST_f_L (llrint, 0.0, 0);
5703       TEST_f_L (llrint, minus_zero, 0);
5704       TEST_f_L (llrint, 0.2L, 0);
5705       TEST_f_L (llrint, -0.2L, 0);
5706
5707       TEST_f_L (llrint, 1.4L, 1);
5708       TEST_f_L (llrint, -1.4L, -1);
5709
5710       TEST_f_L (llrint, 8388600.3L, 8388600);
5711       TEST_f_L (llrint, -8388600.3L, -8388600);
5712
5713       TEST_f_l (llrint, 1071930.0008, 1071930);
5714
5715       /* Test boundary conditions.  */
5716       /* 0x1FFFFF */
5717       TEST_f_L (llrint, 2097151.0,2097151LL);
5718       /* 0x800000 */
5719       TEST_f_L (llrint, 8388608.0, 8388608LL);
5720       /* 0x1000000 */
5721       TEST_f_L (llrint, 16777216.0, 16777216LL);
5722       /* 0x20000000000 */
5723       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5724       /* 0x40000000000 */
5725       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5726       /* 0x1000000000000 */
5727       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5728       /* 0x10000000000000 */
5729       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5730       /* 0x10000080000000 */
5731       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5732       /* 0x20000000000000 */
5733       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5734       /* 0x80000000000000 */
5735       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5736       /* 0x100000000000000 */
5737       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5738 #ifdef TEST_LDOUBLE
5739       /* The input can only be represented in long double.  */
5740       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
5741       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
5742       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
5743       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
5744       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
5745
5746       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
5747       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
5748       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
5749       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
5750       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
5751
5752 # if LDBL_MANT_DIG > 100
5753       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
5754       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
5755       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
5756       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
5757       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
5758       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
5759
5760       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
5761       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
5762       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
5763       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
5764       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
5765       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
5766 #endif
5767
5768       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
5769       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
5770       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
5771       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
5772       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
5773
5774       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
5775       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
5776       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
5777       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
5778       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
5779
5780 # if LDBL_MANT_DIG > 100
5781       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
5782       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
5783       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
5784       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
5785       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
5786       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
5787
5788       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
5789       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
5790       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
5791       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
5792       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
5793       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
5794 #endif
5795
5796       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
5797       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
5798       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
5799       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
5800       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
5801
5802       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
5803       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
5804       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
5805       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
5806       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
5807
5808 # if LDBL_MANT_DIG > 100
5809       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
5810       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
5811       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5812       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5813       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
5814       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
5815       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
5816       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
5817       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
5818       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
5819       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5820       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5821 # endif
5822 #endif
5823     }
5824
5825   fesetround (save_round_mode);
5826
5827   END (llrint_tonearest);
5828 }
5829
5830 static void
5831 llrint_test_towardzero (void)
5832 {
5833   int save_round_mode;
5834   START (llrint_towardzero);
5835
5836   save_round_mode = fegetround ();
5837
5838   if (!fesetround (FE_TOWARDZERO))
5839     {
5840       TEST_f_L (llrint, 0.0, 0);
5841       TEST_f_L (llrint, minus_zero, 0);
5842       TEST_f_L (llrint, 0.2L, 0);
5843       TEST_f_L (llrint, -0.2L, 0);
5844
5845       TEST_f_L (llrint, 1.4L, 1);
5846       TEST_f_L (llrint, -1.4L, -1);
5847
5848       TEST_f_L (llrint, 8388600.3L, 8388600);
5849       TEST_f_L (llrint, -8388600.3L, -8388600);
5850
5851       TEST_f_l (llrint, 1071930.0008, 1071930);
5852
5853       /* Test boundary conditions.  */
5854       /* 0x1FFFFF */
5855       TEST_f_L (llrint, 2097151.0,2097151LL);
5856       /* 0x800000 */
5857       TEST_f_L (llrint, 8388608.0, 8388608LL);
5858       /* 0x1000000 */
5859       TEST_f_L (llrint, 16777216.0, 16777216LL);
5860       /* 0x20000000000 */
5861       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5862       /* 0x40000000000 */
5863       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5864       /* 0x1000000000000 */
5865       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5866       /* 0x10000000000000 */
5867       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5868       /* 0x10000080000000 */
5869       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5870       /* 0x20000000000000 */
5871       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5872       /* 0x80000000000000 */
5873       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5874       /* 0x100000000000000 */
5875       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5876 #ifdef TEST_LDOUBLE
5877       /* The input can only be represented in long double.  */
5878       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
5879       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
5880       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
5881       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
5882       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
5883
5884       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
5885       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
5886       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
5887       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
5888       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
5889
5890 # if LDBL_MANT_DIG > 100
5891       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
5892       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
5893       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
5894       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
5895       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
5896       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
5897
5898       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
5899       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
5900       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
5901       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
5902       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
5903       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
5904 #endif
5905
5906       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
5907       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
5908       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
5909       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
5910       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
5911
5912       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
5913       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
5914       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
5915       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
5916       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
5917
5918 # if LDBL_MANT_DIG > 100
5919       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
5920       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
5921       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
5922       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
5923       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
5924       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
5925
5926       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
5927       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
5928       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
5929       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
5930       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
5931       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
5932 #endif
5933
5934       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
5935       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
5936       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
5937       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
5938       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
5939
5940       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
5941       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
5942       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
5943       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
5944       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
5945
5946 # if LDBL_MANT_DIG > 100
5947       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
5948       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
5949       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5950       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5951       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
5952       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
5953       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
5954       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
5955       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
5956       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
5957       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5958       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5959 # endif
5960 #endif
5961     }
5962
5963   fesetround (save_round_mode);
5964
5965   END (llrint_towardzero);
5966 }
5967
5968 static void
5969 llrint_test_downward (void)
5970 {
5971   int save_round_mode;
5972   START (llrint_downward);
5973
5974   save_round_mode = fegetround ();
5975
5976   if (!fesetround (FE_DOWNWARD))
5977     {
5978       TEST_f_L (llrint, 0.0, 0);
5979       TEST_f_L (llrint, minus_zero, 0);
5980       TEST_f_L (llrint, 0.2L, 0);
5981       TEST_f_L (llrint, -0.2L, -1);
5982
5983       TEST_f_L (llrint, 1.4L, 1);
5984       TEST_f_L (llrint, -1.4L, -2);
5985
5986       TEST_f_L (llrint, 8388600.3L, 8388600);
5987       TEST_f_L (llrint, -8388600.3L, -8388601);
5988
5989       TEST_f_l (llrint, 1071930.0008, 1071930);
5990
5991       /* Test boundary conditions.  */
5992       /* 0x1FFFFF */
5993       TEST_f_L (llrint, 2097151.0,2097151LL);
5994       /* 0x800000 */
5995       TEST_f_L (llrint, 8388608.0, 8388608LL);
5996       /* 0x1000000 */
5997       TEST_f_L (llrint, 16777216.0, 16777216LL);
5998       /* 0x20000000000 */
5999       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6000       /* 0x40000000000 */
6001       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6002       /* 0x1000000000000 */
6003       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6004       /* 0x10000000000000 */
6005       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6006       /* 0x10000080000000 */
6007       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6008       /* 0x20000000000000 */
6009       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6010       /* 0x80000000000000 */
6011       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6012       /* 0x100000000000000 */
6013       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6014 #ifdef TEST_LDOUBLE
6015       /* The input can only be represented in long double.  */
6016       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
6017       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
6018       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
6019       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
6020       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
6021
6022       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
6023       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
6024       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
6025       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
6026       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
6027       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
6028
6029       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
6030       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
6031       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
6032       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
6033       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
6034
6035       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
6036       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
6037       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
6038       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
6039       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
6040       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
6041
6042       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
6043       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
6044       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
6045       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
6046       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
6047
6048       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
6049       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
6050       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
6051       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
6052       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
6053       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
6054
6055       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
6056       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
6057       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
6058       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
6059       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
6060
6061       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
6062       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
6063       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
6064       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
6065       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
6066       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
6067
6068       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
6069       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
6070       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
6071       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
6072       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
6073
6074       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
6075       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
6076       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
6077       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
6078       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
6079
6080 # if LDBL_MANT_DIG > 100
6081       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
6082       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
6083       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6084       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6085       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
6086       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
6087       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
6088       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
6089       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
6090       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
6091       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6092       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6093 # endif
6094 #endif
6095     }
6096
6097   fesetround (save_round_mode);
6098
6099   END (llrint_downward);
6100 }
6101
6102 static void
6103 llrint_test_upward (void)
6104 {
6105   int save_round_mode;
6106   START (llrint_upward);
6107
6108   save_round_mode = fegetround ();
6109
6110   if (!fesetround (FE_UPWARD))
6111     {
6112       TEST_f_L (llrint, 0.0, 0);
6113       TEST_f_L (llrint, minus_zero, 0);
6114       TEST_f_L (llrint, 0.2L, 1);
6115       TEST_f_L (llrint, -0.2L, 0);
6116
6117       TEST_f_L (llrint, 1.4L, 2);
6118       TEST_f_L (llrint, -1.4L, -1);
6119
6120       TEST_f_L (llrint, 8388600.3L, 8388601);
6121       TEST_f_L (llrint, -8388600.3L, -8388600);
6122 #ifndef TEST_FLOAT
6123       TEST_f_l (llrint, 1071930.0008, 1071931);
6124 #endif
6125       /* Test boundary conditions.  */
6126       /* 0x1FFFFF */
6127       TEST_f_L (llrint, 2097151.0,2097151LL);
6128       /* 0x800000 */
6129       TEST_f_L (llrint, 8388608.0, 8388608LL);
6130       /* 0x1000000 */
6131       TEST_f_L (llrint, 16777216.0, 16777216LL);
6132       /* 0x20000000000 */
6133       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
6134       /* 0x40000000000 */
6135       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
6136       /* 0x1000000000000 */
6137       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
6138       /* 0x10000000000000 */
6139       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
6140       /* 0x10000080000000 */
6141       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
6142       /* 0x20000000000000 */
6143       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
6144       /* 0x80000000000000 */
6145       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
6146       /* 0x100000000000000 */
6147       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
6148 #ifdef TEST_LDOUBLE
6149       /* The input can only be represented in long double.  */
6150       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
6151       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
6152       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
6153       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
6154       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
6155
6156       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
6157       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
6158       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
6159       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
6160       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
6161       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
6162
6163       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
6164       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
6165       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
6166       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
6167       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
6168
6169       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
6170       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
6171       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
6172       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
6173       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
6174       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
6175
6176       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
6177       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
6178       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
6179       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
6180       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
6181
6182       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
6183       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
6184       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
6185       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
6186       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
6187       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
6188
6189       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
6190       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
6191       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
6192       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
6193       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
6194
6195       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
6196       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
6197       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
6198       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
6199       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
6200       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
6201
6202       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
6203       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
6204       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
6205       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
6206       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
6207
6208       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
6209       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
6210       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
6211       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
6212       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
6213
6214 # if LDBL_MANT_DIG > 100
6215       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
6216       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
6217       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
6218       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
6219       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
6220       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
6221       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
6222       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
6223       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
6224       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
6225       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
6226       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
6227 # endif
6228 #endif
6229     }
6230
6231   fesetround (save_round_mode);
6232
6233   END (llrint_upward);
6234 }
6235
6236
6237 static void
6238 log_test (void)
6239 {
6240   errno = 0;
6241   FUNC(log) (1);
6242   if (errno == ENOSYS)
6243     /* Function not implemented.  */
6244     return;
6245   START (log);
6246
6247   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6248   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6249
6250   TEST_f_f (log, 1, 0);
6251
6252   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
6253   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
6254   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
6255   TEST_f_f (log, plus_infty, plus_infty);
6256   TEST_f_f (log, nan_value, nan_value);
6257
6258   TEST_f_f (log, M_El, 1);
6259   TEST_f_f (log, 1.0 / M_El, -1);
6260   TEST_f_f (log, 2, M_LN2l);
6261   TEST_f_f (log, 10, M_LN10l);
6262   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
6263
6264   END (log);
6265 }
6266
6267
6268 static void
6269 log10_test (void)
6270 {
6271   errno = 0;
6272   FUNC(log10) (1);
6273   if (errno == ENOSYS)
6274     /* Function not implemented.  */
6275     return;
6276
6277   START (log10);
6278
6279   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6280   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6281
6282   TEST_f_f (log10, 1, 0);
6283
6284   /* log10 (x) == NaN plus invalid exception if x < 0.  */
6285   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
6286   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
6287   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
6288
6289   TEST_f_f (log10, plus_infty, plus_infty);
6290   TEST_f_f (log10, nan_value, nan_value);
6291
6292   TEST_f_f (log10, 0.1L, -1);
6293   TEST_f_f (log10, 10.0, 1);
6294   TEST_f_f (log10, 100.0, 2);
6295   TEST_f_f (log10, 10000.0, 4);
6296   TEST_f_f (log10, M_El, M_LOG10El);
6297   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
6298
6299   END (log10);
6300 }
6301
6302
6303 static void
6304 log1p_test (void)
6305 {
6306   errno = 0;
6307   FUNC(log1p) (0);
6308   if (errno == ENOSYS)
6309     /* Function not implemented.  */
6310     return;
6311
6312   START (log1p);
6313
6314   TEST_f_f (log1p, 0, 0);
6315   TEST_f_f (log1p, minus_zero, minus_zero);
6316
6317   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6318   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
6319   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
6320   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
6321
6322   TEST_f_f (log1p, plus_infty, plus_infty);
6323   TEST_f_f (log1p, nan_value, nan_value);
6324
6325   TEST_f_f (log1p, M_El - 1.0, 1);
6326
6327   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
6328   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
6329
6330   END (log1p);
6331 }
6332
6333
6334 static void
6335 log2_test (void)
6336 {
6337   errno = 0;
6338   FUNC(log2) (1);
6339   if (errno == ENOSYS)
6340     /* Function not implemented.  */
6341     return;
6342
6343   START (log2);
6344
6345   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6346   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6347
6348   TEST_f_f (log2, 1, 0);
6349
6350   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
6351   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
6352   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
6353
6354   TEST_f_f (log2, plus_infty, plus_infty);
6355   TEST_f_f (log2, nan_value, nan_value);
6356
6357   TEST_f_f (log2, M_El, M_LOG2El);
6358   TEST_f_f (log2, 2.0, 1);
6359   TEST_f_f (log2, 16.0, 4);
6360   TEST_f_f (log2, 256.0, 8);
6361   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
6362
6363   END (log2);
6364 }
6365
6366
6367 static void
6368 logb_test (void)
6369 {
6370   START (logb);
6371
6372   TEST_f_f (logb, plus_infty, plus_infty);
6373   TEST_f_f (logb, minus_infty, plus_infty);
6374
6375   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6376
6377   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6378   TEST_f_f (logb, nan_value, nan_value);
6379
6380   TEST_f_f (logb, 1, 0);
6381   TEST_f_f (logb, M_El, 1);
6382   TEST_f_f (logb, 1024, 10);
6383   TEST_f_f (logb, -2000, 10);
6384
6385   TEST_f_f (logb, 0x0.1p-127, -131);
6386   TEST_f_f (logb, 0x0.01p-127, -135);
6387   TEST_f_f (logb, 0x0.011p-127, -135);
6388 #ifndef TEST_FLOAT
6389   TEST_f_f (logb, 0x0.8p-1022, -1023);
6390   TEST_f_f (logb, 0x0.1p-1022, -1026);
6391   TEST_f_f (logb, 0x0.00111p-1022, -1034);
6392   TEST_f_f (logb, 0x0.00001p-1022, -1042);
6393   TEST_f_f (logb, 0x0.000011p-1022, -1042);
6394   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
6395 #endif
6396 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
6397   TEST_f_f (logb, 0x1p-16400L, -16400);
6398   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
6399 #endif
6400
6401   END (logb);
6402 }
6403
6404 static void
6405 logb_test_downward (void)
6406 {
6407   int save_round_mode;
6408   errno = 0;
6409
6410   FUNC(logb) (0);
6411   if (errno == ENOSYS)
6412     /* Function not implemented.  */
6413     return;
6414
6415   START (logb_downward);
6416
6417   save_round_mode = fegetround ();
6418
6419   if (!fesetround (FE_DOWNWARD))
6420     {
6421
6422       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
6423          should not return -0 from logb in any rounding mode.  PowerPC32 has
6424          failed with this test for power4 logb (and logbl on all PowerPC
6425          platforms) in the past due to instruction selection.  GCC PR 52775
6426          provides the availability of the fcfid insn in 32-bit mode which
6427          eliminates the use of fsub in this instance and prevents the negative
6428          signed 0.0.  */
6429
6430       /* BZ #887  */
6431       TEST_f_f (logb, 1.000e+0, plus_zero);
6432     }
6433
6434   fesetround (save_round_mode);
6435
6436   END (logb_downward);
6437 }
6438
6439 static void
6440 lround_test (void)
6441 {
6442   START (lround);
6443
6444   TEST_f_l (lround, 0, 0);
6445   TEST_f_l (lround, minus_zero, 0);
6446   TEST_f_l (lround, 0.2L, 0.0);
6447   TEST_f_l (lround, -0.2L, 0);
6448   TEST_f_l (lround, 0.5, 1);
6449   TEST_f_l (lround, -0.5, -1);
6450   TEST_f_l (lround, 0.8L, 1);
6451   TEST_f_l (lround, -0.8L, -1);
6452   TEST_f_l (lround, 1.5, 2);
6453   TEST_f_l (lround, -1.5, -2);
6454   TEST_f_l (lround, 22514.5, 22515);
6455   TEST_f_l (lround, -22514.5, -22515);
6456   TEST_f_l (lround, 1071930.0008, 1071930);
6457 #ifndef TEST_FLOAT
6458   TEST_f_l (lround, 1073741824.01, 1073741824);
6459 # if LONG_MAX > 281474976710656
6460   TEST_f_l (lround, 281474976710656.025, 281474976710656);
6461   TEST_f_l (lround, 18014398509481974, 18014398509481974);
6462 # endif
6463   TEST_f_l (lround, 2097152.5, 2097153);
6464   TEST_f_l (lround, -2097152.5, -2097153);
6465   /* nextafter(0.5,-1)  */
6466   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
6467   /* nextafter(-0.5,1)  */
6468   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
6469 #else
6470   /* nextafter(0.5,-1)  */
6471   TEST_f_l (lround, 0x1.fffffp-2, 0);
6472   /* nextafter(-0.5,1)  */
6473   TEST_f_l (lround, -0x1.fffffp-2, 0);
6474   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
6475   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
6476 #endif
6477   END (lround);
6478 }
6479
6480
6481 static void
6482 llround_test (void)
6483 {
6484   START (llround);
6485
6486   TEST_f_L (llround, 0, 0);
6487   TEST_f_L (llround, minus_zero, 0);
6488   TEST_f_L (llround, 0.2L, 0.0);
6489   TEST_f_L (llround, -0.2L, 0);
6490   TEST_f_L (llround, 0.5, 1);
6491   TEST_f_L (llround, -0.5, -1);
6492   TEST_f_L (llround, 0.8L, 1);
6493   TEST_f_L (llround, -0.8L, -1);
6494   TEST_f_L (llround, 1.5, 2);
6495   TEST_f_L (llround, -1.5, -2);
6496   TEST_f_L (llround, 22514.5, 22515);
6497   TEST_f_L (llround, -22514.5, -22515);
6498   TEST_f_l (llround, 1071930.0008, 1071930);
6499 #ifndef TEST_FLOAT
6500   TEST_f_L (llround, 2097152.5, 2097153);
6501   TEST_f_L (llround, -2097152.5, -2097153);
6502   TEST_f_L (llround, 34359738368.5, 34359738369ll);
6503   TEST_f_L (llround, -34359738368.5, -34359738369ll);
6504   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
6505 #endif
6506
6507   /* Test boundary conditions.  */
6508   /* 0x1FFFFF */
6509   TEST_f_L (llround, 2097151.0, 2097151LL);
6510   /* 0x800000 */
6511   TEST_f_L (llround, 8388608.0, 8388608LL);
6512   /* 0x1000000 */
6513   TEST_f_L (llround, 16777216.0, 16777216LL);
6514   /* 0x20000000000 */
6515   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
6516   /* 0x40000000000 */
6517   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
6518   /* 0x1000000000000 */
6519   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
6520   /* 0x10000000000000 */
6521   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
6522   /* 0x10000080000000 */
6523   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
6524   /* 0x20000000000000 */
6525   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
6526   /* 0x80000000000000 */
6527   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
6528   /* 0x100000000000000 */
6529   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
6530
6531 #ifndef TEST_FLOAT
6532   /* 0x100000000 */
6533   TEST_f_L (llround, 4294967295.5, 4294967296LL);
6534   /* 0x200000000 */
6535   TEST_f_L (llround, 8589934591.5, 8589934592LL);
6536
6537   /* nextafter(0.5,-1)  */
6538   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
6539   /* nextafter(-0.5,1)  */
6540   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
6541   /* On PowerPC an exponent of '52' is the largest incrementally
6542    * representable sequence of whole-numbers in the 'double' range.  We test
6543    * lround to make sure that a guard bit set during the lround operation
6544    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
6545    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
6546    * rightmost bit set.  */
6547   /* +-(2^52+1)  */
6548   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
6549   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
6550   /* +-(2^53-1): Input is the last (positive and negative) incrementally
6551    * representable whole-number in the 'double' range that might round
6552    * erroneously.  */
6553   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
6554   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
6555 #else
6556   /* nextafter(0.5,-1)  */
6557   TEST_f_L (llround, 0x1.fffffep-2, 0);
6558   /* nextafter(-0.5,1)  */
6559   TEST_f_L (llround, -0x1.fffffep-2, 0);
6560   /* As above, on PowerPC an exponent of '23' is the largest incrementally
6561    * representable sequence of whole-numbers in the 'float' range.
6562    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
6563   TEST_f_L (llround, 0x1.000002p+23,8388609);
6564   TEST_f_L (llround, -0x1.000002p+23,-8388609);
6565   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
6566   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
6567 #endif
6568
6569
6570 #ifdef TEST_LDOUBLE
6571   /* The input can only be represented in long double.  */
6572   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
6573   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
6574   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
6575   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
6576   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
6577
6578 # if LDBL_MANT_DIG > 100
6579   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
6580   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
6581   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
6582   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
6583   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
6584   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
6585
6586   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
6587   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
6588   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
6589   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
6590   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
6591   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
6592 # endif
6593
6594   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
6595   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
6596   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
6597   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
6598   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
6599
6600   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
6601   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
6602   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
6603   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
6604   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
6605
6606 # if LDBL_MANT_DIG > 100
6607   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
6608   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
6609   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
6610   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
6611   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
6612   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
6613
6614   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
6615   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
6616   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
6617   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
6618   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
6619   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
6620 # endif
6621
6622   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
6623   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
6624   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
6625   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
6626   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
6627
6628   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
6629   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
6630   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
6631   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
6632   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
6633
6634   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
6635   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
6636   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
6637   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
6638   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
6639
6640   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
6641   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
6642   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
6643   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
6644   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
6645   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
6646 #endif
6647
6648   END (llround);
6649 }
6650
6651 static void
6652 modf_test (void)
6653 {
6654   FLOAT x;
6655
6656   START (modf);
6657
6658   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
6659   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
6660   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
6661   TEST_fF_f1 (modf, 0, 0, 0);
6662   TEST_fF_f1 (modf, 1.5, 0.5, 1);
6663   TEST_fF_f1 (modf, 2.5, 0.5, 2);
6664   TEST_fF_f1 (modf, -2.5, -0.5, -2);
6665   TEST_fF_f1 (modf, 20, 0, 20);
6666   TEST_fF_f1 (modf, 21, 0, 21);
6667   TEST_fF_f1 (modf, 89.5, 0.5, 89);
6668
6669   END (modf);
6670 }
6671
6672
6673 static void
6674 nearbyint_test (void)
6675 {
6676   START (nearbyint);
6677
6678   TEST_f_f (nearbyint, 0.0, 0.0);
6679   TEST_f_f (nearbyint, minus_zero, minus_zero);
6680   TEST_f_f (nearbyint, plus_infty, plus_infty);
6681   TEST_f_f (nearbyint, minus_infty, minus_infty);
6682   TEST_f_f (nearbyint, nan_value, nan_value);
6683
6684   /* Subnormal values */
6685   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
6686   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
6687
6688   /* Default rounding mode is round to nearest.  */
6689   TEST_f_f (nearbyint, 0.5, 0.0);
6690   TEST_f_f (nearbyint, 1.5, 2.0);
6691   TEST_f_f (nearbyint, -0.5, minus_zero);
6692   TEST_f_f (nearbyint, -1.5, -2.0);
6693
6694   TEST_f_f (nearbyint, 262144.75, 262145.0);
6695   TEST_f_f (nearbyint, 262142.75, 262143.0);
6696   TEST_f_f (nearbyint, 524286.75, 524287.0);
6697   TEST_f_f (nearbyint, 524288.75, 524289.0);
6698
6699   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
6700   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
6701   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
6702   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
6703   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
6704   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
6705   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
6706   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
6707   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
6708   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
6709 #ifndef TEST_FLOAT
6710   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
6711   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
6712   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
6713   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
6714   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
6715   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
6716   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
6717   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
6718   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
6719   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
6720 #endif
6721
6722   END (nearbyint);
6723 }
6724
6725 static void
6726 nextafter_test (void)
6727 {
6728
6729   START (nextafter);
6730
6731   TEST_ff_f (nextafter, 0, 0, 0);
6732   TEST_ff_f (nextafter, minus_zero, 0, 0);
6733   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
6734   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
6735
6736   TEST_ff_f (nextafter, 9, 9, 9);
6737   TEST_ff_f (nextafter, -9, -9, -9);
6738   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
6739   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
6740
6741   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
6742   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
6743   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
6744
6745   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
6746                          LDBL_MAX, DBL_MAX, FLT_MAX);
6747   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
6748   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
6749
6750 #ifdef TEST_LDOUBLE
6751   // XXX Enable once gcc is fixed.
6752   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
6753 #endif
6754
6755   /* XXX We need the hexadecimal FP number representation here for further
6756      tests.  */
6757
6758   END (nextafter);
6759 }
6760
6761
6762 static void
6763 nexttoward_test (void)
6764 {
6765   START (nexttoward);
6766   TEST_ff_f (nexttoward, 0, 0, 0);
6767   TEST_ff_f (nexttoward, minus_zero, 0, 0);
6768   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
6769   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
6770
6771   TEST_ff_f (nexttoward, 9, 9, 9);
6772   TEST_ff_f (nexttoward, -9, -9, -9);
6773   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
6774   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
6775
6776   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
6777   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
6778   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
6779
6780 #ifdef TEST_FLOAT
6781   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
6782   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
6783   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
6784   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
6785   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
6786   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
6787   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
6788   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
6789   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
6790   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
6791   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
6792   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
6793   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
6794 # if LDBL_MANT_DIG >= 64
6795   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
6796   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
6797   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
6798   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
6799 # endif
6800 # if LDBL_MANT_DIG >= 106
6801   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
6802   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
6803   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
6804   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
6805 # endif
6806 # if LDBL_MANT_DIG >= 113
6807   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
6808   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
6809   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
6810   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
6811 # endif
6812 #endif
6813 #ifdef TEST_DOUBLE
6814   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
6815   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
6816   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
6817   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
6818   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
6819   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
6820   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
6821   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
6822   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
6823   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
6824   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
6825   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
6826   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
6827   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
6828 # if LDBL_MANT_DIG >= 64
6829   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
6830   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
6831   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
6832   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
6833 # endif
6834 # if LDBL_MANT_DIG >= 106
6835   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
6836   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
6837   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
6838   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
6839 # endif
6840 # if LDBL_MANT_DIG >= 113
6841   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
6842   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
6843   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
6844   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
6845 # endif
6846 #endif
6847
6848   END (nexttoward);
6849 }
6850
6851
6852 static void
6853 pow_test (void)
6854 {
6855
6856   errno = 0;
6857   FUNC(pow) (0, 0);
6858   if (errno == ENOSYS)
6859     /* Function not implemented.  */
6860     return;
6861
6862   START (pow);
6863
6864   TEST_ff_f (pow, 0, 0, 1);
6865   TEST_ff_f (pow, 0, minus_zero, 1);
6866   TEST_ff_f (pow, minus_zero, 0, 1);
6867   TEST_ff_f (pow, minus_zero, minus_zero, 1);
6868
6869   TEST_ff_f (pow, 10, 0, 1);
6870   TEST_ff_f (pow, 10, minus_zero, 1);
6871   TEST_ff_f (pow, -10, 0, 1);
6872   TEST_ff_f (pow, -10, minus_zero, 1);
6873
6874   TEST_ff_f (pow, nan_value, 0, 1);
6875   TEST_ff_f (pow, nan_value, minus_zero, 1);
6876
6877
6878 #ifndef TEST_INLINE
6879   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
6880   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
6881   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
6882   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
6883
6884   TEST_ff_f (pow, 0.9L, plus_infty, 0);
6885   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
6886   TEST_ff_f (pow, -0.9L, plus_infty, 0);
6887   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
6888
6889   TEST_ff_f (pow, 1.1L, minus_infty, 0);
6890   TEST_ff_f (pow, plus_infty, minus_infty, 0);
6891   TEST_ff_f (pow, -1.1L, minus_infty, 0);
6892   TEST_ff_f (pow, minus_infty, minus_infty, 0);
6893
6894   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
6895   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
6896   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
6897   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
6898
6899   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
6900   TEST_ff_f (pow, plus_infty, 1, plus_infty);
6901   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
6902
6903   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
6904   TEST_ff_f (pow, plus_infty, -1, 0);
6905   TEST_ff_f (pow, plus_infty, -1e7L, 0);
6906
6907   TEST_ff_f (pow, minus_infty, 1, minus_infty);
6908   TEST_ff_f (pow, minus_infty, 11, minus_infty);
6909   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
6910
6911   TEST_ff_f (pow, minus_infty, 2, plus_infty);
6912   TEST_ff_f (pow, minus_infty, 12, plus_infty);
6913   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
6914   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
6915   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
6916   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
6917   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
6918
6919   TEST_ff_f (pow, minus_infty, -1, minus_zero);
6920   TEST_ff_f (pow, minus_infty, -11, minus_zero);
6921   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
6922
6923   TEST_ff_f (pow, minus_infty, -2, 0);
6924   TEST_ff_f (pow, minus_infty, -12, 0);
6925   TEST_ff_f (pow, minus_infty, -1002, 0);
6926   TEST_ff_f (pow, minus_infty, -0.1L, 0);
6927   TEST_ff_f (pow, minus_infty, -1.1L, 0);
6928   TEST_ff_f (pow, minus_infty, -11.1L, 0);
6929   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
6930 #endif
6931
6932   TEST_ff_f (pow, nan_value, nan_value, nan_value);
6933   TEST_ff_f (pow, 0, nan_value, nan_value);
6934   TEST_ff_f (pow, 1, nan_value, 1);
6935   TEST_ff_f (pow, -1, nan_value, nan_value);
6936   TEST_ff_f (pow, nan_value, 1, nan_value);
6937   TEST_ff_f (pow, nan_value, -1, nan_value);
6938
6939   /* pow (x, NaN) == NaN.  */
6940   TEST_ff_f (pow, 3.0, nan_value, nan_value);
6941   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
6942   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
6943   TEST_ff_f (pow, -3.0, nan_value, nan_value);
6944   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
6945
6946   TEST_ff_f (pow, nan_value, 3.0, nan_value);
6947   TEST_ff_f (pow, nan_value, -3.0, nan_value);
6948   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
6949   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
6950   TEST_ff_f (pow, nan_value, 2.5, nan_value);
6951   TEST_ff_f (pow, nan_value, -2.5, nan_value);
6952
6953   TEST_ff_f (pow, 1, plus_infty, 1);
6954   TEST_ff_f (pow, -1, plus_infty, 1);
6955   TEST_ff_f (pow, 1, minus_infty, 1);
6956   TEST_ff_f (pow, -1, minus_infty, 1);
6957   TEST_ff_f (pow, 1, 1, 1);
6958   TEST_ff_f (pow, 1, -1, 1);
6959   TEST_ff_f (pow, 1, 1.25, 1);
6960   TEST_ff_f (pow, 1, -1.25, 1);
6961   TEST_ff_f (pow, 1, 0x1p62L, 1);
6962   TEST_ff_f (pow, 1, 0x1p63L, 1);
6963   TEST_ff_f (pow, 1, 0x1p64L, 1);
6964   TEST_ff_f (pow, 1, 0x1p72L, 1);
6965
6966   /* pow (x, +-0) == 1.  */
6967   TEST_ff_f (pow, plus_infty, 0, 1);
6968   TEST_ff_f (pow, plus_infty, minus_zero, 1);
6969   TEST_ff_f (pow, minus_infty, 0, 1);
6970   TEST_ff_f (pow, minus_infty, minus_zero, 1);
6971   TEST_ff_f (pow, 32.75L, 0, 1);
6972   TEST_ff_f (pow, 32.75L, minus_zero, 1);
6973   TEST_ff_f (pow, -32.75L, 0, 1);
6974   TEST_ff_f (pow, -32.75L, minus_zero, 1);
6975   TEST_ff_f (pow, 0x1p72L, 0, 1);
6976   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
6977   TEST_ff_f (pow, 0x1p-72L, 0, 1);
6978   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
6979
6980   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
6981   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
6982   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
6983   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
6984
6985   errno = 0;
6986   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6987   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6988   errno = 0;
6989   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6990   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6991   errno = 0;
6992   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6993   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6994 #ifndef TEST_FLOAT
6995   errno = 0;
6996   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6997   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6998 #endif
6999 #ifdef TEST_LDOUBLE
7000 # if LDBL_MANT_DIG >= 64
7001   errno = 0;
7002   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7003   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7004 # endif
7005 # if LDBL_MANT_DIG >= 106
7006   errno = 0;
7007   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7008   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7009 # endif
7010 # if LDBL_MANT_DIG >= 113
7011   errno = 0;
7012   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7013   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7014 # endif
7015 #endif
7016   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7017   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7018   errno = 0;
7019   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7020   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7021   errno = 0;
7022   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7023   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7024   errno = 0;
7025   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7026   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7027 #ifndef TEST_FLOAT
7028   errno = 0;
7029   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7030   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7031   errno = 0;
7032   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7033   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7034 #endif
7035 #ifdef TEST_LDOUBLE
7036 # if LDBL_MANT_DIG >= 64
7037   errno = 0;
7038   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7039   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7040   errno = 0;
7041   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7042   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7043 # endif
7044 # if LDBL_MANT_DIG >= 106
7045   errno = 0;
7046   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7047   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7048   errno = 0;
7049   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7050   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7051 # endif
7052 # if LDBL_MANT_DIG >= 113
7053   errno = 0;
7054   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7055   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
7056   errno = 0;
7057   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7058   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7059 # endif
7060 #endif
7061
7062   errno = 0;
7063   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7064   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7065   errno = 0;
7066   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7067   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7068   errno = 0;
7069   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7070   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7071   errno = 0;
7072   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7073   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7074   errno = 0;
7075   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7076   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7077   errno = 0;
7078   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7079   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
7080   errno = 0;
7081   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7082   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7083   errno = 0;
7084   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7085   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7086   errno = 0;
7087   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7088   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7089   errno = 0;
7090   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7091   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
7092
7093   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
7094   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
7095   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
7096   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
7097
7098   TEST_ff_f (pow, 0, 1, 0);
7099   TEST_ff_f (pow, 0, 11, 0);
7100
7101   TEST_ff_f (pow, minus_zero, 1, minus_zero);
7102   TEST_ff_f (pow, minus_zero, 11, minus_zero);
7103
7104   TEST_ff_f (pow, 0, 2, 0);
7105   TEST_ff_f (pow, 0, 11.1L, 0);
7106
7107   TEST_ff_f (pow, minus_zero, 2, 0);
7108   TEST_ff_f (pow, minus_zero, 11.1L, 0);
7109   TEST_ff_f (pow, 0, plus_infty, 0);
7110   TEST_ff_f (pow, minus_zero, plus_infty, 0);
7111   TEST_ff_f (pow, 0, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7112   TEST_ff_f (pow, minus_zero, minus_infty, plus_infty, DIVIDE_BY_ZERO_EXCEPTION_OK);
7113
7114 #ifndef TEST_INLINE
7115   /* pow (x, +inf) == +inf for |x| > 1.  */
7116   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
7117
7118   /* pow (x, +inf) == +0 for |x| < 1.  */
7119   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
7120
7121   /* pow (x, -inf) == +0 for |x| > 1.  */
7122   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
7123
7124   /* pow (x, -inf) == +inf for |x| < 1.  */
7125   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
7126 #endif
7127
7128   /* pow (+inf, y) == +inf for y > 0.  */
7129   TEST_ff_f (pow, plus_infty, 2, plus_infty);
7130   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
7131 #ifndef TEST_FLOAT
7132   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
7133 #endif
7134 #ifdef TEST_LDOUBLE
7135 # if LDBL_MANT_DIG >= 64
7136   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
7137 # endif
7138 # if LDBL_MANT_DIG >= 106
7139   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
7140 # endif
7141 # if LDBL_MANT_DIG >= 113
7142   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
7143 # endif
7144 #endif
7145   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
7146   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
7147   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
7148
7149   /* pow (+inf, y) == +0 for y < 0.  */
7150   TEST_ff_f (pow, plus_infty, -1, 0.0);
7151   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
7152 #ifndef TEST_FLOAT
7153   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
7154 #endif
7155 #ifdef TEST_LDOUBLE
7156 # if LDBL_MANT_DIG >= 64
7157   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
7158 # endif
7159 # if LDBL_MANT_DIG >= 106
7160   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
7161 # endif
7162 # if LDBL_MANT_DIG >= 113
7163   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
7164 # endif
7165 #endif
7166   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
7167   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
7168   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
7169
7170   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
7171   TEST_ff_f (pow, minus_infty, 27, minus_infty);
7172   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
7173   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
7174 #ifndef TEST_FLOAT
7175   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
7176   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
7177 #endif
7178 #ifdef TEST_LDOUBLE
7179 # if LDBL_MANT_DIG >= 64
7180   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
7181   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
7182 # endif
7183 # if LDBL_MANT_DIG >= 106
7184   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
7185   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
7186 # endif
7187 # if LDBL_MANT_DIG >= 113
7188   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
7189   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
7190 # endif
7191 #endif
7192
7193   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
7194   TEST_ff_f (pow, minus_infty, 28, plus_infty);
7195   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
7196   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
7197   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
7198
7199   /* pow (-inf, y) == -0 for y an odd integer < 0. */
7200   TEST_ff_f (pow, minus_infty, -3, minus_zero);
7201   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
7202   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
7203 #ifndef TEST_FLOAT
7204   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
7205   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
7206 #endif
7207 #ifdef TEST_LDOUBLE
7208 # if LDBL_MANT_DIG >= 64
7209   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
7210   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
7211 # endif
7212 # if LDBL_MANT_DIG >= 106
7213   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
7214   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
7215 # endif
7216 # if LDBL_MANT_DIG >= 113
7217   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
7218   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
7219 # endif
7220 #endif
7221   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
7222   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
7223   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
7224   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
7225   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
7226
7227   /* pow (+0, y) == +0 for y an odd integer > 0.  */
7228   TEST_ff_f (pow, 0.0, 27, 0.0);
7229   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
7230 #ifndef TEST_FLOAT
7231   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
7232 #endif
7233 #ifdef TEST_LDOUBLE
7234 # if LDBL_MANT_DIG >= 64
7235   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
7236 # endif
7237 # if LDBL_MANT_DIG >= 106
7238   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
7239 # endif
7240 # if LDBL_MANT_DIG >= 113
7241   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
7242 # endif
7243 #endif
7244
7245   /* pow (-0, y) == -0 for y an odd integer > 0.  */
7246   TEST_ff_f (pow, minus_zero, 27, minus_zero);
7247   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
7248   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
7249 #ifndef TEST_FLOAT
7250   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
7251   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
7252 #endif
7253 #ifdef TEST_LDOUBLE
7254 # if LDBL_MANT_DIG >= 64
7255   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
7256   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
7257 # endif
7258 # if LDBL_MANT_DIG >= 106
7259   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
7260   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
7261 # endif
7262 # if LDBL_MANT_DIG >= 113
7263   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
7264   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
7265 # endif
7266 #endif
7267
7268   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
7269   TEST_ff_f (pow, 0.0, 4, 0.0);
7270   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
7271   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
7272   TEST_ff_f (pow, 0.0, max_value, 0.0);
7273
7274   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
7275   TEST_ff_f (pow, minus_zero, 4, 0.0);
7276   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
7277   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
7278   TEST_ff_f (pow, minus_zero, max_value, 0.0);
7279
7280   TEST_ff_f (pow, 16, 0.25L, 2);
7281   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
7282   TEST_ff_f (pow, 2, 4, 16);
7283   TEST_ff_f (pow, 256, 8, 0x1p64L);
7284
7285   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
7286
7287 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
7288   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
7289 #endif
7290
7291   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
7292   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
7293 #ifndef TEST_FLOAT
7294   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
7295   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
7296 #endif
7297 #ifdef TEST_LDOUBLE
7298 # if LDBL_MANT_DIG >= 64
7299   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
7300   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
7301 # endif
7302 # if LDBL_MANT_DIG >= 106
7303   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
7304   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
7305 # endif
7306 # if LDBL_MANT_DIG >= 113
7307   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
7308   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
7309 # endif
7310 #endif
7311   TEST_ff_f (pow, -1.0, -max_value, 1.0);
7312
7313   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
7314   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
7315 #ifndef TEST_FLOAT
7316   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
7317   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
7318 #endif
7319 #ifdef TEST_LDOUBLE
7320 # if LDBL_MANT_DIG >= 64
7321   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
7322   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
7323 # endif
7324 # if LDBL_MANT_DIG >= 106
7325   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
7326   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
7327 # endif
7328 # if LDBL_MANT_DIG >= 113
7329   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
7330   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
7331 # endif
7332 #endif
7333   TEST_ff_f (pow, -1.0, max_value, 1.0);
7334
7335   TEST_ff_f (pow, -2.0, 126, 0x1p126);
7336   TEST_ff_f (pow, -2.0, 127, -0x1p127);
7337   /* Allow inexact results for float to be considered to underflow.  */
7338   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
7339   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
7340
7341   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
7342   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
7343 #ifndef TEST_FLOAT
7344   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
7345   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
7346 #endif
7347 #ifdef TEST_LDOUBLE
7348 # if LDBL_MANT_DIG >= 64
7349   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
7350   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
7351 # endif
7352 # if LDBL_MANT_DIG >= 106
7353   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
7354   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
7355 # endif
7356 # if LDBL_MANT_DIG >= 113
7357   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
7358   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
7359 # endif
7360 #endif
7361   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
7362
7363   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
7364   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
7365 #ifndef TEST_FLOAT
7366   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
7367   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
7368 #endif
7369 #ifdef TEST_LDOUBLE
7370 # if LDBL_MANT_DIG >= 64
7371   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
7372   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
7373 # endif
7374 # if LDBL_MANT_DIG >= 106
7375   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
7376   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
7377 # endif
7378 # if LDBL_MANT_DIG >= 113
7379   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
7380   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
7381 # endif
7382 #endif
7383   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
7384
7385   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
7386   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
7387   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
7388   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
7389   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
7390   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
7391   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
7392
7393   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
7394   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
7395 #ifndef TEST_FLOAT
7396   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
7397   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
7398 #endif
7399 #ifdef TEST_LDOUBLE
7400 # if LDBL_MANT_DIG >= 64
7401   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
7402   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
7403 # endif
7404 # if LDBL_MANT_DIG >= 106
7405   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
7406   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
7407 # endif
7408 # if LDBL_MANT_DIG >= 113
7409   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
7410   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
7411 # endif
7412 #endif
7413   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
7414
7415   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
7416   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
7417 #ifndef TEST_FLOAT
7418   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
7419   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
7420 #endif
7421 #ifdef TEST_LDOUBLE
7422 # if LDBL_MANT_DIG >= 64
7423   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
7424   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
7425 # endif
7426 # if LDBL_MANT_DIG >= 106
7427   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
7428   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
7429 # endif
7430 # if LDBL_MANT_DIG >= 113
7431   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
7432   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
7433 # endif
7434 #endif
7435   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
7436
7437   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
7438   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
7439   TEST_ff_f (pow, -0.5, -126, 0x1p126);
7440   TEST_ff_f (pow, -0.5, -127, -0x1p127);
7441
7442   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
7443   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
7444 #ifndef TEST_FLOAT
7445   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
7446   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
7447 #endif
7448 #ifdef TEST_LDOUBLE
7449 # if LDBL_MANT_DIG >= 64
7450   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
7451   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
7452 # endif
7453 # if LDBL_MANT_DIG >= 106
7454   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
7455   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
7456 # endif
7457 # if LDBL_MANT_DIG >= 113
7458   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
7459   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
7460 # endif
7461 #endif
7462   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
7463
7464   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
7465   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
7466 #ifndef TEST_FLOAT
7467   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
7468   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
7469 #endif
7470 #ifdef TEST_LDOUBLE
7471 # if LDBL_MANT_DIG >= 64
7472   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
7473   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
7474 # endif
7475 # if LDBL_MANT_DIG >= 106
7476   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
7477   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
7478 # endif
7479 # if LDBL_MANT_DIG >= 113
7480   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
7481   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
7482 # endif
7483 #endif
7484   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
7485
7486   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
7487   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
7488   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
7489   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
7490   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
7491   /* Allow inexact results to be considered to underflow.  */
7492   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
7493   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
7494   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
7495
7496   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
7497   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
7498 #ifndef TEST_FLOAT
7499   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
7500   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
7501 #endif
7502 #ifdef TEST_LDOUBLE
7503 # if LDBL_MANT_DIG >= 64
7504   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
7505   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
7506 # endif
7507 # if LDBL_MANT_DIG >= 106
7508   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
7509   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
7510 # endif
7511 # if LDBL_MANT_DIG >= 113
7512   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
7513   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
7514 # endif
7515 #endif
7516   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
7517
7518   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
7519   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
7520 #ifndef TEST_FLOAT
7521   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
7522   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
7523 #endif
7524 #ifdef TEST_LDOUBLE
7525 # if LDBL_MANT_DIG >= 64
7526   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
7527   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
7528 # endif
7529 # if LDBL_MANT_DIG >= 106
7530   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
7531   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
7532 # endif
7533 # if LDBL_MANT_DIG >= 113
7534   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
7535   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
7536 # endif
7537 #endif
7538   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
7539
7540 #ifndef TEST_LDOUBLE /* Bug 13881.  */
7541   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
7542   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
7543   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
7544   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
7545   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
7546   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
7547   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
7548   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
7549   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
7550   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
7551   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
7552   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
7553   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
7554   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
7555   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
7556 #endif
7557
7558   /* Bug 13881: powl inaccurate so these tests disabled for long double.  */
7559 #if !defined TEST_FLOAT && !defined TEST_LDOUBLE
7560   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
7561   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
7562   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
7563   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
7564 #endif
7565
7566   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
7567
7568   END (pow);
7569 }
7570
7571
7572 static void
7573 pow_test_tonearest (void)
7574 {
7575   int save_round_mode;
7576   errno = 0;
7577   FUNC(pow) (0, 0);
7578   if (errno == ENOSYS)
7579     /* Function not implemented.  */
7580     return;
7581
7582   START (pow_tonearest);
7583
7584   save_round_mode = fegetround ();
7585
7586   if (!fesetround (FE_TONEAREST))
7587     {
7588       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
7589       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
7590     }
7591
7592   fesetround (save_round_mode);
7593
7594   END (pow_tonearest);
7595 }
7596
7597
7598 static void
7599 pow_test_towardzero (void)
7600 {
7601   int save_round_mode;
7602   errno = 0;
7603   FUNC(pow) (0, 0);
7604   if (errno == ENOSYS)
7605     /* Function not implemented.  */
7606     return;
7607
7608   START (pow_towardzero);
7609
7610   save_round_mode = fegetround ();
7611
7612   if (!fesetround (FE_TOWARDZERO))
7613     {
7614       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
7615       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
7616     }
7617
7618   fesetround (save_round_mode);
7619
7620   END (pow_towardzero);
7621 }
7622
7623
7624 static void
7625 pow_test_downward (void)
7626 {
7627   int save_round_mode;
7628   errno = 0;
7629   FUNC(pow) (0, 0);
7630   if (errno == ENOSYS)
7631     /* Function not implemented.  */
7632     return;
7633
7634   START (pow_downward);
7635
7636   save_round_mode = fegetround ();
7637
7638   if (!fesetround (FE_DOWNWARD))
7639     {
7640       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
7641       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
7642     }
7643
7644   fesetround (save_round_mode);
7645
7646   END (pow_downward);
7647 }
7648
7649
7650 static void
7651 pow_test_upward (void)
7652 {
7653   int save_round_mode;
7654   errno = 0;
7655   FUNC(pow) (0, 0);
7656   if (errno == ENOSYS)
7657     /* Function not implemented.  */
7658     return;
7659
7660   START (pow_upward);
7661
7662   save_round_mode = fegetround ();
7663
7664   if (!fesetround (FE_UPWARD))
7665     {
7666       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
7667       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
7668     }
7669
7670   fesetround (save_round_mode);
7671
7672   END (pow_upward);
7673 }
7674
7675
7676 static void
7677 remainder_test (void)
7678 {
7679   errno = 0;
7680   FUNC(remainder) (1.625, 1.0);
7681   if (errno == ENOSYS)
7682     /* Function not implemented.  */
7683     return;
7684
7685   START (remainder);
7686
7687   errno = 0;
7688   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
7689   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
7690   errno = 0;
7691   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
7692   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
7693   errno = 0;
7694   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
7695   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
7696   errno = 0;
7697   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
7698   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
7699   errno = 0;
7700   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
7701   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
7702   errno = 0;
7703   TEST_ff_f (remainder, 0, nan_value, nan_value);
7704   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
7705   errno = 0;
7706   TEST_ff_f (remainder, nan_value, 0, nan_value);
7707   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
7708
7709   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
7710   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
7711   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
7712   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
7713   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
7714   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
7715
7716   END (remainder);
7717 }
7718
7719 static void
7720 remquo_test (void)
7721 {
7722   /* x is needed.  */
7723   int x;
7724
7725   errno = 0;
7726   FUNC(remquo) (1.625, 1.0, &x);
7727   if (errno == ENOSYS)
7728     /* Function not implemented.  */
7729     return;
7730
7731   START (remquo);
7732
7733   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
7734   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
7735   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
7736   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
7737   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
7738
7739   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
7740   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
7741   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
7742   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
7743
7744   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
7745   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
7746
7747   END (remquo);
7748 }
7749
7750 static void
7751 rint_test (void)
7752 {
7753   START (rint);
7754
7755   TEST_f_f (rint, 0.0, 0.0);
7756   TEST_f_f (rint, minus_zero, minus_zero);
7757   TEST_f_f (rint, plus_infty, plus_infty);
7758   TEST_f_f (rint, minus_infty, minus_infty);
7759
7760   /* Default rounding mode is round to even.  */
7761   TEST_f_f (rint, 0.5, 0.0);
7762   TEST_f_f (rint, 1.5, 2.0);
7763   TEST_f_f (rint, 2.5, 2.0);
7764   TEST_f_f (rint, 3.5, 4.0);
7765   TEST_f_f (rint, 4.5, 4.0);
7766   TEST_f_f (rint, -0.5, -0.0);
7767   TEST_f_f (rint, -1.5, -2.0);
7768   TEST_f_f (rint, -2.5, -2.0);
7769   TEST_f_f (rint, -3.5, -4.0);
7770   TEST_f_f (rint, -4.5, -4.0);
7771   TEST_f_f (rint, 0.1, 0.0);
7772   TEST_f_f (rint, 0.25, 0.0);
7773   TEST_f_f (rint, 0.625, 1.0);
7774   TEST_f_f (rint, -0.1, -0.0);
7775   TEST_f_f (rint, -0.25, -0.0);
7776   TEST_f_f (rint, -0.625, -1.0);
7777   TEST_f_f (rint, 262144.75, 262145.0);
7778   TEST_f_f (rint, 262142.75, 262143.0);
7779   TEST_f_f (rint, 524286.75, 524287.0);
7780   TEST_f_f (rint, 524288.75, 524289.0);
7781   TEST_f_f (rint, 1048576.75, 1048577.0);
7782   TEST_f_f (rint, 2097152.75, 2097153.0);
7783   TEST_f_f (rint, -1048576.75, -1048577.0);
7784   TEST_f_f (rint, -2097152.75, -2097153.0);
7785 #ifndef TEST_FLOAT
7786   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
7787   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
7788   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
7789   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
7790   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
7791   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
7792   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
7793   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
7794   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
7795   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
7796 #endif
7797 #ifdef TEST_LDOUBLE
7798   /* The result can only be represented in long double.  */
7799   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
7800   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
7801   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
7802   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
7803   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
7804
7805 # if LDBL_MANT_DIG > 100
7806   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
7807   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
7808   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
7809 # endif
7810
7811   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
7812   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
7813   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
7814   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
7815   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
7816
7817 # if LDBL_MANT_DIG > 100
7818   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
7819   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
7820   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
7821
7822   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
7823   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
7824   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
7825   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
7826   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
7827   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
7828
7829   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7830   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7831   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7832   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
7833   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
7834   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
7835 # endif
7836
7837   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
7838   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
7839   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
7840   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
7841   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
7842
7843   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
7844   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
7845   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
7846   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
7847   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
7848
7849   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
7850   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
7851   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
7852   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
7853   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
7854
7855   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
7856   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
7857   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
7858   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
7859   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
7860
7861   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
7862   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7863   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7864   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
7865   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
7866 #endif
7867
7868   END (rint);
7869 }
7870
7871 static void
7872 rint_test_tonearest (void)
7873 {
7874   int save_round_mode;
7875   START (rint_tonearest);
7876
7877   save_round_mode = fegetround ();
7878
7879   if (!fesetround (FE_TONEAREST))
7880     {
7881       TEST_f_f (rint, 2.0, 2.0);
7882       TEST_f_f (rint, 1.5, 2.0);
7883       TEST_f_f (rint, 1.0, 1.0);
7884       TEST_f_f (rint, 0.5, 0.0);
7885       TEST_f_f (rint, 0.0, 0.0);
7886       TEST_f_f (rint, minus_zero, minus_zero);
7887       TEST_f_f (rint, -0.5, -0.0);
7888       TEST_f_f (rint, -1.0, -1.0);
7889       TEST_f_f (rint, -1.5, -2.0);
7890       TEST_f_f (rint, -2.0, -2.0);
7891       TEST_f_f (rint, 0.1, 0.0);
7892       TEST_f_f (rint, 0.25, 0.0);
7893       TEST_f_f (rint, 0.625, 1.0);
7894       TEST_f_f (rint, -0.1, -0.0);
7895       TEST_f_f (rint, -0.25, -0.0);
7896       TEST_f_f (rint, -0.625, -1.0);
7897       TEST_f_f (rint, 1048576.75, 1048577.0);
7898       TEST_f_f (rint, 2097152.75, 2097153.0);
7899       TEST_f_f (rint, -1048576.75, -1048577.0);
7900       TEST_f_f (rint, -2097152.75, -2097153.0);
7901 #ifndef TEST_FLOAT
7902       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
7903       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
7904       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
7905       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
7906       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
7907       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
7908       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
7909       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
7910       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
7911       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
7912 #endif
7913 #ifdef TEST_LDOUBLE
7914       /* The result can only be represented in long double.  */
7915       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
7916       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
7917       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
7918       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
7919       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
7920 # if LDBL_MANT_DIG > 100
7921       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
7922       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
7923       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
7924 # endif
7925       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
7926       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
7927       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
7928       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
7929       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
7930 # if LDBL_MANT_DIG > 100
7931       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
7932       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
7933       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
7934
7935       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
7936       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
7937       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
7938       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
7939       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
7940       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
7941
7942       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7943       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7944       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7945       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
7946       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
7947       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
7948 # endif
7949 #endif
7950     }
7951
7952   fesetround (save_round_mode);
7953
7954   END (rint_tonearest);
7955 }
7956
7957 static void
7958 rint_test_towardzero (void)
7959 {
7960   int save_round_mode;
7961   START (rint_towardzero);
7962
7963   save_round_mode = fegetround ();
7964
7965   if (!fesetround (FE_TOWARDZERO))
7966     {
7967       TEST_f_f (rint, 2.0, 2.0);
7968       TEST_f_f (rint, 1.5, 1.0);
7969       TEST_f_f (rint, 1.0, 1.0);
7970       TEST_f_f (rint, 0.5, 0.0);
7971       TEST_f_f (rint, 0.0, 0.0);
7972       TEST_f_f (rint, minus_zero, minus_zero);
7973       TEST_f_f (rint, -0.5, -0.0);
7974       TEST_f_f (rint, -1.0, -1.0);
7975       TEST_f_f (rint, -1.5, -1.0);
7976       TEST_f_f (rint, -2.0, -2.0);
7977       TEST_f_f (rint, 0.1, 0.0);
7978       TEST_f_f (rint, 0.25, 0.0);
7979       TEST_f_f (rint, 0.625, 0.0);
7980       TEST_f_f (rint, -0.1, -0.0);
7981       TEST_f_f (rint, -0.25, -0.0);
7982       TEST_f_f (rint, -0.625, -0.0);
7983       TEST_f_f (rint, 1048576.75, 1048576.0);
7984       TEST_f_f (rint, 2097152.75, 2097152.0);
7985       TEST_f_f (rint, -1048576.75, -1048576.0);
7986       TEST_f_f (rint, -2097152.75, -2097152.0);
7987 #ifndef TEST_FLOAT
7988       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
7989       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
7990       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
7991       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
7992       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
7993       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
7994       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
7995       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
7996       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
7997       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
7998 #endif
7999 #ifdef TEST_LDOUBLE
8000       /* The result can only be represented in long double.  */
8001       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8002       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8003       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8004       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8005       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8006 # if LDBL_MANT_DIG > 100
8007       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8008       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8009       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8010 # endif
8011       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
8012       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8013       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8014       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
8015       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
8016 # if LDBL_MANT_DIG > 100
8017       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
8018       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
8019       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
8020
8021       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8022       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8023       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8024       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8025       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8026       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8027
8028       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8029       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8030       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8031       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
8032       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
8033       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
8034 # endif
8035 #endif
8036     }
8037
8038   fesetround (save_round_mode);
8039
8040   END (rint_towardzero);
8041 }
8042
8043 static void
8044 rint_test_downward (void)
8045 {
8046   int save_round_mode;
8047   START (rint_downward);
8048
8049   save_round_mode = fegetround ();
8050
8051   if (!fesetround (FE_DOWNWARD))
8052     {
8053       TEST_f_f (rint, 2.0, 2.0);
8054       TEST_f_f (rint, 1.5, 1.0);
8055       TEST_f_f (rint, 1.0, 1.0);
8056       TEST_f_f (rint, 0.5, 0.0);
8057       TEST_f_f (rint, 0.0, 0.0);
8058       TEST_f_f (rint, minus_zero, minus_zero);
8059       TEST_f_f (rint, -0.5, -1.0);
8060       TEST_f_f (rint, -1.0, -1.0);
8061       TEST_f_f (rint, -1.5, -2.0);
8062       TEST_f_f (rint, -2.0, -2.0);
8063       TEST_f_f (rint, 0.1, 0.0);
8064       TEST_f_f (rint, 0.25, 0.0);
8065       TEST_f_f (rint, 0.625, 0.0);
8066       TEST_f_f (rint, -0.1, -1.0);
8067       TEST_f_f (rint, -0.25, -1.0);
8068       TEST_f_f (rint, -0.625, -1.0);
8069       TEST_f_f (rint, 1048576.75, 1048576.0);
8070       TEST_f_f (rint, 2097152.75, 2097152.0);
8071       TEST_f_f (rint, -1048576.75, -1048577.0);
8072       TEST_f_f (rint, -2097152.75, -2097153.0);
8073 #ifndef TEST_FLOAT
8074       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
8075       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
8076       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
8077       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
8078       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
8079       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
8080       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
8081       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
8082       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
8083       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
8084 #endif
8085 #ifdef TEST_LDOUBLE
8086       /* The result can only be represented in long double.  */
8087       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
8088       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
8089       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
8090       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
8091       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
8092 # if LDBL_MANT_DIG > 100
8093       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
8094       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
8095       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
8096 # endif
8097       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
8098       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
8099       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
8100       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
8101       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
8102 # if LDBL_MANT_DIG > 100
8103       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
8104       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
8105       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
8106
8107       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
8108       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
8109       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
8110       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
8111       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
8112       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
8113
8114       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
8115       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
8116       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
8117       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
8118       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
8119       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
8120 # endif
8121 #endif
8122     }
8123
8124   fesetround (save_round_mode);
8125
8126   END (rint_downward);
8127 }
8128
8129 static void
8130 rint_test_upward (void)
8131 {
8132   int save_round_mode;
8133   START (rint_upward);
8134
8135   save_round_mode = fegetround ();
8136
8137   if (!fesetround (FE_UPWARD))
8138     {
8139       TEST_f_f (rint, 2.0, 2.0);
8140       TEST_f_f (rint, 1.5, 2.0);
8141       TEST_f_f (rint, 1.0, 1.0);
8142       TEST_f_f (rint, 0.5, 1.0);
8143       TEST_f_f (rint, 0.0, 0.0);
8144       TEST_f_f (rint, minus_zero, minus_zero);
8145       TEST_f_f (rint, -0.5, -0.0);
8146       TEST_f_f (rint, -1.0, -1.0);
8147       TEST_f_f (rint, -1.5, -1.0);
8148       TEST_f_f (rint, -2.0, -2.0);
8149       TEST_f_f (rint, 0.1, 1.0);
8150       TEST_f_f (rint, 0.25, 1.0);
8151       TEST_f_f (rint, 0.625, 1.0);
8152       TEST_f_f (rint, -0.1, -0.0);
8153       TEST_f_f (rint, -0.25, -0.0);
8154       TEST_f_f (rint, -0.625, -0.0);
8155       TEST_f_f (rint, 1048576.75, 1048577.0);
8156       TEST_f_f (rint, 2097152.75, 2097153.0);
8157       TEST_f_f (rint, -1048576.75, -1048576.0);
8158       TEST_f_f (rint, -2097152.75, -2097152.0);
8159 #ifndef TEST_FLOAT
8160       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
8161       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
8162       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
8163       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
8164       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
8165       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
8166       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
8167       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
8168       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
8169       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
8170 #endif
8171 #ifdef TEST_LDOUBLE
8172       /* The result can only be represented in long double.  */
8173       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
8174       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
8175       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
8176       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
8177       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
8178 # if LDBL_MANT_DIG > 100
8179       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
8180       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
8181       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
8182 # endif
8183       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
8184       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
8185       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
8186       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
8187       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
8188 # if LDBL_MANT_DIG > 100
8189       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
8190       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
8191       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
8192
8193       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
8194       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
8195       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
8196       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
8197       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
8198       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
8199
8200       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
8201       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
8202       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
8203       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
8204       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
8205       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
8206 # endif
8207 #endif
8208     }
8209
8210   fesetround (save_round_mode);
8211
8212   END (rint_upward);
8213 }
8214
8215 static void
8216 round_test (void)
8217 {
8218   START (round);
8219
8220   TEST_f_f (round, 0, 0);
8221   TEST_f_f (round, minus_zero, minus_zero);
8222   TEST_f_f (round, 0.2L, 0.0);
8223   TEST_f_f (round, -0.2L, minus_zero);
8224   TEST_f_f (round, 0.5, 1.0);
8225   TEST_f_f (round, -0.5, -1.0);
8226   TEST_f_f (round, 0.8L, 1.0);
8227   TEST_f_f (round, -0.8L, -1.0);
8228   TEST_f_f (round, 1.5, 2.0);
8229   TEST_f_f (round, -1.5, -2.0);
8230   TEST_f_f (round, 0.1, 0.0);
8231   TEST_f_f (round, 0.25, 0.0);
8232   TEST_f_f (round, 0.625, 1.0);
8233   TEST_f_f (round, -0.1, -0.0);
8234   TEST_f_f (round, -0.25, -0.0);
8235   TEST_f_f (round, -0.625, -1.0);
8236   TEST_f_f (round, 2097152.5, 2097153);
8237   TEST_f_f (round, -2097152.5, -2097153);
8238
8239 #ifdef TEST_LDOUBLE
8240   /* The result can only be represented in long double.  */
8241   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
8242   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
8243   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
8244   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
8245   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
8246 # if LDBL_MANT_DIG > 100
8247   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
8248   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
8249   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
8250 # endif
8251
8252   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
8253   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
8254   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
8255   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
8256   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
8257 # if LDBL_MANT_DIG > 100
8258   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
8259   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
8260   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
8261 # endif
8262
8263   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
8264   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
8265   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
8266   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
8267   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
8268
8269   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
8270   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
8271   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
8272   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
8273   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
8274
8275 # if LDBL_MANT_DIG > 100
8276   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
8277   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
8278   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
8279   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
8280   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
8281   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
8282
8283   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
8284   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
8285   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
8286   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
8287   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
8288   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
8289 # endif
8290
8291   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
8292   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
8293   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
8294   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
8295   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
8296
8297   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
8298   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
8299   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
8300   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
8301   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
8302
8303   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
8304   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8305   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
8306   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
8307   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
8308 #endif
8309
8310   END (round);
8311 }
8312
8313
8314 static void
8315 scalb_test (void)
8316 {
8317
8318   START (scalb);
8319
8320   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
8321   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
8322
8323   TEST_ff_f (scalb, 0, nan_value, nan_value);
8324   TEST_ff_f (scalb, 1, nan_value, nan_value);
8325
8326   TEST_ff_f (scalb, 1, 0, 1);
8327   TEST_ff_f (scalb, -1, 0, -1);
8328
8329   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
8330   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
8331
8332   TEST_ff_f (scalb, 0, 2, 0);
8333   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
8334   TEST_ff_f (scalb, 0, 0, 0);
8335   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
8336   TEST_ff_f (scalb, 0, -1, 0);
8337   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
8338   TEST_ff_f (scalb, 0, minus_infty, 0);
8339   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
8340
8341   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
8342   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
8343   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
8344   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
8345   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
8346   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
8347
8348   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
8349   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
8350
8351   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
8352   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
8353   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
8354   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
8355
8356   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
8357   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
8358
8359   TEST_ff_f (scalb, nan_value, 1, nan_value);
8360   TEST_ff_f (scalb, 1, nan_value, nan_value);
8361   TEST_ff_f (scalb, nan_value, 0, nan_value);
8362   TEST_ff_f (scalb, 0, nan_value, nan_value);
8363   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
8364   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
8365   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
8366
8367   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
8368   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
8369
8370   END (scalb);
8371 }
8372
8373
8374 static void
8375 scalbn_test (void)
8376 {
8377
8378   START (scalbn);
8379
8380   TEST_fi_f (scalbn, 0, 0, 0);
8381   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
8382
8383   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
8384   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
8385   TEST_fi_f (scalbn, nan_value, 1, nan_value);
8386
8387   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
8388   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
8389
8390   TEST_fi_f (scalbn, 1, 0L, 1);
8391
8392   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8393   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8394   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8395   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8396   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8397   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8398   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8399   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8400
8401   END (scalbn);
8402 }
8403
8404
8405 static void
8406 scalbln_test (void)
8407 {
8408
8409   START (scalbln);
8410
8411   TEST_fl_f (scalbln, 0, 0, 0);
8412   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
8413
8414   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
8415   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
8416   TEST_fl_f (scalbln, nan_value, 1, nan_value);
8417
8418   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
8419   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
8420
8421   TEST_fl_f (scalbln, 1, 0L, 1);
8422
8423   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8424   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8425   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8426   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8427   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8428   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8429   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
8430   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8431
8432   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
8433   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8434   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
8435   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8436   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
8437   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8438   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
8439   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
8440
8441 #if LONG_MAX >= 0x100000000
8442   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
8443   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
8444   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
8445   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
8446   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
8447   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
8448   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
8449   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
8450 #endif
8451
8452   END (scalbn);
8453 }
8454
8455
8456 static void
8457 signbit_test (void)
8458 {
8459
8460   START (signbit);
8461
8462   TEST_f_b (signbit, 0, 0);
8463   TEST_f_b (signbit, minus_zero, 1);
8464   TEST_f_b (signbit, plus_infty, 0);
8465   TEST_f_b (signbit, minus_infty, 1);
8466
8467   /* signbit (x) != 0 for x < 0.  */
8468   TEST_f_b (signbit, -1, 1);
8469   /* signbit (x) == 0 for x >= 0.  */
8470   TEST_f_b (signbit, 1, 0);
8471
8472   END (signbit);
8473 }
8474
8475
8476 static void
8477 sin_test (void)
8478 {
8479   errno = 0;
8480   FUNC(sin) (0);
8481   if (errno == ENOSYS)
8482     /* Function not implemented.  */
8483     return;
8484
8485   START (sin);
8486
8487   TEST_f_f (sin, 0, 0);
8488   TEST_f_f (sin, minus_zero, minus_zero);
8489   errno = 0;
8490   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
8491   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
8492   errno = 0;
8493   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
8494   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
8495   errno = 0;
8496   TEST_f_f (sin, nan_value, nan_value);
8497   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
8498
8499   TEST_f_f (sin, M_PI_6l, 0.5);
8500   TEST_f_f (sin, -M_PI_6l, -0.5);
8501   TEST_f_f (sin, M_PI_2l, 1);
8502   TEST_f_f (sin, -M_PI_2l, -1);
8503   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
8504
8505   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
8506   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
8507
8508   TEST_f_f (sin, 0x1.7f4134p+103, -6.6703229329788657073304190650534846045235e-08L);
8509
8510 #ifdef TEST_DOUBLE
8511   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
8512   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
8513 #endif
8514
8515 #ifndef TEST_FLOAT
8516   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
8517   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
8518 #endif
8519
8520 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8521   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
8522 #endif
8523
8524   TEST_f_f (sin, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L);
8525   TEST_f_f (sin, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L);
8526   TEST_f_f (sin, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L);
8527   TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L);
8528   TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L);
8529   TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L);
8530
8531   END (sin);
8532
8533 }
8534
8535
8536 static void
8537 sin_test_tonearest (void)
8538 {
8539   int save_round_mode;
8540   errno = 0;
8541   FUNC(sin) (0);
8542   if (errno == ENOSYS)
8543     /* Function not implemented.  */
8544     return;
8545
8546   START (sin_tonearest);
8547
8548   save_round_mode = fegetround ();
8549
8550   if (!fesetround (FE_TONEAREST))
8551     {
8552       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
8553       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
8554       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
8555       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
8556       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
8557       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
8558       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
8559       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
8560       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
8561       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
8562     }
8563
8564   fesetround (save_round_mode);
8565
8566   END (sin_tonearest);
8567 }
8568
8569
8570 static void
8571 sin_test_towardzero (void)
8572 {
8573   int save_round_mode;
8574   errno = 0;
8575   FUNC(sin) (0);
8576   if (errno == ENOSYS)
8577     /* Function not implemented.  */
8578     return;
8579
8580   START (sin_towardzero);
8581
8582   save_round_mode = fegetround ();
8583
8584   if (!fesetround (FE_TOWARDZERO))
8585     {
8586       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
8587       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
8588       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
8589       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
8590       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
8591       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
8592       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
8593       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
8594       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
8595       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
8596     }
8597
8598   fesetround (save_round_mode);
8599
8600   END (sin_towardzero);
8601 }
8602
8603
8604 static void
8605 sin_test_downward (void)
8606 {
8607   int save_round_mode;
8608   errno = 0;
8609   FUNC(sin) (0);
8610   if (errno == ENOSYS)
8611     /* Function not implemented.  */
8612     return;
8613
8614   START (sin_downward);
8615
8616   save_round_mode = fegetround ();
8617
8618   if (!fesetround (FE_DOWNWARD))
8619     {
8620       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
8621       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
8622       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
8623       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
8624       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
8625       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
8626       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
8627       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
8628       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
8629       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
8630     }
8631
8632   fesetround (save_round_mode);
8633
8634   END (sin_downward);
8635 }
8636
8637
8638 static void
8639 sin_test_upward (void)
8640 {
8641   int save_round_mode;
8642   errno = 0;
8643   FUNC(sin) (0);
8644   if (errno == ENOSYS)
8645     /* Function not implemented.  */
8646     return;
8647
8648   START (sin_upward);
8649
8650   save_round_mode = fegetround ();
8651
8652   if (!fesetround (FE_UPWARD))
8653     {
8654       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
8655       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
8656       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
8657       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
8658       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
8659       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
8660       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
8661       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
8662       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
8663       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
8664     }
8665
8666   fesetround (save_round_mode);
8667
8668   END (sin_upward);
8669 }
8670
8671
8672 static void
8673 sincos_test (void)
8674 {
8675   FLOAT sin_res, cos_res;
8676
8677   errno = 0;
8678   FUNC(sincos) (0, &sin_res, &cos_res);
8679   if (errno == ENOSYS)
8680     /* Function not implemented.  */
8681     return;
8682
8683   START (sincos);
8684
8685   /* sincos is treated differently because it returns void.  */
8686   TEST_extra (sincos, 0, 0, 1);
8687
8688   TEST_extra (sincos, minus_zero, minus_zero, 1);
8689   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
8690   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
8691   TEST_extra (sincos, nan_value, nan_value, nan_value);
8692
8693   TEST_extra (sincos, M_PI_2l, 1, 0);
8694   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
8695   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
8696   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
8697
8698   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
8699   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
8700
8701 #ifdef TEST_DOUBLE
8702   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
8703 #endif
8704
8705 #ifndef TEST_FLOAT
8706   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
8707   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
8708 #endif
8709
8710 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8711   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
8712 #endif
8713
8714   TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L);
8715   TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L);
8716   TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L);
8717   TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L);
8718   TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L);
8719   TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L);
8720
8721   END (sincos);
8722 }
8723
8724 static void
8725 sinh_test (void)
8726 {
8727   errno = 0;
8728   FUNC(sinh) (0.7L);
8729   if (errno == ENOSYS)
8730     /* Function not implemented.  */
8731     return;
8732
8733   START (sinh);
8734   TEST_f_f (sinh, 0, 0);
8735   TEST_f_f (sinh, minus_zero, minus_zero);
8736
8737 #ifndef TEST_INLINE
8738   TEST_f_f (sinh, plus_infty, plus_infty);
8739   TEST_f_f (sinh, minus_infty, minus_infty);
8740 #endif
8741   TEST_f_f (sinh, nan_value, nan_value);
8742
8743   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
8744   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
8745
8746   END (sinh);
8747 }
8748
8749
8750 static void
8751 sinh_test_tonearest (void)
8752 {
8753   int save_round_mode;
8754   errno = 0;
8755   FUNC(sinh) (0);
8756   if (errno == ENOSYS)
8757     /* Function not implemented.  */
8758     return;
8759
8760   START (sinh_tonearest);
8761
8762   save_round_mode = fegetround ();
8763
8764   if (!fesetround (FE_TONEAREST))
8765     {
8766       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
8767       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
8768       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
8769     }
8770
8771   fesetround (save_round_mode);
8772
8773   END (sinh_tonearest);
8774 }
8775
8776
8777 static void
8778 sinh_test_towardzero (void)
8779 {
8780   int save_round_mode;
8781   errno = 0;
8782   FUNC(sinh) (0);
8783   if (errno == ENOSYS)
8784     /* Function not implemented.  */
8785     return;
8786
8787   START (sinh_towardzero);
8788
8789   save_round_mode = fegetround ();
8790
8791   if (!fesetround (FE_TOWARDZERO))
8792     {
8793       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
8794       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
8795       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
8796     }
8797
8798   fesetround (save_round_mode);
8799
8800   END (sinh_towardzero);
8801 }
8802
8803
8804 static void
8805 sinh_test_downward (void)
8806 {
8807   int save_round_mode;
8808   errno = 0;
8809   FUNC(sinh) (0);
8810   if (errno == ENOSYS)
8811     /* Function not implemented.  */
8812     return;
8813
8814   START (sinh_downward);
8815
8816   save_round_mode = fegetround ();
8817
8818   if (!fesetround (FE_DOWNWARD))
8819     {
8820       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
8821       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
8822       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
8823     }
8824
8825   fesetround (save_round_mode);
8826
8827   END (sinh_downward);
8828 }
8829
8830
8831 static void
8832 sinh_test_upward (void)
8833 {
8834   int save_round_mode;
8835   errno = 0;
8836   FUNC(sinh) (0);
8837   if (errno == ENOSYS)
8838     /* Function not implemented.  */
8839     return;
8840
8841   START (sinh_upward);
8842
8843   save_round_mode = fegetround ();
8844
8845   if (!fesetround (FE_UPWARD))
8846     {
8847       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
8848       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
8849       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
8850     }
8851
8852   fesetround (save_round_mode);
8853
8854   END (sinh_upward);
8855 }
8856
8857
8858 static void
8859 sqrt_test (void)
8860 {
8861   errno = 0;
8862   FUNC(sqrt) (1);
8863   if (errno == ENOSYS)
8864     /* Function not implemented.  */
8865     return;
8866
8867   START (sqrt);
8868
8869   TEST_f_f (sqrt, 0, 0);
8870   TEST_f_f (sqrt, nan_value, nan_value);
8871   TEST_f_f (sqrt, plus_infty, plus_infty);
8872
8873   TEST_f_f (sqrt, minus_zero, minus_zero);
8874
8875   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
8876   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
8877   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
8878   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
8879   TEST_f_f (sqrt, nan_value, nan_value);
8880
8881   TEST_f_f (sqrt, 2209, 47);
8882   TEST_f_f (sqrt, 4, 2);
8883   TEST_f_f (sqrt, 2, M_SQRT2l);
8884   TEST_f_f (sqrt, 0.25, 0.5);
8885   TEST_f_f (sqrt, 6642.25, 81.5);
8886   TEST_f_f (sqrt, 15190.5625L, 123.25L);
8887   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
8888
8889   END (sqrt);
8890 }
8891
8892
8893 static void
8894 tan_test (void)
8895 {
8896   errno = 0;
8897   FUNC(tan) (0);
8898   if (errno == ENOSYS)
8899     /* Function not implemented.  */
8900     return;
8901
8902   START (tan);
8903
8904   TEST_f_f (tan, 0, 0);
8905   TEST_f_f (tan, minus_zero, minus_zero);
8906   errno = 0;
8907   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
8908   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
8909   errno = 0;
8910   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
8911   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
8912   errno = 0;
8913   TEST_f_f (tan, nan_value, nan_value);
8914   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
8915
8916   TEST_f_f (tan, M_PI_4l, 1);
8917   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
8918
8919   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
8920   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
8921
8922   TEST_f_f (tan, 0xc.9p-4, 0.9995162902115457818029468900654150261381L);
8923   TEST_f_f (tan, 0xc.908p-4, 0.9997603425502441410973077452249560802034L);
8924   TEST_f_f (tan, 0xc.90cp-4, 0.9998823910588060302788513970802357770031L);
8925   TEST_f_f (tan, 0xc.90ep-4, 0.9999434208994808753305784795924711152508L);
8926   TEST_f_f (tan, 0xc.90fp-4, 0.9999739372166156702433266059635165160515L);
8927   TEST_f_f (tan, 0xc.90f8p-4, 0.9999891957244072765118898375645469865764L);
8928   TEST_f_f (tan, 0xc.90fcp-4, 0.9999968250656122402859679132395522927393L);
8929   TEST_f_f (tan, 0xc.90fdp-4, 0.9999987324100083358016192309006353329444L);
8930   TEST_f_f (tan, 0xc.90fd8p-4, 0.9999996860835706212861509874451585282616L);
8931   TEST_f_f (tan, 0xc.90fdap-4, 0.9999999245021033010474530133665235922808L);
8932   TEST_f_f (tan, 0xc.ap-4, 1.0073556597407272165371804539701396631519L);
8933   TEST_f_f (tan, 0xc.98p-4, 1.0034282930863044654045449407466962736255L);
8934   TEST_f_f (tan, 0xc.94p-4, 1.0014703786820082237342656561856877993328L);
8935   TEST_f_f (tan, 0xc.92p-4, 1.0004928571392300571266638743539017593717L);
8936   TEST_f_f (tan, 0xc.91p-4, 1.0000044544650244953647966900221905361131L);
8937   TEST_f_f (tan, 0xc.90fep-4, 1.0000006397580424009014454926842136804016L);
8938   TEST_f_f (tan, 0xc.90fdcp-4, 1.0000001629206928242190327320047489394217L);
8939   TEST_f_f (tan, 0xc.90fdbp-4, 1.0000000437113909572052640953950483705005L);
8940
8941   TEST_f_f (tan, -0xc.9p-4, -0.9995162902115457818029468900654150261381L);
8942   TEST_f_f (tan, -0xc.908p-4, -0.9997603425502441410973077452249560802034L);
8943   TEST_f_f (tan, -0xc.90cp-4, -0.9998823910588060302788513970802357770031L);
8944   TEST_f_f (tan, -0xc.90ep-4, -0.9999434208994808753305784795924711152508L);
8945   TEST_f_f (tan, -0xc.90fp-4, -0.9999739372166156702433266059635165160515L);
8946   TEST_f_f (tan, -0xc.90f8p-4, -0.9999891957244072765118898375645469865764L);
8947   TEST_f_f (tan, -0xc.90fcp-4, -0.9999968250656122402859679132395522927393L);
8948   TEST_f_f (tan, -0xc.90fdp-4, -0.9999987324100083358016192309006353329444L);
8949   TEST_f_f (tan, -0xc.90fd8p-4, -0.9999996860835706212861509874451585282616L);
8950   TEST_f_f (tan, -0xc.90fdap-4, -0.9999999245021033010474530133665235922808L);
8951   TEST_f_f (tan, -0xc.ap-4, -1.0073556597407272165371804539701396631519L);
8952   TEST_f_f (tan, -0xc.98p-4, -1.0034282930863044654045449407466962736255L);
8953   TEST_f_f (tan, -0xc.94p-4, -1.0014703786820082237342656561856877993328L);
8954   TEST_f_f (tan, -0xc.92p-4, -1.0004928571392300571266638743539017593717L);
8955   TEST_f_f (tan, -0xc.91p-4, -1.0000044544650244953647966900221905361131L);
8956   TEST_f_f (tan, -0xc.90fep-4, -1.0000006397580424009014454926842136804016L);
8957   TEST_f_f (tan, -0xc.90fdcp-4, -1.0000001629206928242190327320047489394217L);
8958   TEST_f_f (tan, -0xc.90fdbp-4, -1.0000000437113909572052640953950483705005L);
8959
8960 #ifndef TEST_FLOAT
8961   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
8962   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
8963 #endif
8964
8965 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8966   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
8967 #endif
8968
8969   END (tan);
8970 }
8971
8972
8973 static void
8974 tan_test_tonearest (void)
8975 {
8976   int save_round_mode;
8977   errno = 0;
8978   FUNC(tan) (0);
8979   if (errno == ENOSYS)
8980     /* Function not implemented.  */
8981     return;
8982
8983   START (tan_tonearest);
8984
8985   save_round_mode = fegetround ();
8986
8987   if (!fesetround (FE_TONEAREST))
8988     {
8989       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
8990       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
8991       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
8992       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
8993       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
8994       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
8995       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
8996       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
8997       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
8998       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
8999     }
9000
9001   fesetround (save_round_mode);
9002
9003   END (tan_tonearest);
9004 }
9005
9006
9007 static void
9008 tan_test_towardzero (void)
9009 {
9010   int save_round_mode;
9011   errno = 0;
9012   FUNC(tan) (0);
9013   if (errno == ENOSYS)
9014     /* Function not implemented.  */
9015     return;
9016
9017   START (tan_towardzero);
9018
9019   save_round_mode = fegetround ();
9020
9021   if (!fesetround (FE_TOWARDZERO))
9022     {
9023       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9024       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9025       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9026       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9027       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9028       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9029       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9030       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9031       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9032       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9033     }
9034
9035   fesetround (save_round_mode);
9036
9037   END (tan_towardzero);
9038 }
9039
9040
9041 static void
9042 tan_test_downward (void)
9043 {
9044   int save_round_mode;
9045   errno = 0;
9046   FUNC(tan) (0);
9047   if (errno == ENOSYS)
9048     /* Function not implemented.  */
9049     return;
9050
9051   START (tan_downward);
9052
9053   save_round_mode = fegetround ();
9054
9055   if (!fesetround (FE_DOWNWARD))
9056     {
9057       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9058       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9059       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9060       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9061       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9062       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9063       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9064       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9065       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9066       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9067     }
9068
9069   fesetround (save_round_mode);
9070
9071   END (tan_downward);
9072 }
9073
9074
9075 static void
9076 tan_test_upward (void)
9077 {
9078   int save_round_mode;
9079   errno = 0;
9080   FUNC(tan) (0);
9081   if (errno == ENOSYS)
9082     /* Function not implemented.  */
9083     return;
9084
9085   START (tan_upward);
9086
9087   save_round_mode = fegetround ();
9088
9089   if (!fesetround (FE_UPWARD))
9090     {
9091       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
9092       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
9093       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
9094       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
9095       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
9096       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
9097       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
9098       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
9099       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
9100       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
9101     }
9102
9103   fesetround (save_round_mode);
9104
9105   END (tan_upward);
9106 }
9107
9108
9109 static void
9110 tanh_test (void)
9111 {
9112   errno = 0;
9113   FUNC(tanh) (0.7L);
9114   if (errno == ENOSYS)
9115     /* Function not implemented.  */
9116     return;
9117
9118   START (tanh);
9119
9120   TEST_f_f (tanh, 0, 0);
9121   TEST_f_f (tanh, minus_zero, minus_zero);
9122
9123 #ifndef TEST_INLINE
9124   TEST_f_f (tanh, plus_infty, 1);
9125   TEST_f_f (tanh, minus_infty, -1);
9126 #endif
9127   TEST_f_f (tanh, nan_value, nan_value);
9128
9129   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
9130   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
9131
9132   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
9133   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
9134
9135   /* 2^-57  */
9136   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
9137
9138   END (tanh);
9139 }
9140
9141 static void
9142 tgamma_test (void)
9143 {
9144   errno = 0;
9145   FUNC(tgamma) (1);
9146   if (errno == ENOSYS)
9147     /* Function not implemented.  */
9148     return;
9149   feclearexcept (FE_ALL_EXCEPT);
9150
9151   START (tgamma);
9152
9153   TEST_f_f (tgamma, plus_infty, plus_infty);
9154   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
9155   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
9156   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
9157   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
9158   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
9159   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
9160   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
9161   TEST_f_f (tgamma, nan_value, nan_value);
9162
9163   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
9164   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
9165
9166   TEST_f_f (tgamma, 1, 1);
9167   TEST_f_f (tgamma, 4, 6);
9168
9169   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
9170   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
9171
9172   END (tgamma);
9173 }
9174
9175
9176 static void
9177 trunc_test (void)
9178 {
9179   START (trunc);
9180
9181   TEST_f_f (trunc, plus_infty, plus_infty);
9182   TEST_f_f (trunc, minus_infty, minus_infty);
9183   TEST_f_f (trunc, nan_value, nan_value);
9184
9185   TEST_f_f (trunc, 0, 0);
9186   TEST_f_f (trunc, minus_zero, minus_zero);
9187   TEST_f_f (trunc, 0.1, 0);
9188   TEST_f_f (trunc, 0.25, 0);
9189   TEST_f_f (trunc, 0.625, 0);
9190   TEST_f_f (trunc, -0.1, minus_zero);
9191   TEST_f_f (trunc, -0.25, minus_zero);
9192   TEST_f_f (trunc, -0.625, minus_zero);
9193   TEST_f_f (trunc, 1, 1);
9194   TEST_f_f (trunc, -1, -1);
9195   TEST_f_f (trunc, 1.625, 1);
9196   TEST_f_f (trunc, -1.625, -1);
9197
9198   TEST_f_f (trunc, 1048580.625L, 1048580L);
9199   TEST_f_f (trunc, -1048580.625L, -1048580L);
9200
9201   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
9202   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
9203
9204   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
9205   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
9206
9207 #ifdef TEST_LDOUBLE
9208   /* The result can only be represented in long double.  */
9209   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
9210   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
9211   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
9212   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
9213   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
9214
9215 # if LDBL_MANT_DIG > 100
9216   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
9217   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
9218   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
9219 # endif
9220
9221   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
9222   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
9223   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
9224   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
9225   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
9226
9227 # if LDBL_MANT_DIG > 100
9228   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
9229   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
9230   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
9231 # endif
9232
9233   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
9234   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
9235   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
9236   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
9237   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
9238
9239 # if LDBL_MANT_DIG > 100
9240   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
9241   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
9242   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
9243   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
9244   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
9245   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
9246 # endif
9247
9248   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
9249   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
9250   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
9251   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
9252   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
9253
9254 # if LDBL_MANT_DIG > 100
9255   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
9256   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
9257   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
9258   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
9259   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
9260   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
9261 # endif
9262
9263   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
9264   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
9265   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
9266   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
9267   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
9268
9269   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
9270   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
9271   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
9272   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
9273   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
9274
9275   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
9276   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
9277   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
9278   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
9279   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
9280 #endif
9281
9282   END (trunc);
9283 }
9284
9285 static void
9286 y0_test (void)
9287 {
9288   FLOAT s, c;
9289   errno = 0;
9290   FUNC (sincos) (0, &s, &c);
9291   if (errno == ENOSYS)
9292     /* Required function not implemented.  */
9293     return;
9294   FUNC(y0) (1);
9295   if (errno == ENOSYS)
9296     /* Function not implemented.  */
9297     return;
9298
9299   /* y0 is the Bessel function of the second kind of order 0 */
9300   START (y0);
9301
9302   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
9303   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
9304   TEST_f_f (y0, 0.0, minus_infty);
9305   TEST_f_f (y0, nan_value, nan_value);
9306   TEST_f_f (y0, plus_infty, 0);
9307
9308   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
9309   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
9310   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
9311   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
9312   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
9313   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
9314   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
9315
9316   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
9317
9318 #ifndef TEST_FLOAT
9319   /* Bug 14155: spurious exception may occur.  */
9320   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L, UNDERFLOW_EXCEPTION_OK);
9321 #endif
9322
9323   END (y0);
9324 }
9325
9326
9327 static void
9328 y1_test (void)
9329 {
9330   FLOAT s, c;
9331   errno = 0;
9332   FUNC (sincos) (0, &s, &c);
9333   if (errno == ENOSYS)
9334     /* Required function not implemented.  */
9335     return;
9336   FUNC(y1) (1);
9337   if (errno == ENOSYS)
9338     /* Function not implemented.  */
9339     return;
9340
9341   /* y1 is the Bessel function of the second kind of order 1 */
9342   START (y1);
9343
9344   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
9345   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
9346   TEST_f_f (y1, 0.0, minus_infty);
9347   TEST_f_f (y1, plus_infty, 0);
9348   TEST_f_f (y1, nan_value, nan_value);
9349
9350   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
9351   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
9352   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
9353   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
9354   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
9355   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
9356   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
9357
9358   /* Bug 14155: spurious exception may occur.  */
9359   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
9360
9361 #ifndef TEST_FLOAT
9362   /* Bug 14155: spurious exception may occur.  */
9363   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L, UNDERFLOW_EXCEPTION_OK);
9364 #endif
9365
9366   END (y1);
9367 }
9368
9369
9370 static void
9371 yn_test (void)
9372 {
9373   FLOAT s, c;
9374   errno = 0;
9375   FUNC (sincos) (0, &s, &c);
9376   if (errno == ENOSYS)
9377     /* Required function not implemented.  */
9378     return;
9379   FUNC(yn) (1, 1);
9380   if (errno == ENOSYS)
9381     /* Function not implemented.  */
9382     return;
9383
9384   /* yn is the Bessel function of the second kind of order n */
9385   START (yn);
9386
9387   /* yn (0, x) == y0 (x)  */
9388   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
9389   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
9390   TEST_ff_f (yn, 0, 0.0, minus_infty);
9391   TEST_ff_f (yn, 0, nan_value, nan_value);
9392   TEST_ff_f (yn, 0, plus_infty, 0);
9393
9394   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
9395   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
9396   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
9397   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
9398   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
9399   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
9400   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
9401
9402   /* yn (1, x) == y1 (x)  */
9403   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
9404   TEST_ff_f (yn, 1, 0.0, minus_infty);
9405   TEST_ff_f (yn, 1, plus_infty, 0);
9406   TEST_ff_f (yn, 1, nan_value, nan_value);
9407
9408   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
9409   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
9410   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
9411   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
9412   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
9413   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
9414   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
9415
9416   /* yn (3, x)  */
9417   TEST_ff_f (yn, 3, plus_infty, 0);
9418   TEST_ff_f (yn, 3, nan_value, nan_value);
9419
9420   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
9421   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
9422   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
9423   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
9424   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
9425
9426   /* yn (10, x)  */
9427   TEST_ff_f (yn, 10, plus_infty, 0);
9428   TEST_ff_f (yn, 10, nan_value, nan_value);
9429
9430   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
9431   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
9432   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
9433   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
9434   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
9435
9436   /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN,
9437      and FLT_MIN.  See Bug 14173.  */
9438   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
9439
9440   errno = 0;
9441   TEST_ff_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION);
9442   check_int ("errno for yn(10,-min) == ERANGE", errno, ERANGE, 0, 0, 0);
9443
9444   END (yn);
9445 }
9446
9447
9448 static void
9449 significand_test (void)
9450 {
9451   /* significand returns the mantissa of the exponential representation.  */
9452   START (significand);
9453
9454   TEST_f_f (significand, 4.0, 1.0);
9455   TEST_f_f (significand, 6.0, 1.5);
9456   TEST_f_f (significand, 8.0, 1.0);
9457
9458   END (significand);
9459 }
9460
9461
9462 static void
9463 initialize (void)
9464 {
9465   fpstack_test ("start *init*");
9466   plus_zero = 0.0;
9467   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
9468
9469   minus_zero = FUNC(copysign) (0.0, -1.0);
9470   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
9471                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
9472   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
9473                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
9474   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
9475                       LDBL_MAX, DBL_MAX, FLT_MAX);
9476   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
9477                       LDBL_MIN, DBL_MIN, FLT_MIN);
9478   min_subnorm_value = CHOOSE (__LDBL_DENORM_MIN__,
9479                               __DBL_DENORM_MIN__,
9480                               __FLT_DENORM_MIN__,
9481                               __LDBL_DENORM_MIN__,
9482                               __DBL_DENORM_MIN__,
9483                               __FLT_DENORM_MIN__);
9484
9485   (void) &plus_zero;
9486   (void) &nan_value;
9487   (void) &minus_zero;
9488   (void) &plus_infty;
9489   (void) &minus_infty;
9490   (void) &max_value;
9491   (void) &min_value;
9492   (void) &min_subnorm_value;
9493
9494   /* Clear all exceptions.  From now on we must not get random exceptions.  */
9495   feclearexcept (FE_ALL_EXCEPT);
9496
9497   /* Test to make sure we start correctly.  */
9498   fpstack_test ("end *init*");
9499 }
9500
9501 /* Definitions of arguments for argp functions.  */
9502 static const struct argp_option options[] =
9503 {
9504   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
9505   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
9506   { "no-max-error", 'f', NULL, 0,
9507     "Don't output maximal errors of functions"},
9508   { "no-points", 'p', NULL, 0,
9509     "Don't output results of functions invocations"},
9510   { "ignore-max-ulp", 'i', "yes/no", 0,
9511     "Ignore given maximal errors"},
9512   { NULL, 0, NULL, 0, NULL }
9513 };
9514
9515 /* Short description of program.  */
9516 static const char doc[] = "Math test suite: " TEST_MSG ;
9517
9518 /* Prototype for option handler.  */
9519 static error_t parse_opt (int key, char *arg, struct argp_state *state);
9520
9521 /* Data structure to communicate with argp functions.  */
9522 static struct argp argp =
9523 {
9524   options, parse_opt, NULL, doc,
9525 };
9526
9527
9528 /* Handle program arguments.  */
9529 static error_t
9530 parse_opt (int key, char *arg, struct argp_state *state)
9531 {
9532   switch (key)
9533     {
9534     case 'f':
9535       output_max_error = 0;
9536       break;
9537     case 'i':
9538       if (strcmp (arg, "yes") == 0)
9539         ignore_max_ulp = 1;
9540       else if (strcmp (arg, "no") == 0)
9541         ignore_max_ulp = 0;
9542       break;
9543     case 'p':
9544       output_points = 0;
9545       break;
9546     case 'u':
9547       output_ulps = 1;
9548       break;
9549     case 'v':
9550       if (optarg)
9551         verbose = (unsigned int) strtoul (optarg, NULL, 0);
9552       else
9553         verbose = 3;
9554       break;
9555     default:
9556       return ARGP_ERR_UNKNOWN;
9557     }
9558   return 0;
9559 }
9560
9561 #if 0
9562 /* function to check our ulp calculation.  */
9563 void
9564 check_ulp (void)
9565 {
9566   int i;
9567
9568   FLOAT u, diff, ulp;
9569   /* This gives one ulp.  */
9570   u = FUNC(nextafter) (10, 20);
9571   check_equal (10.0, u, 1, &diff, &ulp);
9572   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
9573
9574   /* This gives one more ulp.  */
9575   u = FUNC(nextafter) (u, 20);
9576   check_equal (10.0, u, 2, &diff, &ulp);
9577   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
9578
9579   /* And now calculate 100 ulp.  */
9580   for (i = 2; i < 100; i++)
9581     u = FUNC(nextafter) (u, 20);
9582   check_equal (10.0, u, 100, &diff, &ulp);
9583   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
9584 }
9585 #endif
9586
9587 int
9588 main (int argc, char **argv)
9589 {
9590
9591   int remaining;
9592
9593   verbose = 1;
9594   output_ulps = 0;
9595   output_max_error = 1;
9596   output_points = 1;
9597   /* XXX set to 0 for releases.  */
9598   ignore_max_ulp = 0;
9599
9600   /* Parse and process arguments.  */
9601   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
9602
9603   if (remaining != argc)
9604     {
9605       fprintf (stderr, "wrong number of arguments");
9606       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
9607       exit (EXIT_FAILURE);
9608     }
9609
9610   if (output_ulps)
9611     {
9612       ulps_file = fopen ("ULPs", "a");
9613       if (ulps_file == NULL)
9614         {
9615           perror ("can't open file `ULPs' for writing: ");
9616           exit (1);
9617         }
9618     }
9619
9620
9621   initialize ();
9622   printf (TEST_MSG);
9623
9624 #if 0
9625   check_ulp ();
9626 #endif
9627
9628   /* Keep the tests a wee bit ordered (according to ISO C99).  */
9629   /* Classification macros:  */
9630   fpclassify_test ();
9631   isfinite_test ();
9632   isnormal_test ();
9633   signbit_test ();
9634
9635   /* Trigonometric functions:  */
9636   acos_test ();
9637   acos_test_tonearest ();
9638   acos_test_towardzero ();
9639   acos_test_downward ();
9640   acos_test_upward ();
9641   asin_test ();
9642   asin_test_tonearest ();
9643   asin_test_towardzero ();
9644   asin_test_downward ();
9645   asin_test_upward ();
9646   atan_test ();
9647   atan2_test ();
9648   cos_test ();
9649   cos_test_tonearest ();
9650   cos_test_towardzero ();
9651   cos_test_downward ();
9652   cos_test_upward ();
9653   sin_test ();
9654   sin_test_tonearest ();
9655   sin_test_towardzero ();
9656   sin_test_downward ();
9657   sin_test_upward ();
9658   sincos_test ();
9659   tan_test ();
9660   tan_test_tonearest ();
9661   tan_test_towardzero ();
9662   tan_test_downward ();
9663   tan_test_upward ();
9664
9665   /* Hyperbolic functions:  */
9666   acosh_test ();
9667   asinh_test ();
9668   atanh_test ();
9669   cosh_test ();
9670   cosh_test_tonearest ();
9671   cosh_test_towardzero ();
9672   cosh_test_downward ();
9673   cosh_test_upward ();
9674   sinh_test ();
9675   sinh_test_tonearest ();
9676   sinh_test_towardzero ();
9677   sinh_test_downward ();
9678   sinh_test_upward ();
9679   tanh_test ();
9680
9681   /* Exponential and logarithmic functions:  */
9682   exp_test ();
9683   exp_test_tonearest ();
9684   exp_test_towardzero ();
9685   exp_test_downward ();
9686   exp_test_upward ();
9687   exp10_test ();
9688   exp2_test ();
9689   expm1_test ();
9690   frexp_test ();
9691   ldexp_test ();
9692   log_test ();
9693   log10_test ();
9694   log1p_test ();
9695   log2_test ();
9696   logb_test ();
9697   logb_test_downward ();
9698   modf_test ();
9699   ilogb_test ();
9700   scalb_test ();
9701   scalbn_test ();
9702   scalbln_test ();
9703   significand_test ();
9704
9705   /* Power and absolute value functions:  */
9706   cbrt_test ();
9707   fabs_test ();
9708   hypot_test ();
9709   pow_test ();
9710   pow_test_tonearest ();
9711   pow_test_towardzero ();
9712   pow_test_downward ();
9713   pow_test_upward ();
9714   sqrt_test ();
9715
9716   /* Error and gamma functions:  */
9717   erf_test ();
9718   erfc_test ();
9719   gamma_test ();
9720   lgamma_test ();
9721   tgamma_test ();
9722
9723   /* Nearest integer functions:  */
9724   ceil_test ();
9725   floor_test ();
9726   nearbyint_test ();
9727   rint_test ();
9728   rint_test_tonearest ();
9729   rint_test_towardzero ();
9730   rint_test_downward ();
9731   rint_test_upward ();
9732   lrint_test ();
9733   lrint_test_tonearest ();
9734   lrint_test_towardzero ();
9735   lrint_test_downward ();
9736   lrint_test_upward ();
9737   llrint_test ();
9738   llrint_test_tonearest ();
9739   llrint_test_towardzero ();
9740   llrint_test_downward ();
9741   llrint_test_upward ();
9742   round_test ();
9743   lround_test ();
9744   llround_test ();
9745   trunc_test ();
9746
9747   /* Remainder functions:  */
9748   fmod_test ();
9749   remainder_test ();
9750   remquo_test ();
9751
9752   /* Manipulation functions:  */
9753   copysign_test ();
9754   nextafter_test ();
9755   nexttoward_test ();
9756
9757   /* maximum, minimum and positive difference functions */
9758   fdim_test ();
9759   fmax_test ();
9760   fmin_test ();
9761
9762   /* Multiply and add:  */
9763   fma_test ();
9764   fma_test_towardzero ();
9765   fma_test_downward ();
9766   fma_test_upward ();
9767
9768   /* Complex functions:  */
9769   cabs_test ();
9770   cacos_test ();
9771   cacosh_test ();
9772   carg_test ();
9773   casin_test ();
9774   casinh_test ();
9775   catan_test ();
9776   catanh_test ();
9777   ccos_test ();
9778   ccosh_test ();
9779   cexp_test ();
9780   cimag_test ();
9781   clog10_test ();
9782   clog_test ();
9783   conj_test ();
9784   cpow_test ();
9785   cproj_test ();
9786   creal_test ();
9787   csin_test ();
9788   csinh_test ();
9789   csqrt_test ();
9790   ctan_test ();
9791   ctan_test_tonearest ();
9792   ctan_test_towardzero ();
9793   ctan_test_downward ();
9794   ctan_test_upward ();
9795   ctanh_test ();
9796   ctanh_test_tonearest ();
9797   ctanh_test_towardzero ();
9798   ctanh_test_downward ();
9799   ctanh_test_upward ();
9800
9801   /* Bessel functions:  */
9802   j0_test ();
9803   j1_test ();
9804   jn_test ();
9805   y0_test ();
9806   y1_test ();
9807   yn_test ();
9808
9809   if (output_ulps)
9810     fclose (ulps_file);
9811
9812   printf ("\nTest suite completed:\n");
9813   printf ("  %d test cases plus %d tests for exception flags executed.\n",
9814           noTests, noExcTests);
9815   if (noXFails)
9816     printf ("  %d expected failures occurred.\n", noXFails);
9817   if (noXPasses)
9818     printf ("  %d unexpected passes occurred.\n", noXPasses);
9819   if (noErrors)
9820     {
9821       printf ("  %d errors occurred.\n", noErrors);
9822       return 1;
9823     }
9824   printf ("  All tests passed successfully.\n");
9825
9826   return 0;
9827 }
9828
9829 /*
9830  * Local Variables:
9831  * mode:c
9832  * End:
9833  */