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