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   END (clog, complex);
2423 }
2424
2425
2426 static void
2427 clog10_test (void)
2428 {
2429   errno = 0;
2430   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2431   if (errno == ENOSYS)
2432     /* Function not implemented.  */
2433     return;
2434
2435   START (clog10);
2436
2437   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2438   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2439
2440   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2441   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2442
2443   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2444
2445   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2446   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2447
2448   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2449   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2450   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2451   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2452   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2453   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2454   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2455   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2456
2457   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2458   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2459   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2460   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2461
2462   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2463   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2464   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2465   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2466
2467   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2468   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2469
2470   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2471   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2472
2473   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2474   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2475   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2476   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2477
2478   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2479   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2480   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2481   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2482
2483   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2484
2485   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2486   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2487
2488   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2489   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L, UNDERFLOW_EXCEPTION_FLOAT);
2490   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2491   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2492
2493 #ifndef TEST_FLOAT
2494   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2495   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2496   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2497   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2498 #endif
2499
2500 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2501   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2502   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2503   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2504 #endif
2505
2506   END (clog10, complex);
2507 }
2508
2509
2510 static void
2511 conj_test (void)
2512 {
2513   START (conj);
2514   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2515   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2516   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2517   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2518   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2519   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2520   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2521
2522   END (conj, complex);
2523 }
2524
2525
2526 static void
2527 copysign_test (void)
2528 {
2529   START (copysign);
2530
2531   TEST_ff_f (copysign, 0, 4, 0);
2532   TEST_ff_f (copysign, 0, -4, minus_zero);
2533   TEST_ff_f (copysign, minus_zero, 4, 0);
2534   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2535
2536   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2537   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2538   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2539   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2540
2541   TEST_ff_f (copysign, 0, plus_infty, 0);
2542   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2543   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2544   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2545
2546   /* XXX More correctly we would have to check the sign of the NaN.  */
2547   TEST_ff_f (copysign, nan_value, 0, nan_value);
2548   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2549   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2550   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2551
2552   END (copysign);
2553 }
2554
2555
2556 static void
2557 cos_test (void)
2558 {
2559   errno = 0;
2560   FUNC(cos) (0);
2561   if (errno == ENOSYS)
2562     /* Function not implemented.  */
2563     return;
2564
2565   START (cos);
2566
2567   TEST_f_f (cos, 0, 1);
2568   TEST_f_f (cos, minus_zero, 1);
2569   errno = 0;
2570   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2571   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2572   errno = 0;
2573   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2574   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2575   errno = 0;
2576   TEST_f_f (cos, nan_value, nan_value);
2577   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2578
2579   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2580   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2581   TEST_f_f (cos, M_PI_2l, 0);
2582
2583   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2584
2585   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2586   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2587
2588 #ifdef TEST_DOUBLE
2589   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2590 #endif
2591
2592 #ifndef TEST_FLOAT
2593   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2594   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2595 #endif
2596
2597 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2598   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2599 #endif
2600
2601   END (cos);
2602 }
2603
2604
2605 static void
2606 cos_test_tonearest (void)
2607 {
2608   int save_round_mode;
2609   errno = 0;
2610   FUNC(cos) (0);
2611   if (errno == ENOSYS)
2612     /* Function not implemented.  */
2613     return;
2614
2615   START (cos_tonearest);
2616
2617   save_round_mode = fegetround ();
2618
2619   if (!fesetround (FE_TONEAREST))
2620     {
2621       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2622       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2623       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2624       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2625       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2626       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2627       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2628       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2629       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2630       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2631     }
2632
2633   fesetround (save_round_mode);
2634
2635   END (cos_tonearest);
2636 }
2637
2638
2639 static void
2640 cos_test_towardzero (void)
2641 {
2642   int save_round_mode;
2643   errno = 0;
2644   FUNC(cos) (0);
2645   if (errno == ENOSYS)
2646     /* Function not implemented.  */
2647     return;
2648
2649   START (cos_towardzero);
2650
2651   save_round_mode = fegetround ();
2652
2653   if (!fesetround (FE_TOWARDZERO))
2654     {
2655       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2656       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2657       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2658       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2659       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2660       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2661       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2662       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2663       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2664       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2665     }
2666
2667   fesetround (save_round_mode);
2668
2669   END (cos_towardzero);
2670 }
2671
2672
2673 static void
2674 cos_test_downward (void)
2675 {
2676   int save_round_mode;
2677   errno = 0;
2678   FUNC(cos) (0);
2679   if (errno == ENOSYS)
2680     /* Function not implemented.  */
2681     return;
2682
2683   START (cos_downward);
2684
2685   save_round_mode = fegetround ();
2686
2687   if (!fesetround (FE_DOWNWARD))
2688     {
2689       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2690       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2691       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2692       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2693       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2694       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2695       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2696       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2697       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2698       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2699     }
2700
2701   fesetround (save_round_mode);
2702
2703   END (cos_downward);
2704 }
2705
2706
2707 static void
2708 cos_test_upward (void)
2709 {
2710   int save_round_mode;
2711   errno = 0;
2712   FUNC(cos) (0);
2713   if (errno == ENOSYS)
2714     /* Function not implemented.  */
2715     return;
2716
2717   START (cos_upward);
2718
2719   save_round_mode = fegetround ();
2720
2721   if (!fesetround (FE_UPWARD))
2722     {
2723       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2724       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2725       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2726       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2727       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2728       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2729       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2730       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2731       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2732       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2733     }
2734
2735   fesetround (save_round_mode);
2736
2737   END (cos_upward);
2738 }
2739
2740
2741 static void
2742 cosh_test (void)
2743 {
2744   errno = 0;
2745   FUNC(cosh) (0.7L);
2746   if (errno == ENOSYS)
2747     /* Function not implemented.  */
2748     return;
2749
2750   START (cosh);
2751   TEST_f_f (cosh, 0, 1);
2752   TEST_f_f (cosh, minus_zero, 1);
2753
2754 #ifndef TEST_INLINE
2755   TEST_f_f (cosh, plus_infty, plus_infty);
2756   TEST_f_f (cosh, minus_infty, plus_infty);
2757 #endif
2758   TEST_f_f (cosh, nan_value, nan_value);
2759
2760   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2761
2762   END (cosh);
2763 }
2764
2765
2766 static void
2767 cosh_test_tonearest (void)
2768 {
2769   int save_round_mode;
2770   errno = 0;
2771   FUNC(cosh) (0);
2772   if (errno == ENOSYS)
2773     /* Function not implemented.  */
2774     return;
2775
2776   START (cosh_tonearest);
2777
2778   save_round_mode = fegetround ();
2779
2780   if (!fesetround (FE_TONEAREST))
2781     {
2782       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2783       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2784       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2785     }
2786
2787   fesetround (save_round_mode);
2788
2789   END (cosh_tonearest);
2790 }
2791
2792
2793 static void
2794 cosh_test_towardzero (void)
2795 {
2796   int save_round_mode;
2797   errno = 0;
2798   FUNC(cosh) (0);
2799   if (errno == ENOSYS)
2800     /* Function not implemented.  */
2801     return;
2802
2803   START (cosh_towardzero);
2804
2805   save_round_mode = fegetround ();
2806
2807   if (!fesetround (FE_TOWARDZERO))
2808     {
2809       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2810       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2811       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2812     }
2813
2814   fesetround (save_round_mode);
2815
2816   END (cosh_towardzero);
2817 }
2818
2819
2820 static void
2821 cosh_test_downward (void)
2822 {
2823   int save_round_mode;
2824   errno = 0;
2825   FUNC(cosh) (0);
2826   if (errno == ENOSYS)
2827     /* Function not implemented.  */
2828     return;
2829
2830   START (cosh_downward);
2831
2832   save_round_mode = fegetround ();
2833
2834   if (!fesetround (FE_DOWNWARD))
2835     {
2836       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2837       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2838       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2839     }
2840
2841   fesetround (save_round_mode);
2842
2843   END (cosh_downward);
2844 }
2845
2846
2847 static void
2848 cosh_test_upward (void)
2849 {
2850   int save_round_mode;
2851   errno = 0;
2852   FUNC(cosh) (0);
2853   if (errno == ENOSYS)
2854     /* Function not implemented.  */
2855     return;
2856
2857   START (cosh_upward);
2858
2859   save_round_mode = fegetround ();
2860
2861   if (!fesetround (FE_UPWARD))
2862     {
2863       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2864       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2865       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2866     }
2867
2868   fesetround (save_round_mode);
2869
2870   END (cosh_upward);
2871 }
2872
2873
2874 static void
2875 cpow_test (void)
2876 {
2877   errno = 0;
2878   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2879   if (errno == ENOSYS)
2880     /* Function not implemented.  */
2881     return;
2882
2883   START (cpow);
2884
2885   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2886   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2887
2888   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2889   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2890
2891   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2892
2893   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2894   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2895   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2896   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2897
2898   END (cpow, complex);
2899 }
2900
2901
2902 static void
2903 cproj_test (void)
2904 {
2905   START (cproj);
2906   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2907   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2908   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2909   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2910
2911   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2912
2913   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2914   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2915   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2916   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2917
2918   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2919   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
2920
2921   END (cproj, complex);
2922 }
2923
2924
2925 static void
2926 creal_test (void)
2927 {
2928   START (creal);
2929   TEST_c_f (creal, 0.0, 1.0, 0.0);
2930   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2931   TEST_c_f (creal, nan_value, 1.0, nan_value);
2932   TEST_c_f (creal, nan_value, nan_value, nan_value);
2933   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2934   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2935   TEST_c_f (creal, 2.0, 3.0, 2.0);
2936
2937   END (creal);
2938 }
2939
2940 static void
2941 csin_test (void)
2942 {
2943   errno = 0;
2944   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2945   if (errno == ENOSYS)
2946     /* Function not implemented.  */
2947     return;
2948
2949   START (csin);
2950
2951   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2952   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2953   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2954   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2955
2956   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2957   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2958   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2959   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2960
2961   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2962   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2963   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2964   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2965
2966   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2967   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2968   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2969   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2970
2971   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2972   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2973   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2974   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2975
2976   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2977   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2978   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2979   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2980
2981   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2982   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2983
2984   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2985   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2986
2987   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2988   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2989
2990   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2991   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2992
2993   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2994   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2995
2996   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2997   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2998
2999   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
3000
3001   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
3002   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
3003
3004   TEST_c_c (csin, 0.75, 89.5, 2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3005   TEST_c_c (csin, 0.75, -89.5, 2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3006   TEST_c_c (csin, -0.75, 89.5, -2.522786001038096774676288412995370563339e38L, 2.708024460708609732016532185663087200560e38L);
3007   TEST_c_c (csin, -0.75, -89.5, -2.522786001038096774676288412995370563339e38L, -2.708024460708609732016532185663087200560e38L);
3008
3009 #ifndef TEST_FLOAT
3010   TEST_c_c (csin, 0.75, 710.5, 1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3011   TEST_c_c (csin, 0.75, -710.5, 1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3012   TEST_c_c (csin, -0.75, 710.5, -1.255317763348154410745082950806112487736e308L, 1.347490911916428129246890157395342279438e308L);
3013   TEST_c_c (csin, -0.75, -710.5, -1.255317763348154410745082950806112487736e308L, -1.347490911916428129246890157395342279438e308L);
3014 #endif
3015
3016 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3017   TEST_c_c (csin, 0.75, 11357.25, 8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3018   TEST_c_c (csin, 0.75, -11357.25, 8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3019   TEST_c_c (csin, -0.75, 11357.25, -8.385498349388321535962327491346664141020e4931L, 9.001213196851067077465606717616495588201e4931L);
3020   TEST_c_c (csin, -0.75, -11357.25, -8.385498349388321535962327491346664141020e4931L, -9.001213196851067077465606717616495588201e4931L);
3021 #endif
3022
3023 #ifdef TEST_FLOAT
3024   TEST_c_c (csin, 0x1p-149, 180, 1.043535896672617552965983803453927655332e33L, plus_infty, OVERFLOW_EXCEPTION);
3025 #endif
3026
3027 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3028   TEST_c_c (csin, 0x1p-1074, 1440, 5.981479269486130556466515778180916082415e301L, plus_infty, OVERFLOW_EXCEPTION);
3029 #endif
3030
3031 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3032   TEST_c_c (csin, 0x1p-16434L, 22730, 1.217853148905605987081057582351152052687e4924L, plus_infty, OVERFLOW_EXCEPTION);
3033 #endif
3034
3035   END (csin, complex);
3036 }
3037
3038
3039 static void
3040 csinh_test (void)
3041 {
3042   errno = 0;
3043   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
3044   if (errno == ENOSYS)
3045     /* Function not implemented.  */
3046     return;
3047
3048   START (csinh);
3049
3050   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
3051   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
3052   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
3053   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
3054
3055   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3056   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3057   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3058   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3059
3060   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
3061   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
3062   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
3063   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
3064
3065   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3066   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3067   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3068   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
3069
3070   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
3071   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
3072   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
3073   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
3074
3075   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3076   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3077   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3078   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3079
3080   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3081   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
3082
3083   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3084   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
3085
3086   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3087   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3088
3089   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
3090   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
3091
3092   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3093   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3094
3095   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3096   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3097
3098   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
3099
3100   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
3101   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
3102
3103   TEST_c_c (csinh, 89.5, 0.75, 2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3104   TEST_c_c (csinh, -89.5, 0.75, -2.708024460708609732016532185663087200560e38L, 2.522786001038096774676288412995370563339e38L);
3105   TEST_c_c (csinh, 89.5, -0.75, 2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3106   TEST_c_c (csinh, -89.5, -0.75, -2.708024460708609732016532185663087200560e38L, -2.522786001038096774676288412995370563339e38L);
3107
3108 #ifndef TEST_FLOAT
3109   TEST_c_c (csinh, 710.5, 0.75, 1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3110   TEST_c_c (csinh, -710.5, 0.75, -1.347490911916428129246890157395342279438e308L, 1.255317763348154410745082950806112487736e308L);
3111   TEST_c_c (csinh, 710.5, -0.75, 1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3112   TEST_c_c (csinh, -710.5, -0.75, -1.347490911916428129246890157395342279438e308L, -1.255317763348154410745082950806112487736e308L);
3113 #endif
3114
3115 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3116   TEST_c_c (csinh, 11357.25, 0.75, 9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3117   TEST_c_c (csinh, -11357.25, 0.75, -9.001213196851067077465606717616495588201e4931L, 8.385498349388321535962327491346664141020e4931L);
3118   TEST_c_c (csinh, 11357.25, -0.75, 9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3119   TEST_c_c (csinh, -11357.25, -0.75, -9.001213196851067077465606717616495588201e4931L, -8.385498349388321535962327491346664141020e4931L);
3120 #endif
3121
3122 #ifdef TEST_FLOAT
3123   TEST_c_c (csinh, 180, 0x1p-149, plus_infty, 1.043535896672617552965983803453927655332e33L, OVERFLOW_EXCEPTION);
3124 #endif
3125
3126 #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MAX_EXP == 1024)
3127   TEST_c_c (csinh, 1440, 0x1p-1074, plus_infty, 5.981479269486130556466515778180916082415e301L, OVERFLOW_EXCEPTION);
3128 #endif
3129
3130 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3131   TEST_c_c (csinh, 22730, 0x1p-16434L, plus_infty, 1.217853148905605987081057582351152052687e4924L, OVERFLOW_EXCEPTION);
3132 #endif
3133
3134   END (csinh, complex);
3135 }
3136
3137
3138 static void
3139 csqrt_test (void)
3140 {
3141   errno = 0;
3142   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
3143   if (errno == ENOSYS)
3144     /* Function not implemented.  */
3145     return;
3146
3147   START (csqrt);
3148
3149   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
3150   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
3151   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
3152   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
3153
3154   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
3155   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
3156   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
3157   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
3158
3159   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
3160   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
3161   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
3162   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
3163
3164   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
3165   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
3166   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
3167   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
3168   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
3169   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
3170   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
3171   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
3172   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
3173   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
3174   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
3175   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
3176
3177   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
3178
3179   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
3180
3181   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3182   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3183   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3184   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3185
3186   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3187   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3188   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3189   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
3190
3191   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
3192
3193   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
3194   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
3195   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
3196   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
3197   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
3198   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
3199   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
3200   /* Principal square root should be returned (i.e., non-negative real
3201      part).  */
3202   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
3203
3204   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
3205   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
3206   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
3207   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
3208
3209 #ifndef TEST_FLOAT
3210   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
3211   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
3212   /* Bug 14157: spurious exception may occur.  */
3213   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L, UNDERFLOW_EXCEPTION_OK);
3214   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
3215 #endif
3216
3217 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3218   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
3219   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
3220   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
3221 #endif
3222
3223   END (csqrt, complex);
3224 }
3225
3226 static void
3227 ctan_test (void)
3228 {
3229   errno = 0;
3230   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
3231   if (errno == ENOSYS)
3232     /* Function not implemented.  */
3233     return;
3234
3235   START (ctan);
3236
3237   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
3238   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
3239   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
3240   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
3241
3242   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
3243   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
3244   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
3245   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
3246
3247   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
3248   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
3249   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
3250   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
3251
3252   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3253   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3254   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
3255   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
3256   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3257   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3258   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
3259   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
3260
3261   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
3262   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
3263
3264   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
3265   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
3266
3267   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3268   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3269
3270   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3271   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3272   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
3273   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
3274
3275   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
3276
3277   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
3278   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
3279
3280   TEST_c_c (ctan, 1, 45, 1.490158918874345552942703234806348520895e-39L, 1.000000000000000000000000000000000000001L, UNDERFLOW_EXCEPTION_FLOAT);
3281   TEST_c_c (ctan, 1, 47, 2.729321264492904590777293425576722354636e-41L, 1.0, UNDERFLOW_EXCEPTION_FLOAT);
3282
3283 #ifndef TEST_FLOAT
3284   TEST_c_c (ctan, 1, 355, 8.140551093483276762350406321792653551513e-309L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3285   TEST_c_c (ctan, 1, 365, 1.677892637497921890115075995898773550884e-317L, 1.0, UNDERFLOW_EXCEPTION_DOUBLE);
3286 #endif
3287
3288 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3289   TEST_c_c (ctan, 1, 5680, 4.725214596136812019616700920476949798307e-4934L, 1.0, UNDERFLOW_EXCEPTION);
3290   TEST_c_c (ctan, 1, 5690, 9.739393181626937151720816611272607059057e-4943L, 1.0, UNDERFLOW_EXCEPTION);
3291 #endif
3292
3293   TEST_c_c (ctan, 0x3.243f6cp-1, 0, -2.287733242885645987394874673945769518150e7L, 0.0);
3294
3295   TEST_c_c (ctan, 0x1p127, 1, 0.2446359391192790896381501310437708987204L, 0.9101334047676183761532873794426475906201L);
3296
3297 #ifndef TEST_FLOAT
3298   TEST_c_c (ctan, 0x1p1023, 1, -0.2254627924997545057926782581695274244229L, 0.8786063118883068695462540226219865087189L);
3299 #endif
3300
3301 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3302   TEST_c_c (ctan, 0x1p16383L, 1, 0.1608598776370396607204448234354670036772L, 0.8133818522051542536316746743877629761488L);
3303 #endif
3304
3305   TEST_c_c (ctan, 50000, 50000, plus_zero, 1.0, UNDERFLOW_EXCEPTION);
3306   TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION);
3307   TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION);
3308   TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION);
3309
3310   END (ctan, complex);
3311 }
3312
3313
3314 static void
3315 ctanh_test (void)
3316 {
3317   errno = 0;
3318   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
3319   if (errno == ENOSYS)
3320     /* Function not implemented.  */
3321     return;
3322
3323   START (ctanh);
3324
3325   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
3326   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
3327   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
3328   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
3329
3330   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
3331   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
3332   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
3333   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
3334   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
3335   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
3336   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
3337   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
3338
3339   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3340   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3341   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3342   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3343   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3344   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3345   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3346   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3347
3348   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3349   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
3350
3351   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
3352   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
3353
3354   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3355   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
3356
3357   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3358   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3359   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3360   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
3361
3362   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
3363
3364   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
3365
3366   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
3367   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
3368
3369   TEST_c_c (ctanh, 45, 1, 1.000000000000000000000000000000000000001L, 1.490158918874345552942703234806348520895e-39L, UNDERFLOW_EXCEPTION_FLOAT);
3370   TEST_c_c (ctanh, 47, 1, 1.0, 2.729321264492904590777293425576722354636e-41L, UNDERFLOW_EXCEPTION_FLOAT);
3371
3372 #ifndef TEST_FLOAT
3373   TEST_c_c (ctanh, 355, 1, 1.0, 8.140551093483276762350406321792653551513e-309L, UNDERFLOW_EXCEPTION_DOUBLE);
3374   TEST_c_c (ctanh, 365, 1, 1.0, 1.677892637497921890115075995898773550884e-317L, UNDERFLOW_EXCEPTION_DOUBLE);
3375 #endif
3376
3377 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3378   TEST_c_c (ctanh, 5680, 1, 1.0, 4.725214596136812019616700920476949798307e-4934L, UNDERFLOW_EXCEPTION);
3379   TEST_c_c (ctanh, 5690, 1, 1.0, 9.739393181626937151720816611272607059057e-4943L, UNDERFLOW_EXCEPTION);
3380 #endif
3381
3382   TEST_c_c (ctanh, 0, 0x3.243f6cp-1, 0.0, -2.287733242885645987394874673945769518150e7L);
3383
3384   TEST_c_c (ctanh, 1, 0x1p127, 0.9101334047676183761532873794426475906201L, 0.2446359391192790896381501310437708987204L);
3385
3386 #ifndef TEST_FLOAT
3387   TEST_c_c (ctanh, 1, 0x1p1023, 0.8786063118883068695462540226219865087189L, -0.2254627924997545057926782581695274244229L);
3388 #endif
3389
3390 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3391   TEST_c_c (ctanh, 1, 0x1p16383L, 0.8133818522051542536316746743877629761488L, 0.1608598776370396607204448234354670036772L);
3392 #endif
3393
3394   TEST_c_c (ctanh, 50000, 50000, 1.0, plus_zero, UNDERFLOW_EXCEPTION);
3395   TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION);
3396   TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION);
3397   TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION);
3398
3399   END (ctanh, complex);
3400 }
3401
3402
3403 static void
3404 erf_test (void)
3405 {
3406   errno = 0;
3407   FUNC(erf) (0);
3408   if (errno == ENOSYS)
3409     /* Function not implemented.  */
3410     return;
3411
3412   START (erf);
3413
3414   TEST_f_f (erf, 0, 0);
3415   TEST_f_f (erf, minus_zero, minus_zero);
3416   TEST_f_f (erf, plus_infty, 1);
3417   TEST_f_f (erf, minus_infty, -1);
3418   TEST_f_f (erf, nan_value, nan_value);
3419
3420   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
3421   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
3422   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
3423   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
3424   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
3425   TEST_f_f (erf, 27.0L, 1.0L);
3426
3427   END (erf);
3428 }
3429
3430
3431 static void
3432 erfc_test (void)
3433 {
3434   errno = 0;
3435   FUNC(erfc) (0);
3436   if (errno == ENOSYS)
3437     /* Function not implemented.  */
3438     return;
3439
3440   START (erfc);
3441
3442   TEST_f_f (erfc, plus_infty, 0.0);
3443   TEST_f_f (erfc, minus_infty, 2.0);
3444   TEST_f_f (erfc, 0.0, 1.0);
3445   TEST_f_f (erfc, minus_zero, 1.0);
3446   TEST_f_f (erfc, nan_value, nan_value);
3447
3448   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
3449   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
3450   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
3451   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
3452   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
3453   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
3454   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
3455   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
3456 #ifdef TEST_LDOUBLE
3457   /* The result can only be represented in long double.  */
3458 # if LDBL_MIN_10_EXP < -319
3459   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
3460 # endif
3461 # if LDBL_MANT_DIG >= 106
3462   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
3463 # endif
3464 #endif
3465
3466   END (erfc);
3467 }
3468
3469
3470 static void
3471 exp_test (void)
3472 {
3473   errno = 0;
3474   FUNC(exp) (0);
3475   if (errno == ENOSYS)
3476     /* Function not implemented.  */
3477     return;
3478
3479   START (exp);
3480
3481   TEST_f_f (exp, 0, 1);
3482   TEST_f_f (exp, minus_zero, 1);
3483
3484 #ifndef TEST_INLINE
3485   TEST_f_f (exp, plus_infty, plus_infty);
3486   TEST_f_f (exp, minus_infty, 0);
3487 #endif
3488   TEST_f_f (exp, nan_value, nan_value);
3489   TEST_f_f (exp, 1, M_El);
3490
3491   TEST_f_f (exp, 2, M_E2l);
3492   TEST_f_f (exp, 3, M_E3l);
3493   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
3494   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
3495   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
3496 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
3497   /* The result can only be represented in sane long double.  */
3498   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
3499 #endif
3500
3501 #if !(defined TEST_LDOUBLE && LDBL_MAX_EXP > 1024)
3502   TEST_f_f (exp, 710, plus_infty, OVERFLOW_EXCEPTION);
3503   TEST_f_f (exp, -1234, plus_zero, UNDERFLOW_EXCEPTION);
3504 #endif
3505   TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION);
3506   TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION);
3507   TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION);
3508
3509   END (exp);
3510 }
3511
3512
3513 static void
3514 exp_test_tonearest (void)
3515 {
3516   int save_round_mode;
3517   errno = 0;
3518   FUNC(exp) (0);
3519   if (errno == ENOSYS)
3520     /* Function not implemented.  */
3521     return;
3522
3523   START (exp_tonearest);
3524
3525   save_round_mode = fegetround ();
3526
3527   if (!fesetround (FE_TONEAREST))
3528     {
3529       TEST_f_f (exp, 1, M_El);
3530       TEST_f_f (exp, 2, M_E2l);
3531       TEST_f_f (exp, 3, M_E3l);
3532     }
3533
3534   fesetround (save_round_mode);
3535
3536   END (exp_tonearest);
3537 }
3538
3539
3540 static void
3541 exp_test_towardzero (void)
3542 {
3543   int save_round_mode;
3544   errno = 0;
3545   FUNC(exp) (0);
3546   if (errno == ENOSYS)
3547     /* Function not implemented.  */
3548     return;
3549
3550   START (exp_towardzero);
3551
3552   save_round_mode = fegetround ();
3553
3554   if (!fesetround (FE_TOWARDZERO))
3555     {
3556       TEST_f_f (exp, 1, M_El);
3557       TEST_f_f (exp, 2, M_E2l);
3558       TEST_f_f (exp, 3, M_E3l);
3559     }
3560
3561   fesetround (save_round_mode);
3562
3563   END (exp_towardzero);
3564 }
3565
3566
3567 static void
3568 exp_test_downward (void)
3569 {
3570   int save_round_mode;
3571   errno = 0;
3572   FUNC(exp) (0);
3573   if (errno == ENOSYS)
3574     /* Function not implemented.  */
3575     return;
3576
3577   START (exp_downward);
3578
3579   save_round_mode = fegetround ();
3580
3581   if (!fesetround (FE_DOWNWARD))
3582     {
3583       TEST_f_f (exp, 1, M_El);
3584       TEST_f_f (exp, 2, M_E2l);
3585       TEST_f_f (exp, 3, M_E3l);
3586     }
3587
3588   fesetround (save_round_mode);
3589
3590   END (exp_downward);
3591 }
3592
3593
3594 static void
3595 exp_test_upward (void)
3596 {
3597   int save_round_mode;
3598   errno = 0;
3599   FUNC(exp) (0);
3600   if (errno == ENOSYS)
3601     /* Function not implemented.  */
3602     return;
3603
3604   START (exp_upward);
3605
3606   save_round_mode = fegetround ();
3607
3608   if (!fesetround (FE_UPWARD))
3609     {
3610       TEST_f_f (exp, 1, M_El);
3611       TEST_f_f (exp, 2, M_E2l);
3612       TEST_f_f (exp, 3, M_E3l);
3613     }
3614
3615   fesetround (save_round_mode);
3616
3617   END (exp_upward);
3618 }
3619
3620
3621 static void
3622 exp10_test (void)
3623 {
3624   errno = 0;
3625   FUNC(exp10) (0);
3626   if (errno == ENOSYS)
3627     /* Function not implemented.  */
3628     return;
3629
3630   START (exp10);
3631
3632   TEST_f_f (exp10, 0, 1);
3633   TEST_f_f (exp10, minus_zero, 1);
3634
3635   TEST_f_f (exp10, plus_infty, plus_infty);
3636   TEST_f_f (exp10, minus_infty, 0);
3637   TEST_f_f (exp10, nan_value, nan_value);
3638   TEST_f_f (exp10, 3, 1000);
3639   TEST_f_f (exp10, -1, 0.1L);
3640   TEST_f_f (exp10, 36, 1.0e36L);
3641   TEST_f_f (exp10, -36, 1.0e-36L);
3642 #ifndef TEST_FLOAT
3643   TEST_f_f (exp10, 305, 1.0e305L);
3644   TEST_f_f (exp10, -305, 1.0e-305L, UNDERFLOW_EXCEPTION_LDOUBLE_IBM);
3645 #endif
3646 #if defined TEST_LDOUBLE && LDBL_MAX_10_EXP >= 4932
3647   TEST_f_f (exp10, 4932, 1.0e4932L);
3648   TEST_f_f (exp10, -4932, 1.0e-4932L, UNDERFLOW_EXCEPTION);
3649 #endif
3650   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3651   TEST_f_f (exp10, -1e6, 0, UNDERFLOW_EXCEPTION);
3652   TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION);
3653   TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION);
3654   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
3655
3656   END (exp10);
3657 }
3658
3659
3660 static void
3661 exp2_test (void)
3662 {
3663   errno = 0;
3664   FUNC(exp2) (0);
3665   if (errno == ENOSYS)
3666     /* Function not implemented.  */
3667     return;
3668
3669   START (exp2);
3670
3671   TEST_f_f (exp2, 0, 1);
3672   TEST_f_f (exp2, minus_zero, 1);
3673   TEST_f_f (exp2, plus_infty, plus_infty);
3674   TEST_f_f (exp2, minus_infty, 0);
3675   TEST_f_f (exp2, nan_value, nan_value);
3676
3677   TEST_f_f (exp2, 10, 1024);
3678   TEST_f_f (exp2, -1, 0.5);
3679   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3680   TEST_f_f (exp2, -1e6, 0, UNDERFLOW_EXCEPTION);
3681   TEST_f_f (exp2, max_value, plus_infty, OVERFLOW_EXCEPTION);
3682   TEST_f_f (exp2, -max_value, 0, UNDERFLOW_EXCEPTION);
3683   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
3684
3685   TEST_f_f (exp2, 100.5, 1.792728671193156477399422023278661496394e+30L);
3686   TEST_f_f (exp2, 127, 0x1p127);
3687   TEST_f_f (exp2, -149, 0x1p-149);
3688
3689 #ifndef TEST_FLOAT
3690   TEST_f_f (exp2, 1000.25, 1.274245659452564874772384918171765416737e+301L);
3691   TEST_f_f (exp2, 1023, 0x1p1023);
3692   TEST_f_f (exp2, -1074, 0x1p-1074);
3693 #endif
3694
3695 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3696   TEST_f_f (exp2, 16383, 0x1p16383L);
3697   TEST_f_f (exp2, -16400, 0x1p-16400L);
3698 #endif
3699
3700   END (exp2);
3701 }
3702
3703
3704 static void
3705 expm1_test (void)
3706 {
3707   errno = 0;
3708   FUNC(expm1) (0);
3709   if (errno == ENOSYS)
3710     /* Function not implemented.  */
3711     return;
3712
3713   START (expm1);
3714
3715   TEST_f_f (expm1, 0, 0);
3716   TEST_f_f (expm1, minus_zero, minus_zero);
3717
3718 #ifndef TEST_INLINE
3719   TEST_f_f (expm1, plus_infty, plus_infty);
3720   TEST_f_f (expm1, minus_infty, -1);
3721 #endif
3722   TEST_f_f (expm1, nan_value, nan_value);
3723
3724   TEST_f_f (expm1, 1, M_El - 1.0);
3725   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
3726
3727   TEST_f_f (expm1, 50.0L, 5.1847055285870724640864533229334853848275e+21L);
3728
3729 #ifndef TEST_FLOAT
3730   TEST_f_f (expm1, 127.0L, 1.4302079958348104463583671072905261080748e+55L);
3731   TEST_f_f (expm1, 500.0L, 1.4035922178528374107397703328409120821806e+217L);
3732 #endif
3733
3734 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3735   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
3736 #endif
3737
3738   errno = 0;
3739   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION);
3740   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
3741   TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION);
3742   /* Bug 6778: spurious underflow exception.  */
3743   TEST_f_f (expm1, -max_value, -1, UNDERFLOW_EXCEPTION_OK);
3744
3745   END (expm1);
3746 }
3747
3748
3749 static void
3750 fabs_test (void)
3751 {
3752   START (fabs);
3753
3754   TEST_f_f (fabs, 0, 0);
3755   TEST_f_f (fabs, minus_zero, 0);
3756
3757   TEST_f_f (fabs, plus_infty, plus_infty);
3758   TEST_f_f (fabs, minus_infty, plus_infty);
3759   TEST_f_f (fabs, nan_value, nan_value);
3760
3761   TEST_f_f (fabs, 38.0, 38.0);
3762   TEST_f_f (fabs, -M_El, M_El);
3763
3764   END (fabs);
3765 }
3766
3767
3768 static void
3769 fdim_test (void)
3770 {
3771   START (fdim);
3772
3773   TEST_ff_f (fdim, 0, 0, 0);
3774   TEST_ff_f (fdim, 9, 0, 9);
3775   TEST_ff_f (fdim, 0, 9, 0);
3776   TEST_ff_f (fdim, -9, 0, 0);
3777   TEST_ff_f (fdim, 0, -9, 9);
3778
3779   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
3780   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
3781   TEST_ff_f (fdim, minus_infty, 9, 0);
3782   TEST_ff_f (fdim, minus_infty, -9, 0);
3783   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
3784   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
3785   TEST_ff_f (fdim, 9, plus_infty, 0);
3786   TEST_ff_f (fdim, -9, plus_infty, 0);
3787
3788   TEST_ff_f (fdim, 0, nan_value, nan_value);
3789   TEST_ff_f (fdim, 9, nan_value, nan_value);
3790   TEST_ff_f (fdim, -9, nan_value, nan_value);
3791   TEST_ff_f (fdim, nan_value, 9, nan_value);
3792   TEST_ff_f (fdim, nan_value, -9, nan_value);
3793   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
3794   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
3795   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
3796   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
3797   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
3798
3799   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
3800
3801   END (fdim);
3802 }
3803
3804
3805 static void
3806 floor_test (void)
3807 {
3808   START (floor);
3809
3810   TEST_f_f (floor, 0.0, 0.0);
3811   TEST_f_f (floor, minus_zero, minus_zero);
3812   TEST_f_f (floor, plus_infty, plus_infty);
3813   TEST_f_f (floor, minus_infty, minus_infty);
3814   TEST_f_f (floor, nan_value, nan_value);
3815
3816   TEST_f_f (floor, M_PIl, 3.0);
3817   TEST_f_f (floor, -M_PIl, -4.0);
3818
3819   TEST_f_f (floor, 0.1, 0.0);
3820   TEST_f_f (floor, 0.25, 0.0);
3821   TEST_f_f (floor, 0.625, 0.0);
3822   TEST_f_f (floor, -0.1, -1.0);
3823   TEST_f_f (floor, -0.25, -1.0);
3824   TEST_f_f (floor, -0.625, -1.0);
3825
3826 #ifdef TEST_LDOUBLE
3827   /* The result can only be represented in long double.  */
3828   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
3829   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
3830   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
3831   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
3832   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
3833 # if LDBL_MANT_DIG > 100
3834   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
3835   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
3836   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
3837 # endif
3838
3839   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
3840   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
3841   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
3842   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
3843   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
3844 # if LDBL_MANT_DIG > 100
3845   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
3846   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
3847   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
3848 # endif
3849
3850   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
3851   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
3852   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
3853   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
3854   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
3855
3856 # if LDBL_MANT_DIG > 100
3857   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
3858   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
3859   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
3860   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
3861   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
3862   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
3863 # endif
3864
3865   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
3866   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
3867   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
3868   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
3869   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
3870
3871 # if LDBL_MANT_DIG > 100
3872   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
3873   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
3874   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
3875   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
3876   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
3877   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
3878 # endif
3879
3880   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
3881   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
3882   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
3883   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
3884   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
3885
3886   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
3887   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
3888   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
3889   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
3890   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
3891
3892   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
3893   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
3894   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
3895   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
3896   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
3897
3898   TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L);
3899   TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L);
3900 #endif
3901
3902   END (floor);
3903 }
3904
3905
3906 static void
3907 fma_test (void)
3908 {
3909   START (fma);
3910
3911   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
3912   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
3913   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
3914   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3915   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3916   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3917   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3918   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3919   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3920   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3921   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3922   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3923
3924   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3925   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3926   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3927   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3928   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3929   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3930   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3931   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
3932
3933   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
3934
3935   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3936                          LDBL_MAX, DBL_MAX, FLT_MAX);
3937   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
3938   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
3939   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
3940   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
3941   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
3942   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
3943   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
3944   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
3945
3946 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
3947   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
3948   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
3949   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
3950   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
3951   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
3952   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
3953   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
3954 #endif
3955 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
3956   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
3957   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
3958   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
3959   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
3960   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
3961   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
3962   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
3963   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
3964   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
3965   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0, UNDERFLOW_EXCEPTION);
3966   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022, UNDERFLOW_EXCEPTION);
3967   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022, UNDERFLOW_EXCEPTION);
3968   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022, UNDERFLOW_EXCEPTION);
3969   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022, UNDERFLOW_EXCEPTION);
3970   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022, UNDERFLOW_EXCEPTION);
3971   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022, UNDERFLOW_EXCEPTION);
3972   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022, UNDERFLOW_EXCEPTION);
3973   /* Sometimes the FE_UNDERFLOW is not set, so be prepared.  See Bug 14152.  */
3974   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022, UNDERFLOW_EXCEPTION_OK);
3975   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022, UNDERFLOW_EXCEPTION);
3976   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
3977 #endif
3978 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
3979   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
3980   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
3981   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
3982   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
3983   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
3984   /* Bug 14152: underflow exception may be missing.  */
3985   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L, UNDERFLOW_EXCEPTION_OK);
3986 #endif
3987 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
3988   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
3989   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L, UNDERFLOW_EXCEPTION);
3990   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L, UNDERFLOW_EXCEPTION);
3991   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
3992   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
3993   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
3994   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
3995   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
3996   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
3997   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
3998   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
3999   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
4000   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
4001 #endif
4002
4003   END (fma);
4004 }
4005
4006
4007 static void
4008 fmax_test (void)
4009 {
4010   START (fmax);
4011
4012   TEST_ff_f (fmax, 0, 0, 0);
4013   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
4014   TEST_ff_f (fmax, 9, 0, 9);
4015   TEST_ff_f (fmax, 0, 9, 9);
4016   TEST_ff_f (fmax, -9, 0, 0);
4017   TEST_ff_f (fmax, 0, -9, 0);
4018
4019   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
4020   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
4021   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
4022   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
4023
4024   TEST_ff_f (fmax, minus_infty, 9, 9);
4025   TEST_ff_f (fmax, minus_infty, -9, -9);
4026   TEST_ff_f (fmax, 9, minus_infty, 9);
4027   TEST_ff_f (fmax, -9, minus_infty, -9);
4028
4029   TEST_ff_f (fmax, 0, nan_value, 0);
4030   TEST_ff_f (fmax, 9, nan_value, 9);
4031   TEST_ff_f (fmax, -9, nan_value, -9);
4032   TEST_ff_f (fmax, nan_value, 0, 0);
4033   TEST_ff_f (fmax, nan_value, 9, 9);
4034   TEST_ff_f (fmax, nan_value, -9, -9);
4035   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
4036   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
4037   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
4038   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
4039   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
4040
4041   END (fmax);
4042 }
4043
4044
4045 static void
4046 fmin_test (void)
4047 {
4048   START (fmin);
4049
4050   TEST_ff_f (fmin, 0, 0, 0);
4051   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
4052   TEST_ff_f (fmin, 9, 0, 0);
4053   TEST_ff_f (fmin, 0, 9, 0);
4054   TEST_ff_f (fmin, -9, 0, -9);
4055   TEST_ff_f (fmin, 0, -9, -9);
4056
4057   TEST_ff_f (fmin, plus_infty, 9, 9);
4058   TEST_ff_f (fmin, 9, plus_infty, 9);
4059   TEST_ff_f (fmin, plus_infty, -9, -9);
4060   TEST_ff_f (fmin, -9, plus_infty, -9);
4061   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
4062   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
4063   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
4064   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
4065
4066   TEST_ff_f (fmin, 0, nan_value, 0);
4067   TEST_ff_f (fmin, 9, nan_value, 9);
4068   TEST_ff_f (fmin, -9, nan_value, -9);
4069   TEST_ff_f (fmin, nan_value, 0, 0);
4070   TEST_ff_f (fmin, nan_value, 9, 9);
4071   TEST_ff_f (fmin, nan_value, -9, -9);
4072   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
4073   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
4074   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
4075   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
4076   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
4077
4078   END (fmin);
4079 }
4080
4081
4082 static void
4083 fmod_test (void)
4084 {
4085   errno = 0;
4086   FUNC(fmod) (6.5, 2.3L);
4087   if (errno == ENOSYS)
4088     /* Function not implemented.  */
4089     return;
4090
4091   START (fmod);
4092
4093   /* fmod (+0, y) == +0 for y != 0.  */
4094   TEST_ff_f (fmod, 0, 3, 0);
4095
4096   /* fmod (-0, y) == -0 for y != 0.  */
4097   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
4098
4099   /* fmod (+inf, y) == NaN plus invalid exception.  */
4100   errno = 0;
4101   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
4102   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
4103   /* fmod (-inf, y) == NaN plus invalid exception.  */
4104   errno = 0;
4105   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
4106   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
4107   /* fmod (x, +0) == NaN plus invalid exception.  */
4108   errno = 0;
4109   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
4110   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
4111   /* fmod (x, -0) == NaN plus invalid exception.  */
4112   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
4113
4114   /* fmod (x, +inf) == x for x not infinite.  */
4115   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
4116   /* fmod (x, -inf) == x for x not infinite.  */
4117   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
4118
4119   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
4120
4121   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
4122   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
4123   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
4124   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
4125
4126   END (fmod);
4127 }
4128
4129
4130 static void
4131 fpclassify_test (void)
4132 {
4133   START (fpclassify);
4134
4135   TEST_f_i (fpclassify, nan_value, FP_NAN);
4136   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
4137   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
4138   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
4139   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
4140   TEST_f_i (fpclassify, 1000, FP_NORMAL);
4141
4142   END (fpclassify);
4143 }
4144
4145
4146 static void
4147 frexp_test (void)
4148 {
4149   int x;
4150
4151   START (frexp);
4152
4153   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
4154   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
4155   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
4156
4157   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
4158   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
4159
4160   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
4161   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
4162
4163   END (frexp);
4164 }
4165
4166
4167 static void
4168 gamma_test (void)
4169 {
4170   errno = 0;
4171   FUNC(gamma) (1);
4172
4173   if (errno == ENOSYS)
4174     /* Function not implemented.  */
4175     return;
4176   feclearexcept (FE_ALL_EXCEPT);
4177
4178   START (gamma);
4179
4180   TEST_f_f (gamma, plus_infty, plus_infty);
4181   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4182   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4183   TEST_f_f (gamma, minus_infty, plus_infty);
4184   TEST_f_f (gamma, nan_value, nan_value);
4185
4186   TEST_f_f1 (gamma, 1, 0, 1);
4187   TEST_f_f1 (gamma, 3, M_LN2l, 1);
4188
4189   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
4190   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
4191
4192   END (gamma);
4193 }
4194
4195 static void
4196 hypot_test (void)
4197 {
4198   errno = 0;
4199   FUNC(hypot) (0.7L, 12.4L);
4200   if (errno == ENOSYS)
4201     /* Function not implemented.  */
4202     return;
4203
4204   START (hypot);
4205
4206   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
4207   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
4208
4209 #ifndef TEST_INLINE
4210   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
4211   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
4212   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
4213   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
4214 #endif
4215
4216   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
4217
4218   /* hypot (x,y) == hypot (+-x, +-y)  */
4219   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
4220   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
4221   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
4222   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
4223   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
4224   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
4225   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
4226   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
4227
4228   /*  hypot (x,0) == fabs (x)  */
4229   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
4230   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
4231   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
4232
4233   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
4234
4235 #if !(defined TEST_FLOAT && defined TEST_INLINE)
4236   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
4237   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
4238 #endif
4239
4240 #if !defined TEST_FLOAT && !(defined TEST_DOUBLE && defined TEST_INLINE)
4241   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
4242 #endif
4243
4244 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
4245   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
4246 #endif
4247
4248   END (hypot);
4249 }
4250
4251
4252 static void
4253 ilogb_test (void)
4254 {
4255   START (ilogb);
4256
4257   TEST_f_i (ilogb, 1, 0);
4258   TEST_f_i (ilogb, M_El, 1);
4259   TEST_f_i (ilogb, 1024, 10);
4260   TEST_f_i (ilogb, -2000, 10);
4261
4262   /* ilogb (0.0) == FP_ILOGB0 plus invalid exception  */
4263   errno = 0;
4264   TEST_f_i (ilogb, 0.0, FP_ILOGB0, INVALID_EXCEPTION);
4265   check_int ("errno for ilogb(0.0) unchanged", errno, EDOM, 0, 0, 0);
4266   /* ilogb (NaN) == FP_ILOGBNAN plus invalid exception  */
4267   errno = 0;
4268   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, INVALID_EXCEPTION);
4269   check_int ("errno for ilogb(NaN) unchanged", errno, EDOM, 0, 0, 0);
4270   /* ilogb (inf) == INT_MAX plus invalid exception  */
4271   errno = 0;
4272   TEST_f_i (ilogb, plus_infty, INT_MAX, INVALID_EXCEPTION);
4273   check_int ("errno for ilogb(Inf) unchanged", errno, EDOM, 0, 0, 0);
4274   /* ilogb (-inf) == INT_MAX plus invalid exception  */
4275   errno = 0;
4276   TEST_f_i (ilogb, minus_infty, INT_MAX, INVALID_EXCEPTION);
4277   check_int ("errno for ilogb(-Inf) unchanged", errno, EDOM, 0, 0, 0);
4278
4279   END (ilogb);
4280 }
4281
4282 static void
4283 isfinite_test (void)
4284 {
4285   START (isfinite);
4286
4287   TEST_f_b (isfinite, 0, 1);
4288   TEST_f_b (isfinite, minus_zero, 1);
4289   TEST_f_b (isfinite, 10, 1);
4290   TEST_f_b (isfinite, plus_infty, 0);
4291   TEST_f_b (isfinite, minus_infty, 0);
4292   TEST_f_b (isfinite, nan_value, 0);
4293
4294   END (isfinite);
4295 }
4296
4297 static void
4298 isnormal_test (void)
4299 {
4300   START (isnormal);
4301
4302   TEST_f_b (isnormal, 0, 0);
4303   TEST_f_b (isnormal, minus_zero, 0);
4304   TEST_f_b (isnormal, 10, 1);
4305   TEST_f_b (isnormal, plus_infty, 0);
4306   TEST_f_b (isnormal, minus_infty, 0);
4307   TEST_f_b (isnormal, nan_value, 0);
4308
4309   END (isnormal);
4310 }
4311
4312 static void
4313 j0_test (void)
4314 {
4315   FLOAT s, c;
4316   errno = 0;
4317   FUNC (sincos) (0, &s, &c);
4318   if (errno == ENOSYS)
4319     /* Required function not implemented.  */
4320     return;
4321   FUNC(j0) (0);
4322   if (errno == ENOSYS)
4323     /* Function not implemented.  */
4324     return;
4325
4326   START (j0);
4327
4328   /* j0 is the Bessel function of the first kind of order 0 */
4329   TEST_f_f (j0, nan_value, nan_value);
4330   TEST_f_f (j0, plus_infty, 0);
4331   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
4332   TEST_f_f (j0, 0.0, 1.0);
4333   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
4334   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
4335   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
4336   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
4337   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
4338   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
4339   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
4340   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
4341   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
4342
4343   /* Bug 14155: spurious exception may occur.  */
4344   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L, UNDERFLOW_EXCEPTION_OK);
4345
4346 #ifndef TEST_FLOAT
4347   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L);
4348 #endif
4349
4350   END (j0);
4351 }
4352
4353
4354 static void
4355 j1_test (void)
4356 {
4357   FLOAT s, c;
4358   errno = 0;
4359   FUNC (sincos) (0, &s, &c);
4360   if (errno == ENOSYS)
4361     /* Required function not implemented.  */
4362     return;
4363   FUNC(j1) (0);
4364   if (errno == ENOSYS)
4365     /* Function not implemented.  */
4366     return;
4367
4368   /* j1 is the Bessel function of the first kind of order 1 */
4369
4370   START (j1);
4371
4372   TEST_f_f (j1, nan_value, nan_value);
4373   TEST_f_f (j1, plus_infty, 0);
4374
4375   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
4376   TEST_f_f (j1, 0.0, 0.0);
4377   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
4378   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
4379   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
4380   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
4381   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
4382   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
4383   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
4384
4385   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
4386
4387 #ifndef TEST_FLOAT
4388   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
4389 #endif
4390
4391   END (j1);
4392 }
4393
4394 static void
4395 jn_test (void)
4396 {
4397   FLOAT s, c;
4398   errno = 0;
4399   FUNC (sincos) (0, &s, &c);
4400   if (errno == ENOSYS)
4401     /* Required function not implemented.  */
4402     return;
4403   FUNC(jn) (1, 1);
4404   if (errno == ENOSYS)
4405     /* Function not implemented.  */
4406     return;
4407
4408   /* jn is the Bessel function of the first kind of order n.  */
4409   START (jn);
4410
4411   /* jn (0, x) == j0 (x)  */
4412   TEST_ff_f (jn, 0, nan_value, nan_value);
4413   TEST_ff_f (jn, 0, plus_infty, 0);
4414   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
4415   TEST_ff_f (jn, 0, 0.0, 1.0);
4416   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
4417   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
4418   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
4419   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
4420   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
4421   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
4422   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
4423   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
4424   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
4425
4426   /* jn (1, x) == j1 (x)  */
4427   TEST_ff_f (jn, 1, nan_value, nan_value);
4428   TEST_ff_f (jn, 1, plus_infty, 0);
4429   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
4430   TEST_ff_f (jn, 1, 0.0, 0.0);
4431   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
4432   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
4433   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
4434   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
4435   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
4436   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
4437   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
4438
4439   /* jn (3, x)  */
4440   TEST_ff_f (jn, 3, nan_value, nan_value);
4441   TEST_ff_f (jn, 3, plus_infty, 0);
4442
4443   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
4444   TEST_ff_f (jn, 3, 0.0, 0.0);
4445   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
4446   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
4447   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
4448   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
4449   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
4450
4451   /*  jn (10, x)  */
4452   TEST_ff_f (jn, 10, nan_value, nan_value);
4453   TEST_ff_f (jn, 10, plus_infty, 0);
4454
4455   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
4456   TEST_ff_f (jn, 10, 0.0, 0.0);
4457   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
4458   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
4459   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
4460   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
4461   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
4462
4463   /* BZ #11589 .*/
4464   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
4465   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
4466   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
4467   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
4468   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
4469   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
4470   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
4471   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
4472
4473   /* Bug 14155: spurious exception may occur.  */
4474   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK);
4475
4476   END (jn);
4477 }
4478
4479
4480 static void
4481 ldexp_test (void)
4482 {
4483   TEST_ff_f (ldexp, 0, 0, 0);
4484   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
4485
4486   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
4487   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
4488   TEST_ff_f (ldexp, nan_value, 1, nan_value);
4489
4490   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
4491   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
4492
4493   /* ldexp (x, 0) == x.  */
4494   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
4495 }
4496
4497
4498 static void
4499 lgamma_test (void)
4500 {
4501   errno = 0;
4502   FUNC(lgamma) (0);
4503   if (errno == ENOSYS)
4504     /* Function not implemented.  */
4505     return;
4506   feclearexcept (FE_ALL_EXCEPT);
4507
4508   START (lgamma);
4509
4510   TEST_f_f (lgamma, plus_infty, plus_infty);
4511   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4512   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
4513   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4514   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
4515   TEST_f_f (lgamma, nan_value, nan_value);
4516
4517   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
4518   errno = 0;
4519   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4520   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
4521   TEST_f_f (lgamma, minus_infty, plus_infty);
4522   TEST_f_f (lgamma, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4523   TEST_f_f (lgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
4524
4525   TEST_f_f1 (lgamma, 1, 0, 1);
4526
4527   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
4528
4529   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
4530   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
4531   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
4532   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
4533
4534   END (lgamma);
4535 }
4536
4537
4538 static void
4539 lrint_test (void)
4540 {
4541   /* XXX this test is incomplete.  We need to have a way to specifiy
4542      the rounding method and test the critical cases.  So far, only
4543      unproblematic numbers are tested.  */
4544
4545   START (lrint);
4546
4547   TEST_f_l (lrint, 0.0, 0);
4548   TEST_f_l (lrint, minus_zero, 0);
4549   TEST_f_l (lrint, 0.2L, 0);
4550   TEST_f_l (lrint, -0.2L, 0);
4551
4552   TEST_f_l (lrint, 1.4L, 1);
4553   TEST_f_l (lrint, -1.4L, -1);
4554
4555   TEST_f_l (lrint, 8388600.3L, 8388600);
4556   TEST_f_l (lrint, -8388600.3L, -8388600);
4557
4558   TEST_f_l (lrint, 1071930.0008, 1071930);
4559 #ifndef TEST_FLOAT
4560   TEST_f_l (lrint, 1073741824.01, 1073741824);
4561 # if LONG_MAX > 281474976710656
4562   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4563 # endif
4564 #endif
4565
4566   END (lrint);
4567 }
4568
4569
4570 static void
4571 lrint_test_tonearest (void)
4572 {
4573   int save_round_mode;
4574   START (lrint_tonearest);
4575
4576   save_round_mode = fegetround ();
4577
4578   if (!fesetround (FE_TONEAREST))
4579     {
4580       TEST_f_l (lrint, 0.0, 0);
4581       TEST_f_l (lrint, minus_zero, 0);
4582       TEST_f_l (lrint, 0.2L, 0);
4583       TEST_f_l (lrint, -0.2L, 0);
4584       TEST_f_l (lrint, 0.5L, 0);
4585       TEST_f_l (lrint, -0.5L, 0);
4586       TEST_f_l (lrint, 0.8L, 1);
4587       TEST_f_l (lrint, -0.8L, -1);
4588
4589       TEST_f_l (lrint, 1.4L, 1);
4590       TEST_f_l (lrint, -1.4L, -1);
4591
4592       TEST_f_l (lrint, 8388600.3L, 8388600);
4593       TEST_f_l (lrint, -8388600.3L, -8388600);
4594
4595       TEST_f_l (lrint, 1071930.0008, 1071930);
4596 #ifndef TEST_FLOAT
4597       TEST_f_l (lrint, 1073741824.01, 1073741824);
4598 # if LONG_MAX > 281474976710656
4599       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4600 # endif
4601 #endif
4602     }
4603
4604   fesetround (save_round_mode);
4605
4606   END (lrint_tonearest);
4607 }
4608
4609
4610 static void
4611 lrint_test_towardzero (void)
4612 {
4613   int save_round_mode;
4614   START (lrint_towardzero);
4615
4616   save_round_mode = fegetround ();
4617
4618   if (!fesetround (FE_TOWARDZERO))
4619     {
4620       TEST_f_l (lrint, 0.0, 0);
4621       TEST_f_l (lrint, minus_zero, 0);
4622       TEST_f_l (lrint, 0.2L, 0);
4623       TEST_f_l (lrint, -0.2L, 0);
4624       TEST_f_l (lrint, 0.5L, 0);
4625       TEST_f_l (lrint, -0.5L, 0);
4626       TEST_f_l (lrint, 0.8L, 0);
4627       TEST_f_l (lrint, -0.8L, 0);
4628
4629       TEST_f_l (lrint, 1.4L, 1);
4630       TEST_f_l (lrint, -1.4L, -1);
4631
4632       TEST_f_l (lrint, 8388600.3L, 8388600);
4633       TEST_f_l (lrint, -8388600.3L, -8388600);
4634
4635       TEST_f_l (lrint, 1071930.0008, 1071930);
4636 #ifndef TEST_FLOAT
4637       TEST_f_l (lrint, 1073741824.01, 1073741824);
4638 # if LONG_MAX > 281474976710656
4639       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4640 # endif
4641 #endif
4642     }
4643
4644   fesetround (save_round_mode);
4645
4646   END (lrint_towardzero);
4647 }
4648
4649
4650 static void
4651 lrint_test_downward (void)
4652 {
4653   int save_round_mode;
4654   START (lrint_downward);
4655
4656   save_round_mode = fegetround ();
4657
4658   if (!fesetround (FE_DOWNWARD))
4659     {
4660       TEST_f_l (lrint, 0.0, 0);
4661       TEST_f_l (lrint, minus_zero, 0);
4662       TEST_f_l (lrint, 0.2L, 0);
4663       TEST_f_l (lrint, -0.2L, -1);
4664       TEST_f_l (lrint, 0.5L, 0);
4665       TEST_f_l (lrint, -0.5L, -1);
4666       TEST_f_l (lrint, 0.8L, 0);
4667       TEST_f_l (lrint, -0.8L, -1);
4668
4669       TEST_f_l (lrint, 1.4L, 1);
4670       TEST_f_l (lrint, -1.4L, -2);
4671
4672       TEST_f_l (lrint, 8388600.3L, 8388600);
4673       TEST_f_l (lrint, -8388600.3L, -8388601);
4674
4675       TEST_f_l (lrint, 1071930.0008, 1071930);
4676 #ifndef TEST_FLOAT
4677       TEST_f_l (lrint, 1073741824.01, 1073741824);
4678 # if LONG_MAX > 281474976710656
4679       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4680 # endif
4681 #endif
4682     }
4683
4684   fesetround (save_round_mode);
4685
4686   END (lrint_downward);
4687 }
4688
4689
4690 static void
4691 lrint_test_upward (void)
4692 {
4693   int save_round_mode;
4694   START (lrint_upward);
4695
4696   save_round_mode = fegetround ();
4697
4698   if (!fesetround (FE_UPWARD))
4699     {
4700       TEST_f_l (lrint, 0.0, 0);
4701       TEST_f_l (lrint, minus_zero, 0);
4702       TEST_f_l (lrint, 0.2L, 1);
4703       TEST_f_l (lrint, -0.2L, 0);
4704       TEST_f_l (lrint, 0.5L, 1);
4705       TEST_f_l (lrint, -0.5L, 0);
4706       TEST_f_l (lrint, 0.8L, 1);
4707       TEST_f_l (lrint, -0.8L, 0);
4708
4709       TEST_f_l (lrint, 1.4L, 2);
4710       TEST_f_l (lrint, -1.4L, -1);
4711
4712       TEST_f_l (lrint, 8388600.3L, 8388601);
4713       TEST_f_l (lrint, -8388600.3L, -8388600);
4714
4715 #ifndef TEST_FLOAT
4716       TEST_f_l (lrint, 1071930.0008, 1071931);
4717       TEST_f_l (lrint, 1073741824.01, 1073741825);
4718 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
4719       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4720 # endif
4721 #endif
4722     }
4723
4724   fesetround (save_round_mode);
4725
4726   END (lrint_upward);
4727 }
4728
4729
4730 static void
4731 llrint_test (void)
4732 {
4733   /* XXX this test is incomplete.  We need to have a way to specifiy
4734      the rounding method and test the critical cases.  So far, only
4735      unproblematic numbers are tested.  */
4736
4737   START (llrint);
4738
4739   TEST_f_L (llrint, 0.0, 0);
4740   TEST_f_L (llrint, minus_zero, 0);
4741   TEST_f_L (llrint, 0.2L, 0);
4742   TEST_f_L (llrint, -0.2L, 0);
4743
4744   TEST_f_L (llrint, 1.4L, 1);
4745   TEST_f_L (llrint, -1.4L, -1);
4746
4747   TEST_f_L (llrint, 8388600.3L, 8388600);
4748   TEST_f_L (llrint, -8388600.3L, -8388600);
4749
4750   TEST_f_l (llrint, 1071930.0008, 1071930);
4751
4752   /* Test boundary conditions.  */
4753   /* 0x1FFFFF */
4754   TEST_f_L (llrint, 2097151.0,2097151LL);
4755   /* 0x800000 */
4756   TEST_f_L (llrint, 8388608.0, 8388608LL);
4757   /* 0x1000000 */
4758   TEST_f_L (llrint, 16777216.0, 16777216LL);
4759   /* 0x20000000000 */
4760   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4761   /* 0x40000000000 */
4762   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4763   /* 0x1000000000000 */
4764   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4765   /* 0x10000000000000 */
4766   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4767   /* 0x10000080000000 */
4768   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4769   /* 0x20000000000000 */
4770   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4771   /* 0x80000000000000 */
4772   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4773   /* 0x100000000000000 */
4774   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4775 #ifdef TEST_LDOUBLE
4776   /* The input can only be represented in long double.  */
4777   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4778   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4779   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4780   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4781   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4782
4783   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4784   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4785   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4786   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4787   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4788
4789 # if LDBL_MANT_DIG > 100
4790   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4791   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4792   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4793   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4794   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4795   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4796
4797   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4798   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4799   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4800   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4801   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4802   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4803 #endif
4804
4805   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4806   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4807   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4808   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4809   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4810
4811   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4812   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4813   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4814   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4815   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4816
4817 # if LDBL_MANT_DIG > 100
4818   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4819   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4820   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4821   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4822   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4823   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4824
4825   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4826   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4827   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4828   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4829   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4830   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4831 #endif
4832
4833   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4834   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4835   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4836   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4837   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4838
4839   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4840   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4841   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4842   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4843   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4844
4845 # if LDBL_MANT_DIG > 100
4846   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4847   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4848   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4849   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4850   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4851   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4852   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4853   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4854   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4855   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4856   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4857   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4858 # endif
4859 #endif
4860
4861   END (llrint);
4862 }
4863
4864 static void
4865 llrint_test_tonearest (void)
4866 {
4867   int save_round_mode;
4868   START (llrint_tonearest);
4869
4870   save_round_mode = fegetround ();
4871
4872   if (!fesetround (FE_TONEAREST))
4873     {
4874       TEST_f_L (llrint, 0.0, 0);
4875       TEST_f_L (llrint, minus_zero, 0);
4876       TEST_f_L (llrint, 0.2L, 0);
4877       TEST_f_L (llrint, -0.2L, 0);
4878
4879       TEST_f_L (llrint, 1.4L, 1);
4880       TEST_f_L (llrint, -1.4L, -1);
4881
4882       TEST_f_L (llrint, 8388600.3L, 8388600);
4883       TEST_f_L (llrint, -8388600.3L, -8388600);
4884
4885       TEST_f_l (llrint, 1071930.0008, 1071930);
4886
4887       /* Test boundary conditions.  */
4888       /* 0x1FFFFF */
4889       TEST_f_L (llrint, 2097151.0,2097151LL);
4890       /* 0x800000 */
4891       TEST_f_L (llrint, 8388608.0, 8388608LL);
4892       /* 0x1000000 */
4893       TEST_f_L (llrint, 16777216.0, 16777216LL);
4894       /* 0x20000000000 */
4895       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4896       /* 0x40000000000 */
4897       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4898       /* 0x1000000000000 */
4899       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4900       /* 0x10000000000000 */
4901       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4902       /* 0x10000080000000 */
4903       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4904       /* 0x20000000000000 */
4905       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4906       /* 0x80000000000000 */
4907       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4908       /* 0x100000000000000 */
4909       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4910 #ifdef TEST_LDOUBLE
4911       /* The input can only be represented in long double.  */
4912       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4913       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4914       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4915       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4916       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4917
4918       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4919       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4920       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4921       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4922       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4923
4924 # if LDBL_MANT_DIG > 100
4925       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4926       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4927       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4928       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4929       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4930       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4931
4932       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4933       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4934       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4935       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4936       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4937       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4938 #endif
4939
4940       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4941       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4942       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4943       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4944       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4945
4946       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4947       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4948       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4949       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4950       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4951
4952 # if LDBL_MANT_DIG > 100
4953       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4954       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4955       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4956       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4957       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4958       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4959
4960       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4961       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4962       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4963       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4964       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4965       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4966 #endif
4967
4968       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4969       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4970       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4971       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4972       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4973
4974       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4975       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4976       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4977       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4978       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4979
4980 # if LDBL_MANT_DIG > 100
4981       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4982       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4983       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4984       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4985       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4986       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4987       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4988       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4989       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4990       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4991       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4992       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4993 # endif
4994 #endif
4995     }
4996
4997   fesetround (save_round_mode);
4998
4999   END (llrint_tonearest);
5000 }
5001
5002 static void
5003 llrint_test_towardzero (void)
5004 {
5005   int save_round_mode;
5006   START (llrint_towardzero);
5007
5008   save_round_mode = fegetround ();
5009
5010   if (!fesetround (FE_TOWARDZERO))
5011     {
5012       TEST_f_L (llrint, 0.0, 0);
5013       TEST_f_L (llrint, minus_zero, 0);
5014       TEST_f_L (llrint, 0.2L, 0);
5015       TEST_f_L (llrint, -0.2L, 0);
5016
5017       TEST_f_L (llrint, 1.4L, 1);
5018       TEST_f_L (llrint, -1.4L, -1);
5019
5020       TEST_f_L (llrint, 8388600.3L, 8388600);
5021       TEST_f_L (llrint, -8388600.3L, -8388600);
5022
5023       TEST_f_l (llrint, 1071930.0008, 1071930);
5024
5025       /* Test boundary conditions.  */
5026       /* 0x1FFFFF */
5027       TEST_f_L (llrint, 2097151.0,2097151LL);
5028       /* 0x800000 */
5029       TEST_f_L (llrint, 8388608.0, 8388608LL);
5030       /* 0x1000000 */
5031       TEST_f_L (llrint, 16777216.0, 16777216LL);
5032       /* 0x20000000000 */
5033       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5034       /* 0x40000000000 */
5035       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5036       /* 0x1000000000000 */
5037       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5038       /* 0x10000000000000 */
5039       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5040       /* 0x10000080000000 */
5041       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5042       /* 0x20000000000000 */
5043       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5044       /* 0x80000000000000 */
5045       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5046       /* 0x100000000000000 */
5047       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5048 #ifdef TEST_LDOUBLE
5049       /* The input can only be represented in long double.  */
5050       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
5051       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
5052       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
5053       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
5054       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
5055
5056       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
5057       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
5058       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
5059       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
5060       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
5061
5062 # if LDBL_MANT_DIG > 100
5063       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
5064       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
5065       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
5066       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
5067       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
5068       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
5069
5070       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
5071       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
5072       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
5073       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
5074       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
5075       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
5076 #endif
5077
5078       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
5079       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
5080       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
5081       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
5082       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
5083
5084       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
5085       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
5086       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
5087       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
5088       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
5089
5090 # if LDBL_MANT_DIG > 100
5091       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
5092       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
5093       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
5094       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
5095       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
5096       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
5097
5098       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
5099       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
5100       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
5101       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
5102       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
5103       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
5104 #endif
5105
5106       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
5107       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
5108       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
5109       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
5110       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
5111
5112       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
5113       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
5114       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
5115       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
5116       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
5117
5118 # if LDBL_MANT_DIG > 100
5119       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
5120       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
5121       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5122       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5123       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
5124       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
5125       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
5126       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
5127       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
5128       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
5129       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5130       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5131 # endif
5132 #endif
5133     }
5134
5135   fesetround (save_round_mode);
5136
5137   END (llrint_towardzero);
5138 }
5139
5140 static void
5141 llrint_test_downward (void)
5142 {
5143   int save_round_mode;
5144   START (llrint_downward);
5145
5146   save_round_mode = fegetround ();
5147
5148   if (!fesetround (FE_DOWNWARD))
5149     {
5150       TEST_f_L (llrint, 0.0, 0);
5151       TEST_f_L (llrint, minus_zero, 0);
5152       TEST_f_L (llrint, 0.2L, 0);
5153       TEST_f_L (llrint, -0.2L, -1);
5154
5155       TEST_f_L (llrint, 1.4L, 1);
5156       TEST_f_L (llrint, -1.4L, -2);
5157
5158       TEST_f_L (llrint, 8388600.3L, 8388600);
5159       TEST_f_L (llrint, -8388600.3L, -8388601);
5160
5161       TEST_f_l (llrint, 1071930.0008, 1071930);
5162
5163       /* Test boundary conditions.  */
5164       /* 0x1FFFFF */
5165       TEST_f_L (llrint, 2097151.0,2097151LL);
5166       /* 0x800000 */
5167       TEST_f_L (llrint, 8388608.0, 8388608LL);
5168       /* 0x1000000 */
5169       TEST_f_L (llrint, 16777216.0, 16777216LL);
5170       /* 0x20000000000 */
5171       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5172       /* 0x40000000000 */
5173       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5174       /* 0x1000000000000 */
5175       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5176       /* 0x10000000000000 */
5177       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5178       /* 0x10000080000000 */
5179       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5180       /* 0x20000000000000 */
5181       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5182       /* 0x80000000000000 */
5183       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5184       /* 0x100000000000000 */
5185       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5186 #ifdef TEST_LDOUBLE
5187       /* The input can only be represented in long double.  */
5188       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
5189       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
5190       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
5191       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
5192       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
5193
5194       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
5195       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
5196       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
5197       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
5198       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
5199       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
5200
5201       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
5202       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
5203       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
5204       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
5205       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
5206
5207       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
5208       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
5209       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
5210       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
5211       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
5212       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
5213
5214       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
5215       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
5216       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
5217       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
5218       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
5219
5220       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
5221       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
5222       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
5223       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
5224       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
5225       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
5226
5227       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
5228       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
5229       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
5230       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
5231       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
5232
5233       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
5234       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
5235       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
5236       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
5237       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
5238       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
5239
5240       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
5241       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
5242       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
5243       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
5244       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
5245
5246       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
5247       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
5248       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
5249       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
5250       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
5251
5252 # if LDBL_MANT_DIG > 100
5253       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
5254       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
5255       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5256       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5257       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
5258       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
5259       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
5260       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
5261       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
5262       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
5263       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5264       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5265 # endif
5266 #endif
5267     }
5268
5269   fesetround (save_round_mode);
5270
5271   END (llrint_downward);
5272 }
5273
5274 static void
5275 llrint_test_upward (void)
5276 {
5277   int save_round_mode;
5278   START (llrint_upward);
5279
5280   save_round_mode = fegetround ();
5281
5282   if (!fesetround (FE_UPWARD))
5283     {
5284       TEST_f_L (llrint, 0.0, 0);
5285       TEST_f_L (llrint, minus_zero, 0);
5286       TEST_f_L (llrint, 0.2L, 1);
5287       TEST_f_L (llrint, -0.2L, 0);
5288
5289       TEST_f_L (llrint, 1.4L, 2);
5290       TEST_f_L (llrint, -1.4L, -1);
5291
5292       TEST_f_L (llrint, 8388600.3L, 8388601);
5293       TEST_f_L (llrint, -8388600.3L, -8388600);
5294 #ifndef TEST_FLOAT
5295       TEST_f_l (llrint, 1071930.0008, 1071931);
5296 #endif
5297       /* Test boundary conditions.  */
5298       /* 0x1FFFFF */
5299       TEST_f_L (llrint, 2097151.0,2097151LL);
5300       /* 0x800000 */
5301       TEST_f_L (llrint, 8388608.0, 8388608LL);
5302       /* 0x1000000 */
5303       TEST_f_L (llrint, 16777216.0, 16777216LL);
5304       /* 0x20000000000 */
5305       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
5306       /* 0x40000000000 */
5307       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
5308       /* 0x1000000000000 */
5309       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
5310       /* 0x10000000000000 */
5311       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
5312       /* 0x10000080000000 */
5313       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
5314       /* 0x20000000000000 */
5315       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
5316       /* 0x80000000000000 */
5317       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
5318       /* 0x100000000000000 */
5319       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
5320 #ifdef TEST_LDOUBLE
5321       /* The input can only be represented in long double.  */
5322       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
5323       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
5324       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
5325       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
5326       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
5327
5328       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
5329       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
5330       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
5331       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
5332       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
5333       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
5334
5335       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
5336       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
5337       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
5338       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
5339       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
5340
5341       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
5342       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
5343       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
5344       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
5345       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
5346       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
5347
5348       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
5349       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
5350       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
5351       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
5352       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
5353
5354       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
5355       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
5356       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
5357       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
5358       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
5359       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
5360
5361       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
5362       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
5363       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
5364       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
5365       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
5366
5367       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
5368       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
5369       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
5370       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
5371       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
5372       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
5373
5374       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
5375       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
5376       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
5377       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
5378       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
5379
5380       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
5381       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
5382       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
5383       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
5384       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
5385
5386 # if LDBL_MANT_DIG > 100
5387       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
5388       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
5389       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
5390       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
5391       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
5392       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
5393       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
5394       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
5395       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
5396       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
5397       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
5398       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
5399 # endif
5400 #endif
5401     }
5402
5403   fesetround (save_round_mode);
5404
5405   END (llrint_upward);
5406 }
5407
5408
5409 static void
5410 log_test (void)
5411 {
5412   errno = 0;
5413   FUNC(log) (1);
5414   if (errno == ENOSYS)
5415     /* Function not implemented.  */
5416     return;
5417   START (log);
5418
5419   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5420   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5421
5422   TEST_f_f (log, 1, 0);
5423
5424   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
5425   TEST_f_f (log, -max_value, nan_value, INVALID_EXCEPTION);
5426   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
5427   TEST_f_f (log, plus_infty, plus_infty);
5428   TEST_f_f (log, nan_value, nan_value);
5429
5430   TEST_f_f (log, M_El, 1);
5431   TEST_f_f (log, 1.0 / M_El, -1);
5432   TEST_f_f (log, 2, M_LN2l);
5433   TEST_f_f (log, 10, M_LN10l);
5434   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
5435
5436   END (log);
5437 }
5438
5439
5440 static void
5441 log10_test (void)
5442 {
5443   errno = 0;
5444   FUNC(log10) (1);
5445   if (errno == ENOSYS)
5446     /* Function not implemented.  */
5447     return;
5448
5449   START (log10);
5450
5451   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5452   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5453
5454   TEST_f_f (log10, 1, 0);
5455
5456   /* log10 (x) == NaN plus invalid exception if x < 0.  */
5457   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
5458   TEST_f_f (log10, -max_value, nan_value, INVALID_EXCEPTION);
5459   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
5460
5461   TEST_f_f (log10, plus_infty, plus_infty);
5462   TEST_f_f (log10, nan_value, nan_value);
5463
5464   TEST_f_f (log10, 0.1L, -1);
5465   TEST_f_f (log10, 10.0, 1);
5466   TEST_f_f (log10, 100.0, 2);
5467   TEST_f_f (log10, 10000.0, 4);
5468   TEST_f_f (log10, M_El, M_LOG10El);
5469   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
5470
5471   END (log10);
5472 }
5473
5474
5475 static void
5476 log1p_test (void)
5477 {
5478   errno = 0;
5479   FUNC(log1p) (0);
5480   if (errno == ENOSYS)
5481     /* Function not implemented.  */
5482     return;
5483
5484   START (log1p);
5485
5486   TEST_f_f (log1p, 0, 0);
5487   TEST_f_f (log1p, minus_zero, minus_zero);
5488
5489   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5490   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
5491   TEST_f_f (log1p, -max_value, nan_value, INVALID_EXCEPTION);
5492   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
5493
5494   TEST_f_f (log1p, plus_infty, plus_infty);
5495   TEST_f_f (log1p, nan_value, nan_value);
5496
5497   TEST_f_f (log1p, M_El - 1.0, 1);
5498
5499   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
5500   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
5501
5502   END (log1p);
5503 }
5504
5505
5506 static void
5507 log2_test (void)
5508 {
5509   errno = 0;
5510   FUNC(log2) (1);
5511   if (errno == ENOSYS)
5512     /* Function not implemented.  */
5513     return;
5514
5515   START (log2);
5516
5517   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5518   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5519
5520   TEST_f_f (log2, 1, 0);
5521
5522   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
5523   TEST_f_f (log2, -max_value, nan_value, INVALID_EXCEPTION);
5524   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
5525
5526   TEST_f_f (log2, plus_infty, plus_infty);
5527   TEST_f_f (log2, nan_value, nan_value);
5528
5529   TEST_f_f (log2, M_El, M_LOG2El);
5530   TEST_f_f (log2, 2.0, 1);
5531   TEST_f_f (log2, 16.0, 4);
5532   TEST_f_f (log2, 256.0, 8);
5533   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
5534
5535   END (log2);
5536 }
5537
5538
5539 static void
5540 logb_test (void)
5541 {
5542   START (logb);
5543
5544   TEST_f_f (logb, plus_infty, plus_infty);
5545   TEST_f_f (logb, minus_infty, plus_infty);
5546
5547   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5548
5549   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5550   TEST_f_f (logb, nan_value, nan_value);
5551
5552   TEST_f_f (logb, 1, 0);
5553   TEST_f_f (logb, M_El, 1);
5554   TEST_f_f (logb, 1024, 10);
5555   TEST_f_f (logb, -2000, 10);
5556
5557   TEST_f_f (logb, 0x0.1p-127, -131);
5558   TEST_f_f (logb, 0x0.01p-127, -135);
5559   TEST_f_f (logb, 0x0.011p-127, -135);
5560 #ifndef TEST_FLOAT
5561   TEST_f_f (logb, 0x0.8p-1022, -1023);
5562   TEST_f_f (logb, 0x0.1p-1022, -1026);
5563   TEST_f_f (logb, 0x0.00111p-1022, -1034);
5564   TEST_f_f (logb, 0x0.00001p-1022, -1042);
5565   TEST_f_f (logb, 0x0.000011p-1022, -1042);
5566   TEST_f_f (logb, 0x0.0000000000001p-1022, -1074);
5567 #endif
5568 #if defined TEST_LDOUBLE && LDBL_MIN_EXP - LDBL_MANT_DIG <= -16400
5569   TEST_f_f (logb, 0x1p-16400L, -16400);
5570   TEST_f_f (logb, 0x.00000000001p-16382L, -16426);
5571 #endif
5572
5573   END (logb);
5574 }
5575
5576 static void
5577 logb_test_downward (void)
5578 {
5579   int save_round_mode;
5580   errno = 0;
5581
5582   FUNC(logb) (0);
5583   if (errno == ENOSYS)
5584     /* Function not implemented.  */
5585     return;
5586
5587   START (logb_downward);
5588
5589   save_round_mode = fegetround ();
5590
5591   if (!fesetround (FE_DOWNWARD))
5592     {
5593
5594       /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.".  Libm
5595          should not return -0 from logb in any rounding mode.  PowerPC32 has
5596          failed with this test for power4 logb (and logbl on all PowerPC
5597          platforms) in the past due to instruction selection.  GCC PR 52775
5598          provides the availability of the fcfid insn in 32-bit mode which
5599          eliminates the use of fsub in this instance and prevents the negative
5600          signed 0.0.  */
5601
5602       /* BZ #887  */
5603       TEST_f_f (logb, 1.000e+0, plus_zero);
5604     }
5605
5606   fesetround (save_round_mode);
5607
5608   END (logb_downward);
5609 }
5610
5611 static void
5612 lround_test (void)
5613 {
5614   START (lround);
5615
5616   TEST_f_l (lround, 0, 0);
5617   TEST_f_l (lround, minus_zero, 0);
5618   TEST_f_l (lround, 0.2L, 0.0);
5619   TEST_f_l (lround, -0.2L, 0);
5620   TEST_f_l (lround, 0.5, 1);
5621   TEST_f_l (lround, -0.5, -1);
5622   TEST_f_l (lround, 0.8L, 1);
5623   TEST_f_l (lround, -0.8L, -1);
5624   TEST_f_l (lround, 1.5, 2);
5625   TEST_f_l (lround, -1.5, -2);
5626   TEST_f_l (lround, 22514.5, 22515);
5627   TEST_f_l (lround, -22514.5, -22515);
5628   TEST_f_l (lround, 1071930.0008, 1071930);
5629 #ifndef TEST_FLOAT
5630   TEST_f_l (lround, 1073741824.01, 1073741824);
5631 # if LONG_MAX > 281474976710656
5632   TEST_f_l (lround, 281474976710656.025, 281474976710656);
5633   TEST_f_l (lround, 18014398509481974, 18014398509481974);
5634 # endif
5635   TEST_f_l (lround, 2097152.5, 2097153);
5636   TEST_f_l (lround, -2097152.5, -2097153);
5637   /* nextafter(0.5,-1)  */
5638   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
5639   /* nextafter(-0.5,1)  */
5640   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
5641 #else
5642   /* nextafter(0.5,-1)  */
5643   TEST_f_l (lround, 0x1.fffffp-2, 0);
5644   /* nextafter(-0.5,1)  */
5645   TEST_f_l (lround, -0x1.fffffp-2, 0);
5646   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
5647   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
5648 #endif
5649   END (lround);
5650 }
5651
5652
5653 static void
5654 llround_test (void)
5655 {
5656   START (llround);
5657
5658   TEST_f_L (llround, 0, 0);
5659   TEST_f_L (llround, minus_zero, 0);
5660   TEST_f_L (llround, 0.2L, 0.0);
5661   TEST_f_L (llround, -0.2L, 0);
5662   TEST_f_L (llround, 0.5, 1);
5663   TEST_f_L (llround, -0.5, -1);
5664   TEST_f_L (llround, 0.8L, 1);
5665   TEST_f_L (llround, -0.8L, -1);
5666   TEST_f_L (llround, 1.5, 2);
5667   TEST_f_L (llround, -1.5, -2);
5668   TEST_f_L (llround, 22514.5, 22515);
5669   TEST_f_L (llround, -22514.5, -22515);
5670   TEST_f_l (llround, 1071930.0008, 1071930);
5671 #ifndef TEST_FLOAT
5672   TEST_f_L (llround, 2097152.5, 2097153);
5673   TEST_f_L (llround, -2097152.5, -2097153);
5674   TEST_f_L (llround, 34359738368.5, 34359738369ll);
5675   TEST_f_L (llround, -34359738368.5, -34359738369ll);
5676   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
5677 #endif
5678
5679   /* Test boundary conditions.  */
5680   /* 0x1FFFFF */
5681   TEST_f_L (llround, 2097151.0, 2097151LL);
5682   /* 0x800000 */
5683   TEST_f_L (llround, 8388608.0, 8388608LL);
5684   /* 0x1000000 */
5685   TEST_f_L (llround, 16777216.0, 16777216LL);
5686   /* 0x20000000000 */
5687   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
5688   /* 0x40000000000 */
5689   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
5690   /* 0x1000000000000 */
5691   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
5692   /* 0x10000000000000 */
5693   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
5694   /* 0x10000080000000 */
5695   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
5696   /* 0x20000000000000 */
5697   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
5698   /* 0x80000000000000 */
5699   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
5700   /* 0x100000000000000 */
5701   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
5702
5703 #ifndef TEST_FLOAT
5704   /* 0x100000000 */
5705   TEST_f_L (llround, 4294967295.5, 4294967296LL);
5706   /* 0x200000000 */
5707   TEST_f_L (llround, 8589934591.5, 8589934592LL);
5708
5709   /* nextafter(0.5,-1)  */
5710   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
5711   /* nextafter(-0.5,1)  */
5712   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
5713   /* On PowerPC an exponent of '52' is the largest incrementally
5714    * representable sequence of whole-numbers in the 'double' range.  We test
5715    * lround to make sure that a guard bit set during the lround operation
5716    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
5717    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
5718    * rightmost bit set.  */
5719   /* +-(2^52+1)  */
5720   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
5721   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
5722   /* +-(2^53-1): Input is the last (positive and negative) incrementally
5723    * representable whole-number in the 'double' range that might round
5724    * erroneously.  */
5725   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
5726   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
5727 #else
5728   /* nextafter(0.5,-1)  */
5729   TEST_f_L (llround, 0x1.fffffep-2, 0);
5730   /* nextafter(-0.5,1)  */
5731   TEST_f_L (llround, -0x1.fffffep-2, 0);
5732   /* As above, on PowerPC an exponent of '23' is the largest incrementally
5733    * representable sequence of whole-numbers in the 'float' range.
5734    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
5735   TEST_f_L (llround, 0x1.000002p+23,8388609);
5736   TEST_f_L (llround, -0x1.000002p+23,-8388609);
5737   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
5738   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
5739 #endif
5740
5741
5742 #ifdef TEST_LDOUBLE
5743   /* The input can only be represented in long double.  */
5744   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
5745   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
5746   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
5747   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
5748   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
5749
5750 # if LDBL_MANT_DIG > 100
5751   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
5752   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
5753   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
5754   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
5755   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
5756   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
5757
5758   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
5759   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
5760   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
5761   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
5762   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
5763   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
5764 # endif
5765
5766   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
5767   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
5768   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
5769   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
5770   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
5771
5772   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
5773   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
5774   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
5775   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
5776   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
5777
5778 # if LDBL_MANT_DIG > 100
5779   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
5780   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
5781   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
5782   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
5783   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
5784   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
5785
5786   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
5787   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
5788   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
5789   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
5790   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
5791   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
5792 # endif
5793
5794   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
5795   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
5796   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
5797   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
5798   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
5799
5800   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
5801   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
5802   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
5803   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
5804   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
5805
5806   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
5807   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
5808   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
5809   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
5810   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
5811
5812   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
5813   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
5814   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
5815   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
5816   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
5817   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
5818 #endif
5819
5820   END (llround);
5821 }
5822
5823 static void
5824 modf_test (void)
5825 {
5826   FLOAT x;
5827
5828   START (modf);
5829
5830   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
5831   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
5832   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
5833   TEST_fF_f1 (modf, 0, 0, 0);
5834   TEST_fF_f1 (modf, 1.5, 0.5, 1);
5835   TEST_fF_f1 (modf, 2.5, 0.5, 2);
5836   TEST_fF_f1 (modf, -2.5, -0.5, -2);
5837   TEST_fF_f1 (modf, 20, 0, 20);
5838   TEST_fF_f1 (modf, 21, 0, 21);
5839   TEST_fF_f1 (modf, 89.5, 0.5, 89);
5840
5841   END (modf);
5842 }
5843
5844
5845 static void
5846 nearbyint_test (void)
5847 {
5848   START (nearbyint);
5849
5850   TEST_f_f (nearbyint, 0.0, 0.0);
5851   TEST_f_f (nearbyint, minus_zero, minus_zero);
5852   TEST_f_f (nearbyint, plus_infty, plus_infty);
5853   TEST_f_f (nearbyint, minus_infty, minus_infty);
5854   TEST_f_f (nearbyint, nan_value, nan_value);
5855
5856   /* Subnormal values */
5857   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
5858   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
5859
5860   /* Default rounding mode is round to nearest.  */
5861   TEST_f_f (nearbyint, 0.5, 0.0);
5862   TEST_f_f (nearbyint, 1.5, 2.0);
5863   TEST_f_f (nearbyint, -0.5, minus_zero);
5864   TEST_f_f (nearbyint, -1.5, -2.0);
5865
5866   TEST_f_f (nearbyint, 262144.75, 262145.0);
5867   TEST_f_f (nearbyint, 262142.75, 262143.0);
5868   TEST_f_f (nearbyint, 524286.75, 524287.0);
5869   TEST_f_f (nearbyint, 524288.75, 524289.0);
5870
5871   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
5872   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
5873   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
5874   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
5875   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
5876   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
5877   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
5878   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
5879   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
5880   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
5881 #ifndef TEST_FLOAT
5882   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
5883   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
5884   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
5885   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
5886   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
5887   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
5888   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
5889   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
5890   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
5891   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
5892 #endif
5893
5894   END (nearbyint);
5895 }
5896
5897 static void
5898 nextafter_test (void)
5899 {
5900
5901   START (nextafter);
5902
5903   TEST_ff_f (nextafter, 0, 0, 0);
5904   TEST_ff_f (nextafter, minus_zero, 0, 0);
5905   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
5906   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
5907
5908   TEST_ff_f (nextafter, 9, 9, 9);
5909   TEST_ff_f (nextafter, -9, -9, -9);
5910   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
5911   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
5912
5913   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
5914   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
5915   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
5916
5917   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
5918                          LDBL_MAX, DBL_MAX, FLT_MAX);
5919   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
5920   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
5921
5922 #ifdef TEST_LDOUBLE
5923   // XXX Enable once gcc is fixed.
5924   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
5925 #endif
5926
5927   /* XXX We need the hexadecimal FP number representation here for further
5928      tests.  */
5929
5930   END (nextafter);
5931 }
5932
5933
5934 static void
5935 nexttoward_test (void)
5936 {
5937   START (nexttoward);
5938   TEST_ff_f (nexttoward, 0, 0, 0);
5939   TEST_ff_f (nexttoward, minus_zero, 0, 0);
5940   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
5941   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
5942
5943   TEST_ff_f (nexttoward, 9, 9, 9);
5944   TEST_ff_f (nexttoward, -9, -9, -9);
5945   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
5946   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
5947
5948   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
5949   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
5950   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
5951
5952 #ifdef TEST_FLOAT
5953   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.000002p0);
5954   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.000002p0);
5955   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.000002p0);
5956   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.ffffffp0);
5957   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.ffffffp0);
5958   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.ffffffp0);
5959   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.000002p0);
5960   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.000002p0);
5961   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.000002p0);
5962   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.ffffffp0);
5963   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.ffffffp0);
5964   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.ffffffp0);
5965   TEST_ff_f (nexttoward, -0x1.3p-145, -0xap-148L, -0x1.4p-145, UNDERFLOW_EXCEPTION);
5966 # if LDBL_MANT_DIG >= 64
5967   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.000002p0);
5968   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.ffffffp0);
5969   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.000002p0);
5970   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.ffffffp0);
5971 # endif
5972 # if LDBL_MANT_DIG >= 106
5973   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.000002p0);
5974   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.ffffffp0);
5975   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.000002p0);
5976   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.ffffffp0);
5977 # endif
5978 # if LDBL_MANT_DIG >= 113
5979   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.000002p0);
5980   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.ffffffp0);
5981   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.000002p0);
5982   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.ffffffp0);
5983 # endif
5984 #endif
5985 #ifdef TEST_DOUBLE
5986   TEST_ff_f (nexttoward, 1.0, 1.1L, 0x1.0000000000001p0);
5987   TEST_ff_f (nexttoward, 1.0, LDBL_MAX, 0x1.0000000000001p0);
5988   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000001p0, 0x1.0000000000001p0);
5989   TEST_ff_f (nexttoward, 1.0, 0.9L, 0x0.fffffffffffff8p0);
5990   TEST_ff_f (nexttoward, 1.0, -LDBL_MAX, 0x0.fffffffffffff8p0);
5991   TEST_ff_f (nexttoward, 1.0, 0x0.fffffffffffff8p0, 0x0.fffffffffffff8p0);
5992   TEST_ff_f (nexttoward, -1.0, -1.1L, -0x1.0000000000001p0);
5993   TEST_ff_f (nexttoward, -1.0, -LDBL_MAX, -0x1.0000000000001p0);
5994   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000001p0, -0x1.0000000000001p0);
5995   TEST_ff_f (nexttoward, -1.0, -0.9L, -0x0.fffffffffffff8p0);
5996   TEST_ff_f (nexttoward, -1.0, LDBL_MAX, -0x0.fffffffffffff8p0);
5997   TEST_ff_f (nexttoward, -1.0, -0x0.fffffffffffff8p0, -0x0.fffffffffffff8p0);
5998   TEST_ff_f (nexttoward, -1.0, -0x8.00346dc5d6388p-3L, -0x1.0000000000001p0);
5999   TEST_ff_f (nexttoward, 0x1p-1074, 0x1p-1073L, 0x1p-1073, UNDERFLOW_EXCEPTION);
6000 # if LDBL_MANT_DIG >= 64
6001   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000002p0L, 0x1.0000000000001p0);
6002   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffp0L, 0x0.fffffffffffff8p0);
6003   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000002p0L, -0x1.0000000000001p0);
6004   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffp0L, -0x0.fffffffffffff8p0);
6005 # endif
6006 # if LDBL_MANT_DIG >= 106
6007   TEST_ff_f (nexttoward, 1.0, 0x1.000000000000000000000000008p0L, 0x1.0000000000001p0);
6008   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffcp0L, 0x0.fffffffffffff8p0);
6009   TEST_ff_f (nexttoward, -1.0, -0x1.000000000000000000000000008p0L, -0x1.0000000000001p0);
6010   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffcp0L, -0x0.fffffffffffff8p0);
6011 # endif
6012 # if LDBL_MANT_DIG >= 113
6013   TEST_ff_f (nexttoward, 1.0, 0x1.0000000000000000000000000001p0L, 0x1.0000000000001p0);
6014   TEST_ff_f (nexttoward, 1.0, 0x0.ffffffffffffffffffffffffffff8p0L, 0x0.fffffffffffff8p0);
6015   TEST_ff_f (nexttoward, -1.0, -0x1.0000000000000000000000000001p0L, -0x1.0000000000001p0);
6016   TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0);
6017 # endif
6018 #endif
6019
6020   END (nexttoward);
6021 }
6022
6023
6024 static void
6025 pow_test (void)
6026 {
6027
6028   errno = 0;
6029   FUNC(pow) (0, 0);
6030   if (errno == ENOSYS)
6031     /* Function not implemented.  */
6032     return;
6033
6034   START (pow);
6035
6036   TEST_ff_f (pow, 0, 0, 1);
6037   TEST_ff_f (pow, 0, minus_zero, 1);
6038   TEST_ff_f (pow, minus_zero, 0, 1);
6039   TEST_ff_f (pow, minus_zero, minus_zero, 1);
6040
6041   TEST_ff_f (pow, 10, 0, 1);
6042   TEST_ff_f (pow, 10, minus_zero, 1);
6043   TEST_ff_f (pow, -10, 0, 1);
6044   TEST_ff_f (pow, -10, minus_zero, 1);
6045
6046   TEST_ff_f (pow, nan_value, 0, 1);
6047   TEST_ff_f (pow, nan_value, minus_zero, 1);
6048
6049
6050 #ifndef TEST_INLINE
6051   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
6052   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
6053   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
6054   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
6055
6056   TEST_ff_f (pow, 0.9L, plus_infty, 0);
6057   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
6058   TEST_ff_f (pow, -0.9L, plus_infty, 0);
6059   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
6060
6061   TEST_ff_f (pow, 1.1L, minus_infty, 0);
6062   TEST_ff_f (pow, plus_infty, minus_infty, 0);
6063   TEST_ff_f (pow, -1.1L, minus_infty, 0);
6064   TEST_ff_f (pow, minus_infty, minus_infty, 0);
6065
6066   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
6067   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
6068   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
6069   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
6070
6071   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
6072   TEST_ff_f (pow, plus_infty, 1, plus_infty);
6073   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
6074
6075   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
6076   TEST_ff_f (pow, plus_infty, -1, 0);
6077   TEST_ff_f (pow, plus_infty, -1e7L, 0);
6078
6079   TEST_ff_f (pow, minus_infty, 1, minus_infty);
6080   TEST_ff_f (pow, minus_infty, 11, minus_infty);
6081   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
6082
6083   TEST_ff_f (pow, minus_infty, 2, plus_infty);
6084   TEST_ff_f (pow, minus_infty, 12, plus_infty);
6085   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
6086   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
6087   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
6088   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
6089   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
6090
6091   TEST_ff_f (pow, minus_infty, -1, minus_zero);
6092   TEST_ff_f (pow, minus_infty, -11, minus_zero);
6093   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
6094
6095   TEST_ff_f (pow, minus_infty, -2, 0);
6096   TEST_ff_f (pow, minus_infty, -12, 0);
6097   TEST_ff_f (pow, minus_infty, -1002, 0);
6098   TEST_ff_f (pow, minus_infty, -0.1L, 0);
6099   TEST_ff_f (pow, minus_infty, -1.1L, 0);
6100   TEST_ff_f (pow, minus_infty, -11.1L, 0);
6101   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
6102 #endif
6103
6104   TEST_ff_f (pow, nan_value, nan_value, nan_value);
6105   TEST_ff_f (pow, 0, nan_value, nan_value);
6106   TEST_ff_f (pow, 1, nan_value, 1);
6107   TEST_ff_f (pow, -1, nan_value, nan_value);
6108   TEST_ff_f (pow, nan_value, 1, nan_value);
6109   TEST_ff_f (pow, nan_value, -1, nan_value);
6110
6111   /* pow (x, NaN) == NaN.  */
6112   TEST_ff_f (pow, 3.0, nan_value, nan_value);
6113   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
6114   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
6115   TEST_ff_f (pow, -3.0, nan_value, nan_value);
6116   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
6117
6118   TEST_ff_f (pow, nan_value, 3.0, nan_value);
6119   TEST_ff_f (pow, nan_value, -3.0, nan_value);
6120   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
6121   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
6122   TEST_ff_f (pow, nan_value, 2.5, nan_value);
6123   TEST_ff_f (pow, nan_value, -2.5, nan_value);
6124
6125   TEST_ff_f (pow, 1, plus_infty, 1);
6126   TEST_ff_f (pow, -1, plus_infty, 1);
6127   TEST_ff_f (pow, 1, minus_infty, 1);
6128   TEST_ff_f (pow, -1, minus_infty, 1);
6129   TEST_ff_f (pow, 1, 1, 1);
6130   TEST_ff_f (pow, 1, -1, 1);
6131   TEST_ff_f (pow, 1, 1.25, 1);
6132   TEST_ff_f (pow, 1, -1.25, 1);
6133   TEST_ff_f (pow, 1, 0x1p62L, 1);
6134   TEST_ff_f (pow, 1, 0x1p63L, 1);
6135   TEST_ff_f (pow, 1, 0x1p64L, 1);
6136   TEST_ff_f (pow, 1, 0x1p72L, 1);
6137
6138   /* pow (x, +-0) == 1.  */
6139   TEST_ff_f (pow, plus_infty, 0, 1);
6140   TEST_ff_f (pow, plus_infty, minus_zero, 1);
6141   TEST_ff_f (pow, minus_infty, 0, 1);
6142   TEST_ff_f (pow, minus_infty, minus_zero, 1);
6143   TEST_ff_f (pow, 32.75L, 0, 1);
6144   TEST_ff_f (pow, 32.75L, minus_zero, 1);
6145   TEST_ff_f (pow, -32.75L, 0, 1);
6146   TEST_ff_f (pow, -32.75L, minus_zero, 1);
6147   TEST_ff_f (pow, 0x1p72L, 0, 1);
6148   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
6149   TEST_ff_f (pow, 0x1p-72L, 0, 1);
6150   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
6151
6152   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
6153   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
6154   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
6155   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
6156
6157   errno = 0;
6158   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6159   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6160   errno = 0;
6161   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6162   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6163   errno = 0;
6164   TEST_ff_f (pow, 0, -0xffffff, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6165   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6166 #ifndef TEST_FLOAT
6167   errno = 0;
6168   TEST_ff_f (pow, 0, -0x1.fffffffffffffp+52L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6169   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6170 #endif
6171 #ifdef TEST_LDOUBLE
6172 # if LDBL_MANT_DIG >= 64
6173   errno = 0;
6174   TEST_ff_f (pow, 0, -0x1.fffffffffffffffep+63L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6175   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6176 # endif
6177 # if LDBL_MANT_DIG >= 106
6178   errno = 0;
6179   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffff8p+105L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6180   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6181 # endif
6182 # if LDBL_MANT_DIG >= 113
6183   errno = 0;
6184   TEST_ff_f (pow, 0, -0x1.ffffffffffffffffffffffffffffp+112L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6185   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6186 # endif
6187 #endif
6188   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6189   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6190   errno = 0;
6191   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6192   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6193   errno = 0;
6194   TEST_ff_f (pow, minus_zero, -0xffffff, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6195   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6196   errno = 0;
6197   TEST_ff_f (pow, minus_zero, -0x1fffffe, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6198   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6199 #ifndef TEST_FLOAT
6200   errno = 0;
6201   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+52L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6202   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6203   errno = 0;
6204   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffp+53L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6205   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6206 #endif
6207 #ifdef TEST_LDOUBLE
6208 # if LDBL_MANT_DIG >= 64
6209   errno = 0;
6210   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+63L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6211   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6212   errno = 0;
6213   TEST_ff_f (pow, minus_zero, -0x1.fffffffffffffffep+64L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6214   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6215 # endif
6216 # if LDBL_MANT_DIG >= 106
6217   errno = 0;
6218   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6219   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6220   errno = 0;
6221   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6222   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6223 # endif
6224 # if LDBL_MANT_DIG >= 113
6225   errno = 0;
6226   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6227   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
6228   errno = 0;
6229   TEST_ff_f (pow, minus_zero, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6230   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6231 # endif
6232 #endif
6233
6234   errno = 0;
6235   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6236   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6237   errno = 0;
6238   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6239   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6240   errno = 0;
6241   TEST_ff_f (pow, 0, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6242   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6243   errno = 0;
6244   TEST_ff_f (pow, 0, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6245   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6246   errno = 0;
6247   TEST_ff_f (pow, 0, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6248   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6249   errno = 0;
6250   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6251   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
6252   errno = 0;
6253   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6254   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6255   errno = 0;
6256   TEST_ff_f (pow, minus_zero, -0x1p24, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6257   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6258   errno = 0;
6259   TEST_ff_f (pow, minus_zero, -0x1p127, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6260   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6261   errno = 0;
6262   TEST_ff_f (pow, minus_zero, -max_value, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
6263   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
6264
6265   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
6266   TEST_ff_f (pow, 10, -0x1p72L, 0, UNDERFLOW_EXCEPTION);
6267   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
6268   TEST_ff_f (pow, 10, -max_value, 0, UNDERFLOW_EXCEPTION);
6269
6270   TEST_ff_f (pow, 0, 1, 0);
6271   TEST_ff_f (pow, 0, 11, 0);
6272
6273   TEST_ff_f (pow, minus_zero, 1, minus_zero);
6274   TEST_ff_f (pow, minus_zero, 11, minus_zero);
6275
6276   TEST_ff_f (pow, 0, 2, 0);
6277   TEST_ff_f (pow, 0, 11.1L, 0);
6278
6279   TEST_ff_f (pow, minus_zero, 2, 0);
6280   TEST_ff_f (pow, minus_zero, 11.1L, 0);
6281   TEST_ff_f (pow, 0, plus_infty, 0);
6282   TEST_ff_f (pow, minus_zero, plus_infty, 0);
6283
6284 #ifndef TEST_INLINE
6285   /* pow (x, +inf) == +inf for |x| > 1.  */
6286   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
6287
6288   /* pow (x, +inf) == +0 for |x| < 1.  */
6289   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
6290
6291   /* pow (x, -inf) == +0 for |x| > 1.  */
6292   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
6293
6294   /* pow (x, -inf) == +inf for |x| < 1.  */
6295   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
6296 #endif
6297
6298   /* pow (+inf, y) == +inf for y > 0.  */
6299   TEST_ff_f (pow, plus_infty, 2, plus_infty);
6300   TEST_ff_f (pow, plus_infty, 0xffffff, plus_infty);
6301 #ifndef TEST_FLOAT
6302   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffp+52L, plus_infty);
6303 #endif
6304 #ifdef TEST_LDOUBLE
6305 # if LDBL_MANT_DIG >= 64
6306   TEST_ff_f (pow, plus_infty, 0x1.fffffffffffffffep+63L, plus_infty);
6307 # endif
6308 # if LDBL_MANT_DIG >= 106
6309   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, plus_infty);
6310 # endif
6311 # if LDBL_MANT_DIG >= 113
6312   TEST_ff_f (pow, plus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, plus_infty);
6313 # endif
6314 #endif
6315   TEST_ff_f (pow, plus_infty, 0x1p24, plus_infty);
6316   TEST_ff_f (pow, plus_infty, 0x1p127, plus_infty);
6317   TEST_ff_f (pow, plus_infty, max_value, plus_infty);
6318
6319   /* pow (+inf, y) == +0 for y < 0.  */
6320   TEST_ff_f (pow, plus_infty, -1, 0.0);
6321   TEST_ff_f (pow, plus_infty, -0xffffff, 0.0);
6322 #ifndef TEST_FLOAT
6323   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffp+52L, 0.0);
6324 #endif
6325 #ifdef TEST_LDOUBLE
6326 # if LDBL_MANT_DIG >= 64
6327   TEST_ff_f (pow, plus_infty, -0x1.fffffffffffffffep+63L, 0.0);
6328 # endif
6329 # if LDBL_MANT_DIG >= 106
6330   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
6331 # endif
6332 # if LDBL_MANT_DIG >= 113
6333   TEST_ff_f (pow, plus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
6334 # endif
6335 #endif
6336   TEST_ff_f (pow, plus_infty, -0x1p24, 0.0);
6337   TEST_ff_f (pow, plus_infty, -0x1p127, 0.0);
6338   TEST_ff_f (pow, plus_infty, -max_value, 0.0);
6339
6340   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
6341   TEST_ff_f (pow, minus_infty, 27, minus_infty);
6342   TEST_ff_f (pow, minus_infty, 0xffffff, minus_infty);
6343   TEST_ff_f (pow, minus_infty, 0x1fffffe, plus_infty);
6344 #ifndef TEST_FLOAT
6345   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+52L, minus_infty);
6346   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffp+53L, plus_infty);
6347 #endif
6348 #ifdef TEST_LDOUBLE
6349 # if LDBL_MANT_DIG >= 64
6350   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+63L, minus_infty);
6351   TEST_ff_f (pow, minus_infty, 0x1.fffffffffffffffep+64L, plus_infty);
6352 # endif
6353 # if LDBL_MANT_DIG >= 106
6354   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty);
6355   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty);
6356 # endif
6357 # if LDBL_MANT_DIG >= 113
6358   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty);
6359   TEST_ff_f (pow, minus_infty, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty);
6360 # endif
6361 #endif
6362
6363   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
6364   TEST_ff_f (pow, minus_infty, 28, plus_infty);
6365   TEST_ff_f (pow, minus_infty, 0x1p24, plus_infty);
6366   TEST_ff_f (pow, minus_infty, 0x1p127, plus_infty);
6367   TEST_ff_f (pow, minus_infty, max_value, plus_infty);
6368
6369   /* pow (-inf, y) == -0 for y an odd integer < 0. */
6370   TEST_ff_f (pow, minus_infty, -3, minus_zero);
6371   TEST_ff_f (pow, minus_infty, -0xffffff, minus_zero);
6372   TEST_ff_f (pow, minus_infty, -0x1fffffe, plus_zero);
6373 #ifndef TEST_FLOAT
6374   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+52L, minus_zero);
6375   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffp+53L, plus_zero);
6376 #endif
6377 #ifdef TEST_LDOUBLE
6378 # if LDBL_MANT_DIG >= 64
6379   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+63L, minus_zero);
6380   TEST_ff_f (pow, minus_infty, -0x1.fffffffffffffffep+64L, plus_zero);
6381 # endif
6382 # if LDBL_MANT_DIG >= 106
6383   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6384   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6385 # endif
6386 # if LDBL_MANT_DIG >= 113
6387   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6388   TEST_ff_f (pow, minus_infty, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6389 # endif
6390 #endif
6391   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
6392   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
6393   TEST_ff_f (pow, minus_infty, -0x1p24, 0.0);
6394   TEST_ff_f (pow, minus_infty, -0x1p127, 0.0);
6395   TEST_ff_f (pow, minus_infty, -max_value, 0.0);
6396
6397   /* pow (+0, y) == +0 for y an odd integer > 0.  */
6398   TEST_ff_f (pow, 0.0, 27, 0.0);
6399   TEST_ff_f (pow, 0.0, 0xffffff, 0.0);
6400 #ifndef TEST_FLOAT
6401   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffp+52L, 0.0);
6402 #endif
6403 #ifdef TEST_LDOUBLE
6404 # if LDBL_MANT_DIG >= 64
6405   TEST_ff_f (pow, 0.0, 0x1.fffffffffffffffep+63L, 0.0);
6406 # endif
6407 # if LDBL_MANT_DIG >= 106
6408   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffff8p+105L, 0.0);
6409 # endif
6410 # if LDBL_MANT_DIG >= 113
6411   TEST_ff_f (pow, 0.0, 0x1.ffffffffffffffffffffffffffffp+112L, 0.0);
6412 # endif
6413 #endif
6414
6415   /* pow (-0, y) == -0 for y an odd integer > 0.  */
6416   TEST_ff_f (pow, minus_zero, 27, minus_zero);
6417   TEST_ff_f (pow, minus_zero, 0xffffff, minus_zero);
6418   TEST_ff_f (pow, minus_zero, 0x1fffffe, plus_zero);
6419 #ifndef TEST_FLOAT
6420   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+52L, minus_zero);
6421   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffp+53L, plus_zero);
6422 #endif
6423 #ifdef TEST_LDOUBLE
6424 # if LDBL_MANT_DIG >= 64
6425   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+63L, minus_zero);
6426   TEST_ff_f (pow, minus_zero, 0x1.fffffffffffffffep+64L, plus_zero);
6427 # endif
6428 # if LDBL_MANT_DIG >= 106
6429   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero);
6430   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero);
6431 # endif
6432 # if LDBL_MANT_DIG >= 113
6433   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero);
6434   TEST_ff_f (pow, minus_zero, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero);
6435 # endif
6436 #endif
6437
6438   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
6439   TEST_ff_f (pow, 0.0, 4, 0.0);
6440   TEST_ff_f (pow, 0.0, 0x1p24, 0.0);
6441   TEST_ff_f (pow, 0.0, 0x1p127, 0.0);
6442   TEST_ff_f (pow, 0.0, max_value, 0.0);
6443
6444   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
6445   TEST_ff_f (pow, minus_zero, 4, 0.0);
6446   TEST_ff_f (pow, minus_zero, 0x1p24, 0.0);
6447   TEST_ff_f (pow, minus_zero, 0x1p127, 0.0);
6448   TEST_ff_f (pow, minus_zero, max_value, 0.0);
6449
6450   TEST_ff_f (pow, 16, 0.25L, 2);
6451   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
6452   TEST_ff_f (pow, 2, 4, 16);
6453   TEST_ff_f (pow, 256, 8, 0x1p64L);
6454
6455   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
6456
6457 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
6458   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0, UNDERFLOW_EXCEPTION);
6459 #endif
6460
6461   TEST_ff_f (pow, -1.0, -0xffffff, -1.0);
6462   TEST_ff_f (pow, -1.0, -0x1fffffe, 1.0);
6463 #ifndef TEST_FLOAT
6464   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+52L, -1.0);
6465   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffp+53L, 1.0);
6466 #endif
6467 #ifdef TEST_LDOUBLE
6468 # if LDBL_MANT_DIG >= 64
6469   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+63L, -1.0);
6470   TEST_ff_f (pow, -1.0, -0x1.fffffffffffffffep+64L, 1.0);
6471 # endif
6472 # if LDBL_MANT_DIG >= 106
6473   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
6474   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
6475 # endif
6476 # if LDBL_MANT_DIG >= 113
6477   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
6478   TEST_ff_f (pow, -1.0, -0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
6479 # endif
6480 #endif
6481   TEST_ff_f (pow, -1.0, -max_value, 1.0);
6482
6483   TEST_ff_f (pow, -1.0, 0xffffff, -1.0);
6484   TEST_ff_f (pow, -1.0, 0x1fffffe, 1.0);
6485 #ifndef TEST_FLOAT
6486   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+52L, -1.0);
6487   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffp+53L, 1.0);
6488 #endif
6489 #ifdef TEST_LDOUBLE
6490 # if LDBL_MANT_DIG >= 64
6491   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+63L, -1.0);
6492   TEST_ff_f (pow, -1.0, 0x1.fffffffffffffffep+64L, 1.0);
6493 # endif
6494 # if LDBL_MANT_DIG >= 106
6495   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+105L, -1.0);
6496   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffff8p+106L, 1.0);
6497 # endif
6498 # if LDBL_MANT_DIG >= 113
6499   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+112L, -1.0);
6500   TEST_ff_f (pow, -1.0, 0x1.ffffffffffffffffffffffffffffp+113L, 1.0);
6501 # endif
6502 #endif
6503   TEST_ff_f (pow, -1.0, max_value, 1.0);
6504
6505   TEST_ff_f (pow, -2.0, 126, 0x1p126);
6506   TEST_ff_f (pow, -2.0, 127, -0x1p127);
6507   /* Allow inexact results for float to be considered to underflow.  */
6508   TEST_ff_f (pow, -2.0, -126, 0x1p-126, UNDERFLOW_EXCEPTION_OK_FLOAT);
6509   TEST_ff_f (pow, -2.0, -127, -0x1p-127, UNDERFLOW_EXCEPTION_OK_FLOAT);
6510
6511   TEST_ff_f (pow, -2.0, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
6512   TEST_ff_f (pow, -2.0, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
6513 #ifndef TEST_FLOAT
6514   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
6515   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
6516 #endif
6517 #ifdef TEST_LDOUBLE
6518 # if LDBL_MANT_DIG >= 64
6519   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
6520   TEST_ff_f (pow, -2.0, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
6521 # endif
6522 # if LDBL_MANT_DIG >= 106
6523   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
6524   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
6525 # endif
6526 # if LDBL_MANT_DIG >= 113
6527   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
6528   TEST_ff_f (pow, -2.0, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
6529 # endif
6530 #endif
6531   TEST_ff_f (pow, -2.0, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
6532
6533   TEST_ff_f (pow, -2.0, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6534   TEST_ff_f (pow, -2.0, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6535 #ifndef TEST_FLOAT
6536   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6537   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6538 #endif
6539 #ifdef TEST_LDOUBLE
6540 # if LDBL_MANT_DIG >= 64
6541   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6542   TEST_ff_f (pow, -2.0, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6543 # endif
6544 # if LDBL_MANT_DIG >= 106
6545   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6546   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6547 # endif
6548 # if LDBL_MANT_DIG >= 113
6549   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6550   TEST_ff_f (pow, -2.0, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6551 # endif
6552 #endif
6553   TEST_ff_f (pow, -2.0, max_value, plus_infty, OVERFLOW_EXCEPTION);
6554
6555   TEST_ff_f (pow, -max_value, 0.5, nan_value, INVALID_EXCEPTION);
6556   TEST_ff_f (pow, -max_value, 1.5, nan_value, INVALID_EXCEPTION);
6557   TEST_ff_f (pow, -max_value, 1000.5, nan_value, INVALID_EXCEPTION);
6558   TEST_ff_f (pow, -max_value, -2, plus_zero, UNDERFLOW_EXCEPTION);
6559   TEST_ff_f (pow, -max_value, -3, minus_zero, UNDERFLOW_EXCEPTION);
6560   TEST_ff_f (pow, -max_value, 2, plus_infty, OVERFLOW_EXCEPTION);
6561   TEST_ff_f (pow, -max_value, 3, minus_infty, OVERFLOW_EXCEPTION);
6562
6563   TEST_ff_f (pow, -max_value, -0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
6564   TEST_ff_f (pow, -max_value, -0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
6565 #ifndef TEST_FLOAT
6566   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
6567   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
6568 #endif
6569 #ifdef TEST_LDOUBLE
6570 # if LDBL_MANT_DIG >= 64
6571   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
6572   TEST_ff_f (pow, -max_value, -0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
6573 # endif
6574 # if LDBL_MANT_DIG >= 106
6575   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
6576   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
6577 # endif
6578 # if LDBL_MANT_DIG >= 113
6579   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
6580   TEST_ff_f (pow, -max_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
6581 # endif
6582 #endif
6583   TEST_ff_f (pow, -max_value, -max_value, plus_zero, UNDERFLOW_EXCEPTION);
6584
6585   TEST_ff_f (pow, -max_value, 0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6586   TEST_ff_f (pow, -max_value, 0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6587 #ifndef TEST_FLOAT
6588   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6589   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6590 #endif
6591 #ifdef TEST_LDOUBLE
6592 # if LDBL_MANT_DIG >= 64
6593   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6594   TEST_ff_f (pow, -max_value, 0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6595 # endif
6596 # if LDBL_MANT_DIG >= 106
6597   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6598   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6599 # endif
6600 # if LDBL_MANT_DIG >= 113
6601   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6602   TEST_ff_f (pow, -max_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6603 # endif
6604 #endif
6605   TEST_ff_f (pow, -max_value, max_value, plus_infty, OVERFLOW_EXCEPTION);
6606
6607   TEST_ff_f (pow, -0.5, 126, 0x1p-126);
6608   TEST_ff_f (pow, -0.5, 127, -0x1p-127);
6609   TEST_ff_f (pow, -0.5, -126, 0x1p126);
6610   TEST_ff_f (pow, -0.5, -127, -0x1p127);
6611
6612   TEST_ff_f (pow, -0.5, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6613   TEST_ff_f (pow, -0.5, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6614 #ifndef TEST_FLOAT
6615   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6616   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6617 #endif
6618 #ifdef TEST_LDOUBLE
6619 # if LDBL_MANT_DIG >= 64
6620   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6621   TEST_ff_f (pow, -0.5, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6622 # endif
6623 # if LDBL_MANT_DIG >= 106
6624   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6625   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6626 # endif
6627 # if LDBL_MANT_DIG >= 113
6628   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6629   TEST_ff_f (pow, -0.5, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6630 # endif
6631 #endif
6632   TEST_ff_f (pow, -0.5, -max_value, plus_infty, OVERFLOW_EXCEPTION);
6633
6634   TEST_ff_f (pow, -0.5, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
6635   TEST_ff_f (pow, -0.5, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
6636 #ifndef TEST_FLOAT
6637   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
6638   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
6639 #endif
6640 #ifdef TEST_LDOUBLE
6641 # if LDBL_MANT_DIG >= 64
6642   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
6643   TEST_ff_f (pow, -0.5, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
6644 # endif
6645 # if LDBL_MANT_DIG >= 106
6646   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
6647   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
6648 # endif
6649 # if LDBL_MANT_DIG >= 113
6650   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
6651   TEST_ff_f (pow, -0.5, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
6652 # endif
6653 #endif
6654   TEST_ff_f (pow, -0.5, max_value, plus_zero, UNDERFLOW_EXCEPTION);
6655
6656   TEST_ff_f (pow, -min_value, 0.5, nan_value, INVALID_EXCEPTION);
6657   TEST_ff_f (pow, -min_value, 1.5, nan_value, INVALID_EXCEPTION);
6658   TEST_ff_f (pow, -min_value, 1000.5, nan_value, INVALID_EXCEPTION);
6659   TEST_ff_f (pow, -min_value, -2, plus_infty, OVERFLOW_EXCEPTION);
6660   TEST_ff_f (pow, -min_value, -3, minus_infty, OVERFLOW_EXCEPTION);
6661   /* Allow inexact results to be considered to underflow.  */
6662   TEST_ff_f (pow, -min_value, 1, -min_value, UNDERFLOW_EXCEPTION_OK);
6663   TEST_ff_f (pow, -min_value, 2, plus_zero, UNDERFLOW_EXCEPTION);
6664   TEST_ff_f (pow, -min_value, 3, minus_zero, UNDERFLOW_EXCEPTION);
6665
6666   TEST_ff_f (pow, -min_value, -0xffffff, minus_infty, OVERFLOW_EXCEPTION);
6667   TEST_ff_f (pow, -min_value, -0x1fffffe, plus_infty, OVERFLOW_EXCEPTION);
6668 #ifndef TEST_FLOAT
6669   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+52L, minus_infty, OVERFLOW_EXCEPTION);
6670   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffp+53L, plus_infty, OVERFLOW_EXCEPTION);
6671 #endif
6672 #ifdef TEST_LDOUBLE
6673 # if LDBL_MANT_DIG >= 64
6674   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+63L, minus_infty, OVERFLOW_EXCEPTION);
6675   TEST_ff_f (pow, -min_value, -0x1.fffffffffffffffep+64L, plus_infty, OVERFLOW_EXCEPTION);
6676 # endif
6677 # if LDBL_MANT_DIG >= 106
6678   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+105L, minus_infty, OVERFLOW_EXCEPTION);
6679   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffff8p+106L, plus_infty, OVERFLOW_EXCEPTION);
6680 # endif
6681 # if LDBL_MANT_DIG >= 113
6682   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+112L, minus_infty, OVERFLOW_EXCEPTION);
6683   TEST_ff_f (pow, -min_value, -0x1.ffffffffffffffffffffffffffffp+113L, plus_infty, OVERFLOW_EXCEPTION);
6684 # endif
6685 #endif
6686   TEST_ff_f (pow, -min_value, -max_value, plus_infty, OVERFLOW_EXCEPTION);
6687
6688   TEST_ff_f (pow, -min_value, 0xffffff, minus_zero, UNDERFLOW_EXCEPTION);
6689   TEST_ff_f (pow, -min_value, 0x1fffffe, plus_zero, UNDERFLOW_EXCEPTION);
6690 #ifndef TEST_FLOAT
6691   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+52L, minus_zero, UNDERFLOW_EXCEPTION);
6692   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffp+53L, plus_zero, UNDERFLOW_EXCEPTION);
6693 #endif
6694 #ifdef TEST_LDOUBLE
6695 # if LDBL_MANT_DIG >= 64
6696   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+63L, minus_zero, UNDERFLOW_EXCEPTION);
6697   TEST_ff_f (pow, -min_value, 0x1.fffffffffffffffep+64L, plus_zero, UNDERFLOW_EXCEPTION);
6698 # endif
6699 # if LDBL_MANT_DIG >= 106
6700   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+105L, minus_zero, UNDERFLOW_EXCEPTION);
6701   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffff8p+106L, plus_zero, UNDERFLOW_EXCEPTION);
6702 # endif
6703 # if LDBL_MANT_DIG >= 113
6704   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+112L, minus_zero, UNDERFLOW_EXCEPTION);
6705   TEST_ff_f (pow, -min_value, 0x1.ffffffffffffffffffffffffffffp+113L, plus_zero, UNDERFLOW_EXCEPTION);
6706 # endif
6707 #endif
6708   TEST_ff_f (pow, -min_value, max_value, plus_zero, UNDERFLOW_EXCEPTION);
6709
6710 #ifndef TEST_LDOUBLE /* Bug 13881.  */
6711   TEST_ff_f (pow, 0x0.ffffffp0, 10, 0.999999403953712118183885036774764444747L);
6712   TEST_ff_f (pow, 0x0.ffffffp0, 100, 0.999994039553108359406305079606228341585L);
6713   TEST_ff_f (pow, 0x0.ffffffp0, 1000, 0.9999403971297699052276650144650733772182L);
6714   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p24, 0.3678794302077803437135155590023422899744L);
6715   TEST_ff_f (pow, 0x0.ffffffp0, 0x1p30, 1.603807831524924233828134753069728224044e-28L);
6716   TEST_ff_f (pow, 0x0.ffffffp0, 0x1.234566p30, 2.374884712135295099971443365381007297732e-32L);
6717   TEST_ff_f (pow, 0x0.ffffffp0, -10, 1.000000596046643153205170848674671339688L);
6718   TEST_ff_f (pow, 0x0.ffffffp0, -100, 1.000005960482418779499387594989252621451L);
6719   TEST_ff_f (pow, 0x0.ffffffp0, -1000, 1.000059606422943986382898964231519867906L);
6720   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p24, 2.7182819094701610539628664526874952929416L);
6721   TEST_ff_f (pow, 0x0.ffffffp0, -0x1p30, 6.2351609734265057988914412331288163636075e+27L);
6722   TEST_ff_f (pow, 0x0.ffffffp0, -0x1.234566p30, 4.2107307141696353498921307077142537353515e+31L);
6723   TEST_ff_f (pow, 0x1.000002p0, 0x1p24, 7.3890552180866447284268641248075832310141L);
6724   TEST_ff_f (pow, 0x1.000002p0, 0x1.234566p29, 4.2107033006507495188536371520637025716256e+31L);
6725   TEST_ff_f (pow, 0x1.000002p0, -0x1.234566p29, 2.3749001736727769098946062325205705312166e-32L);
6726 #endif
6727
6728   /* Bug 13881: powl inaccurate so these tests disabled for long double.  */
6729 #if !defined TEST_FLOAT && !defined TEST_LDOUBLE
6730   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, 0x1.23456789abcdfp62L, 1.0118762747827252817436395051178295138220e-253L);
6731   TEST_ff_f (pow, 0x0.fffffffffffff8p0L, -0x1.23456789abcdfp62L, 9.8826311568054561811190162420900667121992e+252L);
6732   TEST_ff_f (pow, 0x1.0000000000001p0L, 0x1.23456789abcdfp61L, 9.8826311568044974397135026217687399395481e+252L);
6733   TEST_ff_f (pow, 0x1.0000000000001p0L, -0x1.23456789abcdfp61L, 1.0118762747828234466621210689458255908670e-253L);
6734 #endif
6735
6736   TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION);
6737
6738   END (pow);
6739 }
6740
6741
6742 static void
6743 pow_test_tonearest (void)
6744 {
6745   int save_round_mode;
6746   errno = 0;
6747   FUNC(pow) (0, 0);
6748   if (errno == ENOSYS)
6749     /* Function not implemented.  */
6750     return;
6751
6752   START (pow_tonearest);
6753
6754   save_round_mode = fegetround ();
6755
6756   if (!fesetround (FE_TONEAREST))
6757     {
6758       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6759       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6760     }
6761
6762   fesetround (save_round_mode);
6763
6764   END (pow_tonearest);
6765 }
6766
6767
6768 static void
6769 pow_test_towardzero (void)
6770 {
6771   int save_round_mode;
6772   errno = 0;
6773   FUNC(pow) (0, 0);
6774   if (errno == ENOSYS)
6775     /* Function not implemented.  */
6776     return;
6777
6778   START (pow_towardzero);
6779
6780   save_round_mode = fegetround ();
6781
6782   if (!fesetround (FE_TOWARDZERO))
6783     {
6784       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6785       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6786     }
6787
6788   fesetround (save_round_mode);
6789
6790   END (pow_towardzero);
6791 }
6792
6793
6794 static void
6795 pow_test_downward (void)
6796 {
6797   int save_round_mode;
6798   errno = 0;
6799   FUNC(pow) (0, 0);
6800   if (errno == ENOSYS)
6801     /* Function not implemented.  */
6802     return;
6803
6804   START (pow_downward);
6805
6806   save_round_mode = fegetround ();
6807
6808   if (!fesetround (FE_DOWNWARD))
6809     {
6810       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6811       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6812     }
6813
6814   fesetround (save_round_mode);
6815
6816   END (pow_downward);
6817 }
6818
6819
6820 static void
6821 pow_test_upward (void)
6822 {
6823   int save_round_mode;
6824   errno = 0;
6825   FUNC(pow) (0, 0);
6826   if (errno == ENOSYS)
6827     /* Function not implemented.  */
6828     return;
6829
6830   START (pow_upward);
6831
6832   save_round_mode = fegetround ();
6833
6834   if (!fesetround (FE_UPWARD))
6835     {
6836       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
6837       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
6838     }
6839
6840   fesetround (save_round_mode);
6841
6842   END (pow_upward);
6843 }
6844
6845
6846 static void
6847 remainder_test (void)
6848 {
6849   errno = 0;
6850   FUNC(remainder) (1.625, 1.0);
6851   if (errno == ENOSYS)
6852     /* Function not implemented.  */
6853     return;
6854
6855   START (remainder);
6856
6857   errno = 0;
6858   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
6859   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
6860   errno = 0;
6861   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
6862   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
6863   errno = 0;
6864   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
6865   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6866   errno = 0;
6867   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
6868   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
6869   errno = 0;
6870   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
6871   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
6872   errno = 0;
6873   TEST_ff_f (remainder, 0, nan_value, nan_value);
6874   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
6875   errno = 0;
6876   TEST_ff_f (remainder, nan_value, 0, nan_value);
6877   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
6878
6879   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
6880   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
6881   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
6882   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
6883   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
6884   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
6885
6886   END (remainder);
6887 }
6888
6889 static void
6890 remquo_test (void)
6891 {
6892   /* x is needed.  */
6893   int x;
6894
6895   errno = 0;
6896   FUNC(remquo) (1.625, 1.0, &x);
6897   if (errno == ENOSYS)
6898     /* Function not implemented.  */
6899     return;
6900
6901   START (remquo);
6902
6903   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
6904   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
6905   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6906   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
6907   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
6908
6909   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
6910   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
6911   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
6912   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
6913
6914   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
6915   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
6916
6917   END (remquo);
6918 }
6919
6920 static void
6921 rint_test (void)
6922 {
6923   START (rint);
6924
6925   TEST_f_f (rint, 0.0, 0.0);
6926   TEST_f_f (rint, minus_zero, minus_zero);
6927   TEST_f_f (rint, plus_infty, plus_infty);
6928   TEST_f_f (rint, minus_infty, minus_infty);
6929
6930   /* Default rounding mode is round to even.  */
6931   TEST_f_f (rint, 0.5, 0.0);
6932   TEST_f_f (rint, 1.5, 2.0);
6933   TEST_f_f (rint, 2.5, 2.0);
6934   TEST_f_f (rint, 3.5, 4.0);
6935   TEST_f_f (rint, 4.5, 4.0);
6936   TEST_f_f (rint, -0.5, -0.0);
6937   TEST_f_f (rint, -1.5, -2.0);
6938   TEST_f_f (rint, -2.5, -2.0);
6939   TEST_f_f (rint, -3.5, -4.0);
6940   TEST_f_f (rint, -4.5, -4.0);
6941   TEST_f_f (rint, 0.1, 0.0);
6942   TEST_f_f (rint, 0.25, 0.0);
6943   TEST_f_f (rint, 0.625, 1.0);
6944   TEST_f_f (rint, -0.1, -0.0);
6945   TEST_f_f (rint, -0.25, -0.0);
6946   TEST_f_f (rint, -0.625, -1.0);
6947   TEST_f_f (rint, 262144.75, 262145.0);
6948   TEST_f_f (rint, 262142.75, 262143.0);
6949   TEST_f_f (rint, 524286.75, 524287.0);
6950   TEST_f_f (rint, 524288.75, 524289.0);
6951   TEST_f_f (rint, 1048576.75, 1048577.0);
6952   TEST_f_f (rint, 2097152.75, 2097153.0);
6953   TEST_f_f (rint, -1048576.75, -1048577.0);
6954   TEST_f_f (rint, -2097152.75, -2097153.0);
6955 #ifndef TEST_FLOAT
6956   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6957   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6958   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6959   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6960   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6961   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6962   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6963   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6964   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6965   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6966 #endif
6967 #ifdef TEST_LDOUBLE
6968   /* The result can only be represented in long double.  */
6969   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6970   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6971   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6972   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6973   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6974
6975 # if LDBL_MANT_DIG > 100
6976   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6977   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6978   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6979 # endif
6980
6981   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6982   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6983   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6984   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6985   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6986
6987 # if LDBL_MANT_DIG > 100
6988   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6989   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6990   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6991
6992   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6993   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6994   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6995   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6996   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6997   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
6998
6999   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7000   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7001   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7002   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
7003   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
7004   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
7005 # endif
7006
7007   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
7008   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
7009   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
7010   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
7011   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
7012
7013   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
7014   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
7015   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
7016   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
7017   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
7018
7019   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
7020   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
7021   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
7022   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
7023   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
7024
7025   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
7026   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
7027   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
7028   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
7029   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
7030
7031   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
7032   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7033   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7034   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
7035   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
7036 #endif
7037
7038   END (rint);
7039 }
7040
7041 static void
7042 rint_test_tonearest (void)
7043 {
7044   int save_round_mode;
7045   START (rint_tonearest);
7046
7047   save_round_mode = fegetround ();
7048
7049   if (!fesetround (FE_TONEAREST))
7050     {
7051       TEST_f_f (rint, 2.0, 2.0);
7052       TEST_f_f (rint, 1.5, 2.0);
7053       TEST_f_f (rint, 1.0, 1.0);
7054       TEST_f_f (rint, 0.5, 0.0);
7055       TEST_f_f (rint, 0.0, 0.0);
7056       TEST_f_f (rint, minus_zero, minus_zero);
7057       TEST_f_f (rint, -0.5, -0.0);
7058       TEST_f_f (rint, -1.0, -1.0);
7059       TEST_f_f (rint, -1.5, -2.0);
7060       TEST_f_f (rint, -2.0, -2.0);
7061       TEST_f_f (rint, 0.1, 0.0);
7062       TEST_f_f (rint, 0.25, 0.0);
7063       TEST_f_f (rint, 0.625, 1.0);
7064       TEST_f_f (rint, -0.1, -0.0);
7065       TEST_f_f (rint, -0.25, -0.0);
7066       TEST_f_f (rint, -0.625, -1.0);
7067       TEST_f_f (rint, 1048576.75, 1048577.0);
7068       TEST_f_f (rint, 2097152.75, 2097153.0);
7069       TEST_f_f (rint, -1048576.75, -1048577.0);
7070       TEST_f_f (rint, -2097152.75, -2097153.0);
7071 #ifndef TEST_FLOAT
7072       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
7073       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
7074       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
7075       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
7076       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
7077       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
7078       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
7079       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
7080       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
7081       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
7082 #endif
7083 #ifdef TEST_LDOUBLE
7084       /* The result can only be represented in long double.  */
7085       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
7086       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
7087       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
7088       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
7089       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
7090 # if LDBL_MANT_DIG > 100
7091       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
7092       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
7093       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
7094 # endif
7095       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
7096       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
7097       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
7098       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
7099       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
7100 # if LDBL_MANT_DIG > 100
7101       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
7102       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
7103       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
7104
7105       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
7106       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
7107       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
7108       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
7109       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
7110       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
7111
7112       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7113       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7114       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7115       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
7116       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
7117       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
7118 # endif
7119 #endif
7120     }
7121
7122   fesetround (save_round_mode);
7123
7124   END (rint_tonearest);
7125 }
7126
7127 static void
7128 rint_test_towardzero (void)
7129 {
7130   int save_round_mode;
7131   START (rint_towardzero);
7132
7133   save_round_mode = fegetround ();
7134
7135   if (!fesetround (FE_TOWARDZERO))
7136     {
7137       TEST_f_f (rint, 2.0, 2.0);
7138       TEST_f_f (rint, 1.5, 1.0);
7139       TEST_f_f (rint, 1.0, 1.0);
7140       TEST_f_f (rint, 0.5, 0.0);
7141       TEST_f_f (rint, 0.0, 0.0);
7142       TEST_f_f (rint, minus_zero, minus_zero);
7143       TEST_f_f (rint, -0.5, -0.0);
7144       TEST_f_f (rint, -1.0, -1.0);
7145       TEST_f_f (rint, -1.5, -1.0);
7146       TEST_f_f (rint, -2.0, -2.0);
7147       TEST_f_f (rint, 0.1, 0.0);
7148       TEST_f_f (rint, 0.25, 0.0);
7149       TEST_f_f (rint, 0.625, 0.0);
7150       TEST_f_f (rint, -0.1, -0.0);
7151       TEST_f_f (rint, -0.25, -0.0);
7152       TEST_f_f (rint, -0.625, -0.0);
7153       TEST_f_f (rint, 1048576.75, 1048576.0);
7154       TEST_f_f (rint, 2097152.75, 2097152.0);
7155       TEST_f_f (rint, -1048576.75, -1048576.0);
7156       TEST_f_f (rint, -2097152.75, -2097152.0);
7157 #ifndef TEST_FLOAT
7158       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
7159       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
7160       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
7161       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
7162       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
7163       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
7164       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
7165       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
7166       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
7167       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
7168 #endif
7169 #ifdef TEST_LDOUBLE
7170       /* The result can only be represented in long double.  */
7171       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
7172       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
7173       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
7174       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
7175       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
7176 # if LDBL_MANT_DIG > 100
7177       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
7178       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
7179       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
7180 # endif
7181       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
7182       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
7183       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
7184       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
7185       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
7186 # if LDBL_MANT_DIG > 100
7187       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
7188       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
7189       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
7190
7191       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
7192       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
7193       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
7194       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
7195       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
7196       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
7197
7198       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7199       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7200       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7201       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
7202       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
7203       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
7204 # endif
7205 #endif
7206     }
7207
7208   fesetround (save_round_mode);
7209
7210   END (rint_towardzero);
7211 }
7212
7213 static void
7214 rint_test_downward (void)
7215 {
7216   int save_round_mode;
7217   START (rint_downward);
7218
7219   save_round_mode = fegetround ();
7220
7221   if (!fesetround (FE_DOWNWARD))
7222     {
7223       TEST_f_f (rint, 2.0, 2.0);
7224       TEST_f_f (rint, 1.5, 1.0);
7225       TEST_f_f (rint, 1.0, 1.0);
7226       TEST_f_f (rint, 0.5, 0.0);
7227       TEST_f_f (rint, 0.0, 0.0);
7228       TEST_f_f (rint, minus_zero, minus_zero);
7229       TEST_f_f (rint, -0.5, -1.0);
7230       TEST_f_f (rint, -1.0, -1.0);
7231       TEST_f_f (rint, -1.5, -2.0);
7232       TEST_f_f (rint, -2.0, -2.0);
7233       TEST_f_f (rint, 0.1, 0.0);
7234       TEST_f_f (rint, 0.25, 0.0);
7235       TEST_f_f (rint, 0.625, 0.0);
7236       TEST_f_f (rint, -0.1, -1.0);
7237       TEST_f_f (rint, -0.25, -1.0);
7238       TEST_f_f (rint, -0.625, -1.0);
7239       TEST_f_f (rint, 1048576.75, 1048576.0);
7240       TEST_f_f (rint, 2097152.75, 2097152.0);
7241       TEST_f_f (rint, -1048576.75, -1048577.0);
7242       TEST_f_f (rint, -2097152.75, -2097153.0);
7243 #ifndef TEST_FLOAT
7244       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
7245       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
7246       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
7247       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
7248       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
7249       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
7250       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
7251       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
7252       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
7253       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
7254 #endif
7255 #ifdef TEST_LDOUBLE
7256       /* The result can only be represented in long double.  */
7257       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
7258       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
7259       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
7260       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
7261       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
7262 # if LDBL_MANT_DIG > 100
7263       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
7264       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
7265       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
7266 # endif
7267       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
7268       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
7269       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
7270       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
7271       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
7272 # if LDBL_MANT_DIG > 100
7273       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
7274       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
7275       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
7276
7277       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
7278       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
7279       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
7280       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
7281       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
7282       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
7283
7284       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
7285       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
7286       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
7287       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
7288       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
7289       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
7290 # endif
7291 #endif
7292     }
7293
7294   fesetround (save_round_mode);
7295
7296   END (rint_downward);
7297 }
7298
7299 static void
7300 rint_test_upward (void)
7301 {
7302   int save_round_mode;
7303   START (rint_upward);
7304
7305   save_round_mode = fegetround ();
7306
7307   if (!fesetround (FE_UPWARD))
7308     {
7309       TEST_f_f (rint, 2.0, 2.0);
7310       TEST_f_f (rint, 1.5, 2.0);
7311       TEST_f_f (rint, 1.0, 1.0);
7312       TEST_f_f (rint, 0.5, 1.0);
7313       TEST_f_f (rint, 0.0, 0.0);
7314       TEST_f_f (rint, minus_zero, minus_zero);
7315       TEST_f_f (rint, -0.5, -0.0);
7316       TEST_f_f (rint, -1.0, -1.0);
7317       TEST_f_f (rint, -1.5, -1.0);
7318       TEST_f_f (rint, -2.0, -2.0);
7319       TEST_f_f (rint, 0.1, 1.0);
7320       TEST_f_f (rint, 0.25, 1.0);
7321       TEST_f_f (rint, 0.625, 1.0);
7322       TEST_f_f (rint, -0.1, -0.0);
7323       TEST_f_f (rint, -0.25, -0.0);
7324       TEST_f_f (rint, -0.625, -0.0);
7325       TEST_f_f (rint, 1048576.75, 1048577.0);
7326       TEST_f_f (rint, 2097152.75, 2097153.0);
7327       TEST_f_f (rint, -1048576.75, -1048576.0);
7328       TEST_f_f (rint, -2097152.75, -2097152.0);
7329 #ifndef TEST_FLOAT
7330       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
7331       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
7332       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
7333       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
7334       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
7335       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
7336       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
7337       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
7338       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
7339       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
7340 #endif
7341 #ifdef TEST_LDOUBLE
7342       /* The result can only be represented in long double.  */
7343       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
7344       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
7345       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
7346       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
7347       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
7348 # if LDBL_MANT_DIG > 100
7349       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
7350       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
7351       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
7352 # endif
7353       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
7354       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
7355       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
7356       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
7357       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
7358 # if LDBL_MANT_DIG > 100
7359       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
7360       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
7361       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
7362
7363       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
7364       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
7365       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
7366       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
7367       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
7368       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
7369
7370       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
7371       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
7372       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
7373       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
7374       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
7375       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
7376 # endif
7377 #endif
7378     }
7379
7380   fesetround (save_round_mode);
7381
7382   END (rint_upward);
7383 }
7384
7385 static void
7386 round_test (void)
7387 {
7388   START (round);
7389
7390   TEST_f_f (round, 0, 0);
7391   TEST_f_f (round, minus_zero, minus_zero);
7392   TEST_f_f (round, 0.2L, 0.0);
7393   TEST_f_f (round, -0.2L, minus_zero);
7394   TEST_f_f (round, 0.5, 1.0);
7395   TEST_f_f (round, -0.5, -1.0);
7396   TEST_f_f (round, 0.8L, 1.0);
7397   TEST_f_f (round, -0.8L, -1.0);
7398   TEST_f_f (round, 1.5, 2.0);
7399   TEST_f_f (round, -1.5, -2.0);
7400   TEST_f_f (round, 0.1, 0.0);
7401   TEST_f_f (round, 0.25, 0.0);
7402   TEST_f_f (round, 0.625, 1.0);
7403   TEST_f_f (round, -0.1, -0.0);
7404   TEST_f_f (round, -0.25, -0.0);
7405   TEST_f_f (round, -0.625, -1.0);
7406   TEST_f_f (round, 2097152.5, 2097153);
7407   TEST_f_f (round, -2097152.5, -2097153);
7408
7409 #ifdef TEST_LDOUBLE
7410   /* The result can only be represented in long double.  */
7411   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
7412   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
7413   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
7414   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
7415   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
7416 # if LDBL_MANT_DIG > 100
7417   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
7418   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
7419   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
7420 # endif
7421
7422   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
7423   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
7424   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
7425   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
7426   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
7427 # if LDBL_MANT_DIG > 100
7428   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
7429   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
7430   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
7431 # endif
7432
7433   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
7434   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
7435   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
7436   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
7437   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
7438
7439   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
7440   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
7441   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
7442   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
7443   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
7444
7445 # if LDBL_MANT_DIG > 100
7446   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
7447   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
7448   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
7449   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
7450   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
7451   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
7452
7453   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
7454   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
7455   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
7456   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
7457   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
7458   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
7459 # endif
7460
7461   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
7462   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
7463   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
7464   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
7465   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
7466
7467   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
7468   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
7469   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
7470   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
7471   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
7472
7473   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
7474   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7475   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
7476   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
7477   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
7478 #endif
7479
7480   END (round);
7481 }
7482
7483
7484 static void
7485 scalb_test (void)
7486 {
7487
7488   START (scalb);
7489
7490   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
7491   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
7492
7493   TEST_ff_f (scalb, 0, nan_value, nan_value);
7494   TEST_ff_f (scalb, 1, nan_value, nan_value);
7495
7496   TEST_ff_f (scalb, 1, 0, 1);
7497   TEST_ff_f (scalb, -1, 0, -1);
7498
7499   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
7500   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
7501
7502   TEST_ff_f (scalb, 0, 2, 0);
7503   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
7504   TEST_ff_f (scalb, 0, 0, 0);
7505   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
7506   TEST_ff_f (scalb, 0, -1, 0);
7507   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
7508   TEST_ff_f (scalb, 0, minus_infty, 0);
7509   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
7510
7511   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
7512   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
7513   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
7514   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
7515   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
7516   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
7517
7518   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
7519   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
7520
7521   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
7522   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
7523   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
7524   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
7525
7526   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
7527   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
7528
7529   TEST_ff_f (scalb, nan_value, 1, nan_value);
7530   TEST_ff_f (scalb, 1, nan_value, nan_value);
7531   TEST_ff_f (scalb, nan_value, 0, nan_value);
7532   TEST_ff_f (scalb, 0, nan_value, nan_value);
7533   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
7534   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
7535   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
7536
7537   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
7538   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
7539
7540   END (scalb);
7541 }
7542
7543
7544 static void
7545 scalbn_test (void)
7546 {
7547
7548   START (scalbn);
7549
7550   TEST_fi_f (scalbn, 0, 0, 0);
7551   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
7552
7553   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
7554   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
7555   TEST_fi_f (scalbn, nan_value, 1, nan_value);
7556
7557   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
7558   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
7559
7560   TEST_fi_f (scalbn, 1, 0L, 1);
7561
7562   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7563   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7564   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7565   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7566   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7567   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7568   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7569   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7570
7571   END (scalbn);
7572 }
7573
7574
7575 static void
7576 scalbln_test (void)
7577 {
7578
7579   START (scalbln);
7580
7581   TEST_fl_f (scalbln, 0, 0, 0);
7582   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
7583
7584   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
7585   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
7586   TEST_fl_f (scalbln, nan_value, 1, nan_value);
7587
7588   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
7589   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
7590
7591   TEST_fl_f (scalbln, 1, 0L, 1);
7592
7593   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7594   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7595   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7596   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7597   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7598   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7599   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
7600   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7601
7602   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7603   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7604   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7605   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7606   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7607   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7608   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
7609   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero, UNDERFLOW_EXCEPTION);
7610
7611 #if LONG_MAX >= 0x100000000
7612   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7613   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
7614   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7615   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
7616   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7617   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
7618   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
7619   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero, UNDERFLOW_EXCEPTION);
7620 #endif
7621
7622   END (scalbn);
7623 }
7624
7625
7626 static void
7627 signbit_test (void)
7628 {
7629
7630   START (signbit);
7631
7632   TEST_f_b (signbit, 0, 0);
7633   TEST_f_b (signbit, minus_zero, 1);
7634   TEST_f_b (signbit, plus_infty, 0);
7635   TEST_f_b (signbit, minus_infty, 1);
7636
7637   /* signbit (x) != 0 for x < 0.  */
7638   TEST_f_b (signbit, -1, 1);
7639   /* signbit (x) == 0 for x >= 0.  */
7640   TEST_f_b (signbit, 1, 0);
7641
7642   END (signbit);
7643 }
7644
7645
7646 static void
7647 sin_test (void)
7648 {
7649   errno = 0;
7650   FUNC(sin) (0);
7651   if (errno == ENOSYS)
7652     /* Function not implemented.  */
7653     return;
7654
7655   START (sin);
7656
7657   TEST_f_f (sin, 0, 0);
7658   TEST_f_f (sin, minus_zero, minus_zero);
7659   errno = 0;
7660   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
7661   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
7662   errno = 0;
7663   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
7664   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
7665   errno = 0;
7666   TEST_f_f (sin, nan_value, nan_value);
7667   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
7668
7669   TEST_f_f (sin, M_PI_6l, 0.5);
7670   TEST_f_f (sin, -M_PI_6l, -0.5);
7671   TEST_f_f (sin, M_PI_2l, 1);
7672   TEST_f_f (sin, -M_PI_2l, -1);
7673   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
7674
7675   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
7676   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
7677
7678 #ifdef TEST_DOUBLE
7679   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
7680   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
7681 #endif
7682
7683 #ifndef TEST_FLOAT
7684   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
7685   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
7686 #endif
7687
7688 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7689   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
7690 #endif
7691
7692   END (sin);
7693
7694 }
7695
7696
7697 static void
7698 sin_test_tonearest (void)
7699 {
7700   int save_round_mode;
7701   errno = 0;
7702   FUNC(sin) (0);
7703   if (errno == ENOSYS)
7704     /* Function not implemented.  */
7705     return;
7706
7707   START (sin_tonearest);
7708
7709   save_round_mode = fegetround ();
7710
7711   if (!fesetround (FE_TONEAREST))
7712     {
7713       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7714       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7715       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7716       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7717       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7718       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7719       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7720       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7721       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7722       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7723     }
7724
7725   fesetround (save_round_mode);
7726
7727   END (sin_tonearest);
7728 }
7729
7730
7731 static void
7732 sin_test_towardzero (void)
7733 {
7734   int save_round_mode;
7735   errno = 0;
7736   FUNC(sin) (0);
7737   if (errno == ENOSYS)
7738     /* Function not implemented.  */
7739     return;
7740
7741   START (sin_towardzero);
7742
7743   save_round_mode = fegetround ();
7744
7745   if (!fesetround (FE_TOWARDZERO))
7746     {
7747       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7748       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7749       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7750       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7751       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7752       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7753       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7754       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7755       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7756       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7757     }
7758
7759   fesetround (save_round_mode);
7760
7761   END (sin_towardzero);
7762 }
7763
7764
7765 static void
7766 sin_test_downward (void)
7767 {
7768   int save_round_mode;
7769   errno = 0;
7770   FUNC(sin) (0);
7771   if (errno == ENOSYS)
7772     /* Function not implemented.  */
7773     return;
7774
7775   START (sin_downward);
7776
7777   save_round_mode = fegetround ();
7778
7779   if (!fesetround (FE_DOWNWARD))
7780     {
7781       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7782       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7783       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7784       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7785       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7786       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7787       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7788       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7789       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7790       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7791     }
7792
7793   fesetround (save_round_mode);
7794
7795   END (sin_downward);
7796 }
7797
7798
7799 static void
7800 sin_test_upward (void)
7801 {
7802   int save_round_mode;
7803   errno = 0;
7804   FUNC(sin) (0);
7805   if (errno == ENOSYS)
7806     /* Function not implemented.  */
7807     return;
7808
7809   START (sin_upward);
7810
7811   save_round_mode = fegetround ();
7812
7813   if (!fesetround (FE_UPWARD))
7814     {
7815       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
7816       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
7817       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
7818       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
7819       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
7820       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
7821       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
7822       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
7823       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
7824       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
7825     }
7826
7827   fesetround (save_round_mode);
7828
7829   END (sin_upward);
7830 }
7831
7832
7833 static void
7834 sincos_test (void)
7835 {
7836   FLOAT sin_res, cos_res;
7837
7838   errno = 0;
7839   FUNC(sincos) (0, &sin_res, &cos_res);
7840   if (errno == ENOSYS)
7841     /* Function not implemented.  */
7842     return;
7843
7844   START (sincos);
7845
7846   /* sincos is treated differently because it returns void.  */
7847   TEST_extra (sincos, 0, 0, 1);
7848
7849   TEST_extra (sincos, minus_zero, minus_zero, 1);
7850   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7851   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
7852   TEST_extra (sincos, nan_value, nan_value, nan_value);
7853
7854   TEST_extra (sincos, M_PI_2l, 1, 0);
7855   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
7856   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
7857   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
7858
7859   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7860   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
7861
7862 #ifdef TEST_DOUBLE
7863   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
7864 #endif
7865
7866 #ifndef TEST_FLOAT
7867   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
7868   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
7869 #endif
7870
7871 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
7872   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
7873 #endif
7874
7875   END (sincos);
7876 }
7877
7878 static void
7879 sinh_test (void)
7880 {
7881   errno = 0;
7882   FUNC(sinh) (0.7L);
7883   if (errno == ENOSYS)
7884     /* Function not implemented.  */
7885     return;
7886
7887   START (sinh);
7888   TEST_f_f (sinh, 0, 0);
7889   TEST_f_f (sinh, minus_zero, minus_zero);
7890
7891 #ifndef TEST_INLINE
7892   TEST_f_f (sinh, plus_infty, plus_infty);
7893   TEST_f_f (sinh, minus_infty, minus_infty);
7894 #endif
7895   TEST_f_f (sinh, nan_value, nan_value);
7896
7897   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
7898   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
7899
7900   END (sinh);
7901 }
7902
7903
7904 static void
7905 sinh_test_tonearest (void)
7906 {
7907   int save_round_mode;
7908   errno = 0;
7909   FUNC(sinh) (0);
7910   if (errno == ENOSYS)
7911     /* Function not implemented.  */
7912     return;
7913
7914   START (sinh_tonearest);
7915
7916   save_round_mode = fegetround ();
7917
7918   if (!fesetround (FE_TONEAREST))
7919     {
7920       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7921       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7922       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7923     }
7924
7925   fesetround (save_round_mode);
7926
7927   END (sinh_tonearest);
7928 }
7929
7930
7931 static void
7932 sinh_test_towardzero (void)
7933 {
7934   int save_round_mode;
7935   errno = 0;
7936   FUNC(sinh) (0);
7937   if (errno == ENOSYS)
7938     /* Function not implemented.  */
7939     return;
7940
7941   START (sinh_towardzero);
7942
7943   save_round_mode = fegetround ();
7944
7945   if (!fesetround (FE_TOWARDZERO))
7946     {
7947       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7948       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7949       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7950     }
7951
7952   fesetround (save_round_mode);
7953
7954   END (sinh_towardzero);
7955 }
7956
7957
7958 static void
7959 sinh_test_downward (void)
7960 {
7961   int save_round_mode;
7962   errno = 0;
7963   FUNC(sinh) (0);
7964   if (errno == ENOSYS)
7965     /* Function not implemented.  */
7966     return;
7967
7968   START (sinh_downward);
7969
7970   save_round_mode = fegetround ();
7971
7972   if (!fesetround (FE_DOWNWARD))
7973     {
7974       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
7975       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
7976       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
7977     }
7978
7979   fesetround (save_round_mode);
7980
7981   END (sinh_downward);
7982 }
7983
7984
7985 static void
7986 sinh_test_upward (void)
7987 {
7988   int save_round_mode;
7989   errno = 0;
7990   FUNC(sinh) (0);
7991   if (errno == ENOSYS)
7992     /* Function not implemented.  */
7993     return;
7994
7995   START (sinh_upward);
7996
7997   save_round_mode = fegetround ();
7998
7999   if (!fesetround (FE_UPWARD))
8000     {
8001       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
8002       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
8003       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
8004     }
8005
8006   fesetround (save_round_mode);
8007
8008   END (sinh_upward);
8009 }
8010
8011
8012 static void
8013 sqrt_test (void)
8014 {
8015   errno = 0;
8016   FUNC(sqrt) (1);
8017   if (errno == ENOSYS)
8018     /* Function not implemented.  */
8019     return;
8020
8021   START (sqrt);
8022
8023   TEST_f_f (sqrt, 0, 0);
8024   TEST_f_f (sqrt, nan_value, nan_value);
8025   TEST_f_f (sqrt, plus_infty, plus_infty);
8026
8027   TEST_f_f (sqrt, minus_zero, minus_zero);
8028
8029   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
8030   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
8031   TEST_f_f (sqrt, -max_value, nan_value, INVALID_EXCEPTION);
8032   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
8033   TEST_f_f (sqrt, nan_value, nan_value);
8034
8035   TEST_f_f (sqrt, 2209, 47);
8036   TEST_f_f (sqrt, 4, 2);
8037   TEST_f_f (sqrt, 2, M_SQRT2l);
8038   TEST_f_f (sqrt, 0.25, 0.5);
8039   TEST_f_f (sqrt, 6642.25, 81.5);
8040   TEST_f_f (sqrt, 15190.5625L, 123.25L);
8041   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
8042
8043   END (sqrt);
8044 }
8045
8046
8047 static void
8048 tan_test (void)
8049 {
8050   errno = 0;
8051   FUNC(tan) (0);
8052   if (errno == ENOSYS)
8053     /* Function not implemented.  */
8054     return;
8055
8056   START (tan);
8057
8058   TEST_f_f (tan, 0, 0);
8059   TEST_f_f (tan, minus_zero, minus_zero);
8060   errno = 0;
8061   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
8062   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
8063   errno = 0;
8064   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
8065   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
8066   errno = 0;
8067   TEST_f_f (tan, nan_value, nan_value);
8068   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
8069
8070   /* Bug 14154: spurious exception may occur.  */
8071   TEST_f_f (tan, M_PI_4l, 1, UNDERFLOW_EXCEPTION_OK_FLOAT);
8072   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
8073
8074   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
8075   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
8076
8077 #ifndef TEST_FLOAT
8078   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
8079   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
8080 #endif
8081
8082 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
8083   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
8084 #endif
8085
8086   END (tan);
8087 }
8088
8089
8090 static void
8091 tan_test_tonearest (void)
8092 {
8093   int save_round_mode;
8094   errno = 0;
8095   FUNC(tan) (0);
8096   if (errno == ENOSYS)
8097     /* Function not implemented.  */
8098     return;
8099
8100   START (tan_tonearest);
8101
8102   save_round_mode = fegetround ();
8103
8104   if (!fesetround (FE_TONEAREST))
8105     {
8106       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
8107       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
8108       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
8109       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
8110       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
8111       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
8112       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
8113       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
8114       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
8115       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
8116     }
8117
8118   fesetround (save_round_mode);
8119
8120   END (tan_tonearest);
8121 }
8122
8123
8124 static void
8125 tan_test_towardzero (void)
8126 {
8127   int save_round_mode;
8128   errno = 0;
8129   FUNC(tan) (0);
8130   if (errno == ENOSYS)
8131     /* Function not implemented.  */
8132     return;
8133
8134   START (tan_towardzero);
8135
8136   save_round_mode = fegetround ();
8137
8138   if (!fesetround (FE_TOWARDZERO))
8139     {
8140       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
8141       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
8142       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
8143       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
8144       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
8145       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
8146       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
8147       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
8148       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
8149       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
8150     }
8151
8152   fesetround (save_round_mode);
8153
8154   END (tan_towardzero);
8155 }
8156
8157
8158 static void
8159 tan_test_downward (void)
8160 {
8161   int save_round_mode;
8162   errno = 0;
8163   FUNC(tan) (0);
8164   if (errno == ENOSYS)
8165     /* Function not implemented.  */
8166     return;
8167
8168   START (tan_downward);
8169
8170   save_round_mode = fegetround ();
8171
8172   if (!fesetround (FE_DOWNWARD))
8173     {
8174       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
8175       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
8176       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
8177       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
8178       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
8179       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
8180       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
8181       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
8182       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
8183       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
8184     }
8185
8186   fesetround (save_round_mode);
8187
8188   END (tan_downward);
8189 }
8190
8191
8192 static void
8193 tan_test_upward (void)
8194 {
8195   int save_round_mode;
8196   errno = 0;
8197   FUNC(tan) (0);
8198   if (errno == ENOSYS)
8199     /* Function not implemented.  */
8200     return;
8201
8202   START (tan_upward);
8203
8204   save_round_mode = fegetround ();
8205
8206   if (!fesetround (FE_UPWARD))
8207     {
8208       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
8209       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
8210       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
8211       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
8212       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
8213       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
8214       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
8215       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
8216       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
8217       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
8218     }
8219
8220   fesetround (save_round_mode);
8221
8222   END (tan_upward);
8223 }
8224
8225
8226 static void
8227 tanh_test (void)
8228 {
8229   errno = 0;
8230   FUNC(tanh) (0.7L);
8231   if (errno == ENOSYS)
8232     /* Function not implemented.  */
8233     return;
8234
8235   START (tanh);
8236
8237   TEST_f_f (tanh, 0, 0);
8238   TEST_f_f (tanh, minus_zero, minus_zero);
8239
8240 #ifndef TEST_INLINE
8241   TEST_f_f (tanh, plus_infty, 1);
8242   TEST_f_f (tanh, minus_infty, -1);
8243 #endif
8244   TEST_f_f (tanh, nan_value, nan_value);
8245
8246   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
8247   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
8248
8249   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
8250   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
8251
8252   /* 2^-57  */
8253   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
8254
8255   END (tanh);
8256 }
8257
8258 static void
8259 tgamma_test (void)
8260 {
8261   errno = 0;
8262   FUNC(tgamma) (1);
8263   if (errno == ENOSYS)
8264     /* Function not implemented.  */
8265     return;
8266   feclearexcept (FE_ALL_EXCEPT);
8267
8268   START (tgamma);
8269
8270   TEST_f_f (tgamma, plus_infty, plus_infty);
8271   TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION);
8272   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8273   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
8274   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
8275   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
8276   TEST_f_f (tgamma, -max_value, nan_value, INVALID_EXCEPTION);
8277   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
8278   TEST_f_f (tgamma, nan_value, nan_value);
8279
8280   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
8281   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
8282
8283   TEST_f_f (tgamma, 1, 1);
8284   TEST_f_f (tgamma, 4, 6);
8285
8286   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
8287   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
8288
8289   END (tgamma);
8290 }
8291
8292
8293 static void
8294 trunc_test (void)
8295 {
8296   START (trunc);
8297
8298   TEST_f_f (trunc, plus_infty, plus_infty);
8299   TEST_f_f (trunc, minus_infty, minus_infty);
8300   TEST_f_f (trunc, nan_value, nan_value);
8301
8302   TEST_f_f (trunc, 0, 0);
8303   TEST_f_f (trunc, minus_zero, minus_zero);
8304   TEST_f_f (trunc, 0.1, 0);
8305   TEST_f_f (trunc, 0.25, 0);
8306   TEST_f_f (trunc, 0.625, 0);
8307   TEST_f_f (trunc, -0.1, minus_zero);
8308   TEST_f_f (trunc, -0.25, minus_zero);
8309   TEST_f_f (trunc, -0.625, minus_zero);
8310   TEST_f_f (trunc, 1, 1);
8311   TEST_f_f (trunc, -1, -1);
8312   TEST_f_f (trunc, 1.625, 1);
8313   TEST_f_f (trunc, -1.625, -1);
8314
8315   TEST_f_f (trunc, 1048580.625L, 1048580L);
8316   TEST_f_f (trunc, -1048580.625L, -1048580L);
8317
8318   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
8319   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
8320
8321   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
8322   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
8323
8324 #ifdef TEST_LDOUBLE
8325   /* The result can only be represented in long double.  */
8326   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
8327   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
8328   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
8329   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
8330   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
8331
8332 # if LDBL_MANT_DIG > 100
8333   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
8334   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
8335   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
8336 # endif
8337
8338   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
8339   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
8340   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
8341   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
8342   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
8343
8344 # if LDBL_MANT_DIG > 100
8345   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
8346   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
8347   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
8348 # endif
8349
8350   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
8351   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
8352   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
8353   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
8354   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
8355
8356 # if LDBL_MANT_DIG > 100
8357   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
8358   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
8359   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
8360   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
8361   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
8362   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
8363 # endif
8364
8365   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
8366   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
8367   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
8368   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
8369   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
8370
8371 # if LDBL_MANT_DIG > 100
8372   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
8373   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
8374   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
8375   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
8376   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
8377   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
8378 # endif
8379
8380   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
8381   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
8382   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
8383   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
8384   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
8385
8386   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
8387   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
8388   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
8389   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
8390   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
8391
8392   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
8393   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
8394   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
8395   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
8396   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
8397 #endif
8398
8399   END (trunc);
8400 }
8401
8402 static void
8403 y0_test (void)
8404 {
8405   FLOAT s, c;
8406   errno = 0;
8407   FUNC (sincos) (0, &s, &c);
8408   if (errno == ENOSYS)
8409     /* Required function not implemented.  */
8410     return;
8411   FUNC(y0) (1);
8412   if (errno == ENOSYS)
8413     /* Function not implemented.  */
8414     return;
8415
8416   /* y0 is the Bessel function of the second kind of order 0 */
8417   START (y0);
8418
8419   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
8420   TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION);
8421   TEST_f_f (y0, 0.0, minus_infty);
8422   TEST_f_f (y0, nan_value, nan_value);
8423   TEST_f_f (y0, plus_infty, 0);
8424
8425   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
8426   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
8427   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
8428   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
8429   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
8430   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
8431   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
8432
8433   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
8434
8435 #ifndef TEST_FLOAT
8436   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
8437 #endif
8438
8439   END (y0);
8440 }
8441
8442
8443 static void
8444 y1_test (void)
8445 {
8446   FLOAT s, c;
8447   errno = 0;
8448   FUNC (sincos) (0, &s, &c);
8449   if (errno == ENOSYS)
8450     /* Required function not implemented.  */
8451     return;
8452   FUNC(y1) (1);
8453   if (errno == ENOSYS)
8454     /* Function not implemented.  */
8455     return;
8456
8457   /* y1 is the Bessel function of the second kind of order 1 */
8458   START (y1);
8459
8460   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
8461   TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION);
8462   TEST_f_f (y1, 0.0, minus_infty);
8463   TEST_f_f (y1, plus_infty, 0);
8464   TEST_f_f (y1, nan_value, nan_value);
8465
8466   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
8467   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
8468   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
8469   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
8470   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
8471   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
8472   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
8473
8474   /* Bug 14155: spurious exception may occur.  */
8475   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L, UNDERFLOW_EXCEPTION_OK);
8476
8477 #ifndef TEST_FLOAT
8478   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L);
8479 #endif
8480
8481   END (y1);
8482 }
8483
8484
8485 static void
8486 yn_test (void)
8487 {
8488   FLOAT s, c;
8489   errno = 0;
8490   FUNC (sincos) (0, &s, &c);
8491   if (errno == ENOSYS)
8492     /* Required function not implemented.  */
8493     return;
8494   FUNC(yn) (1, 1);
8495   if (errno == ENOSYS)
8496     /* Function not implemented.  */
8497     return;
8498
8499   /* yn is the Bessel function of the second kind of order n */
8500   START (yn);
8501
8502   /* yn (0, x) == y0 (x)  */
8503   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
8504   TEST_ff_f (yn, 0, -max_value, minus_infty, INVALID_EXCEPTION);
8505   TEST_ff_f (yn, 0, 0.0, minus_infty);
8506   TEST_ff_f (yn, 0, nan_value, nan_value);
8507   TEST_ff_f (yn, 0, plus_infty, 0);
8508
8509   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
8510   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
8511   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
8512   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
8513   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
8514   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
8515   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
8516
8517   /* yn (1, x) == y1 (x)  */
8518   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
8519   TEST_ff_f (yn, 1, 0.0, minus_infty);
8520   TEST_ff_f (yn, 1, plus_infty, 0);
8521   TEST_ff_f (yn, 1, nan_value, nan_value);
8522
8523   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
8524   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
8525   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
8526   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
8527   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
8528   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
8529   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
8530
8531   /* yn (3, x)  */
8532   TEST_ff_f (yn, 3, plus_infty, 0);
8533   TEST_ff_f (yn, 3, nan_value, nan_value);
8534
8535   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
8536   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
8537   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
8538   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
8539   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
8540
8541   /* yn (10, x)  */
8542   TEST_ff_f (yn, 10, plus_infty, 0);
8543   TEST_ff_f (yn, 10, nan_value, nan_value);
8544
8545   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
8546   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
8547   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
8548   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
8549   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
8550
8551   END (yn);
8552
8553 }
8554
8555
8556 static void
8557 significand_test (void)
8558 {
8559   /* significand returns the mantissa of the exponential representation.  */
8560   START (significand);
8561
8562   TEST_f_f (significand, 4.0, 1.0);
8563   TEST_f_f (significand, 6.0, 1.5);
8564   TEST_f_f (significand, 8.0, 1.0);
8565
8566   END (significand);
8567 }
8568
8569
8570 static void
8571 initialize (void)
8572 {
8573   fpstack_test ("start *init*");
8574   plus_zero = 0.0;
8575   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
8576
8577   minus_zero = FUNC(copysign) (0.0, -1.0);
8578   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
8579                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
8580   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
8581                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
8582   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
8583                       LDBL_MAX, DBL_MAX, FLT_MAX);
8584   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
8585                       LDBL_MIN, DBL_MIN, FLT_MIN);
8586
8587   (void) &plus_zero;
8588   (void) &nan_value;
8589   (void) &minus_zero;
8590   (void) &plus_infty;
8591   (void) &minus_infty;
8592   (void) &max_value;
8593   (void) &min_value;
8594
8595   /* Clear all exceptions.  From now on we must not get random exceptions.  */
8596   feclearexcept (FE_ALL_EXCEPT);
8597
8598   /* Test to make sure we start correctly.  */
8599   fpstack_test ("end *init*");
8600 }
8601
8602 /* Definitions of arguments for argp functions.  */
8603 static const struct argp_option options[] =
8604 {
8605   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
8606   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
8607   { "no-max-error", 'f', NULL, 0,
8608     "Don't output maximal errors of functions"},
8609   { "no-points", 'p', NULL, 0,
8610     "Don't output results of functions invocations"},
8611   { "ignore-max-ulp", 'i', "yes/no", 0,
8612     "Ignore given maximal errors"},
8613   { NULL, 0, NULL, 0, NULL }
8614 };
8615
8616 /* Short description of program.  */
8617 static const char doc[] = "Math test suite: " TEST_MSG ;
8618
8619 /* Prototype for option handler.  */
8620 static error_t parse_opt (int key, char *arg, struct argp_state *state);
8621
8622 /* Data structure to communicate with argp functions.  */
8623 static struct argp argp =
8624 {
8625   options, parse_opt, NULL, doc,
8626 };
8627
8628
8629 /* Handle program arguments.  */
8630 static error_t
8631 parse_opt (int key, char *arg, struct argp_state *state)
8632 {
8633   switch (key)
8634     {
8635     case 'f':
8636       output_max_error = 0;
8637       break;
8638     case 'i':
8639       if (strcmp (arg, "yes") == 0)
8640         ignore_max_ulp = 1;
8641       else if (strcmp (arg, "no") == 0)
8642         ignore_max_ulp = 0;
8643       break;
8644     case 'p':
8645       output_points = 0;
8646       break;
8647     case 'u':
8648       output_ulps = 1;
8649       break;
8650     case 'v':
8651       if (optarg)
8652         verbose = (unsigned int) strtoul (optarg, NULL, 0);
8653       else
8654         verbose = 3;
8655       break;
8656     default:
8657       return ARGP_ERR_UNKNOWN;
8658     }
8659   return 0;
8660 }
8661
8662 #if 0
8663 /* function to check our ulp calculation.  */
8664 void
8665 check_ulp (void)
8666 {
8667   int i;
8668
8669   FLOAT u, diff, ulp;
8670   /* This gives one ulp.  */
8671   u = FUNC(nextafter) (10, 20);
8672   check_equal (10.0, u, 1, &diff, &ulp);
8673   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
8674
8675   /* This gives one more ulp.  */
8676   u = FUNC(nextafter) (u, 20);
8677   check_equal (10.0, u, 2, &diff, &ulp);
8678   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
8679
8680   /* And now calculate 100 ulp.  */
8681   for (i = 2; i < 100; i++)
8682     u = FUNC(nextafter) (u, 20);
8683   check_equal (10.0, u, 100, &diff, &ulp);
8684   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
8685 }
8686 #endif
8687
8688 int
8689 main (int argc, char **argv)
8690 {
8691
8692   int remaining;
8693
8694   verbose = 1;
8695   output_ulps = 0;
8696   output_max_error = 1;
8697   output_points = 1;
8698   /* XXX set to 0 for releases.  */
8699   ignore_max_ulp = 0;
8700
8701   /* Parse and process arguments.  */
8702   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
8703
8704   if (remaining != argc)
8705     {
8706       fprintf (stderr, "wrong number of arguments");
8707       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
8708       exit (EXIT_FAILURE);
8709     }
8710
8711   if (output_ulps)
8712     {
8713       ulps_file = fopen ("ULPs", "a");
8714       if (ulps_file == NULL)
8715         {
8716           perror ("can't open file `ULPs' for writing: ");
8717           exit (1);
8718         }
8719     }
8720
8721
8722   initialize ();
8723   printf (TEST_MSG);
8724
8725 #if 0
8726   check_ulp ();
8727 #endif
8728
8729   /* Keep the tests a wee bit ordered (according to ISO C99).  */
8730   /* Classification macros:  */
8731   fpclassify_test ();
8732   isfinite_test ();
8733   isnormal_test ();
8734   signbit_test ();
8735
8736   /* Trigonometric functions:  */
8737   acos_test ();
8738   acos_test_tonearest ();
8739   acos_test_towardzero ();
8740   acos_test_downward ();
8741   acos_test_upward ();
8742   asin_test ();
8743   asin_test_tonearest ();
8744   asin_test_towardzero ();
8745   asin_test_downward ();
8746   asin_test_upward ();
8747   atan_test ();
8748   atan2_test ();
8749   cos_test ();
8750   cos_test_tonearest ();
8751   cos_test_towardzero ();
8752   cos_test_downward ();
8753   cos_test_upward ();
8754   sin_test ();
8755   sin_test_tonearest ();
8756   sin_test_towardzero ();
8757   sin_test_downward ();
8758   sin_test_upward ();
8759   sincos_test ();
8760   tan_test ();
8761   tan_test_tonearest ();
8762   tan_test_towardzero ();
8763   tan_test_downward ();
8764   tan_test_upward ();
8765
8766   /* Hyperbolic functions:  */
8767   acosh_test ();
8768   asinh_test ();
8769   atanh_test ();
8770   cosh_test ();
8771   cosh_test_tonearest ();
8772   cosh_test_towardzero ();
8773   cosh_test_downward ();
8774   cosh_test_upward ();
8775   sinh_test ();
8776   sinh_test_tonearest ();
8777   sinh_test_towardzero ();
8778   sinh_test_downward ();
8779   sinh_test_upward ();
8780   tanh_test ();
8781
8782   /* Exponential and logarithmic functions:  */
8783   exp_test ();
8784   exp_test_tonearest ();
8785   exp_test_towardzero ();
8786   exp_test_downward ();
8787   exp_test_upward ();
8788   exp10_test ();
8789   exp2_test ();
8790   expm1_test ();
8791   frexp_test ();
8792   ldexp_test ();
8793   log_test ();
8794   log10_test ();
8795   log1p_test ();
8796   log2_test ();
8797   logb_test ();
8798   logb_test_downward ();
8799   modf_test ();
8800   ilogb_test ();
8801   scalb_test ();
8802   scalbn_test ();
8803   scalbln_test ();
8804   significand_test ();
8805
8806   /* Power and absolute value functions:  */
8807   cbrt_test ();
8808   fabs_test ();
8809   hypot_test ();
8810   pow_test ();
8811   pow_test_tonearest ();
8812   pow_test_towardzero ();
8813   pow_test_downward ();
8814   pow_test_upward ();
8815   sqrt_test ();
8816
8817   /* Error and gamma functions:  */
8818   erf_test ();
8819   erfc_test ();
8820   gamma_test ();
8821   lgamma_test ();
8822   tgamma_test ();
8823
8824   /* Nearest integer functions:  */
8825   ceil_test ();
8826   floor_test ();
8827   nearbyint_test ();
8828   rint_test ();
8829   rint_test_tonearest ();
8830   rint_test_towardzero ();
8831   rint_test_downward ();
8832   rint_test_upward ();
8833   lrint_test ();
8834   lrint_test_tonearest ();
8835   lrint_test_towardzero ();
8836   lrint_test_downward ();
8837   lrint_test_upward ();
8838   llrint_test ();
8839   llrint_test_tonearest ();
8840   llrint_test_towardzero ();
8841   llrint_test_downward ();
8842   llrint_test_upward ();
8843   round_test ();
8844   lround_test ();
8845   llround_test ();
8846   trunc_test ();
8847
8848   /* Remainder functions:  */
8849   fmod_test ();
8850   remainder_test ();
8851   remquo_test ();
8852
8853   /* Manipulation functions:  */
8854   copysign_test ();
8855   nextafter_test ();
8856   nexttoward_test ();
8857
8858   /* maximum, minimum and positive difference functions */
8859   fdim_test ();
8860   fmax_test ();
8861   fmin_test ();
8862
8863   /* Multiply and add:  */
8864   fma_test ();
8865
8866   /* Complex functions:  */
8867   cabs_test ();
8868   cacos_test ();
8869   cacosh_test ();
8870   carg_test ();
8871   casin_test ();
8872   casinh_test ();
8873   catan_test ();
8874   catanh_test ();
8875   ccos_test ();
8876   ccosh_test ();
8877   cexp_test ();
8878   cimag_test ();
8879   clog10_test ();
8880   clog_test ();
8881   conj_test ();
8882   cpow_test ();
8883   cproj_test ();
8884   creal_test ();
8885   csin_test ();
8886   csinh_test ();
8887   csqrt_test ();
8888   ctan_test ();
8889   ctanh_test ();
8890
8891   /* Bessel functions:  */
8892   j0_test ();
8893   j1_test ();
8894   jn_test ();
8895   y0_test ();
8896   y1_test ();
8897   yn_test ();
8898
8899   if (output_ulps)
8900     fclose (ulps_file);
8901
8902   printf ("\nTest suite completed:\n");
8903   printf ("  %d test cases plus %d tests for exception flags executed.\n",
8904           noTests, noExcTests);
8905   if (noXFails)
8906     printf ("  %d expected failures occurred.\n", noXFails);
8907   if (noXPasses)
8908     printf ("  %d unexpected passes occurred.\n", noXPasses);
8909   if (noErrors)
8910     {
8911       printf ("  %d errors occurred.\n", noErrors);
8912       return 1;
8913     }
8914   printf ("  All tests passed successfully.\n");
8915
8916   return 0;
8917 }
8918
8919 /*
8920  * Local Variables:
8921  * mode:c
8922  * End:
8923  */