math/libm-test.inc

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