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