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