math/libm-test.inc

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