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   END (cexp, complex);
1898 }
1899
1900
1901 static void
1902 cimag_test (void)
1903 {
1904   START (cimag);
1905   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1906   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1907   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1908   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1909   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1910   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1911   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1912
1913   END (cimag);
1914 }
1915
1916 static void
1917 clog_test (void)
1918 {
1919   errno = 0;
1920   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1921   if (errno == ENOSYS)
1922     /* Function not implemented.  */
1923     return;
1924
1925   START (clog);
1926
1927   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1928   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1929
1930   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1931   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1932
1933   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1934   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1935
1936   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1937   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1938
1939   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1940   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1941   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1942   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1943   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1944   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1945   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1946   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1947
1948   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1949   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1950   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1951   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1952
1953   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1954   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1955   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1956   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1957
1958   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1959   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1960
1961   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1962   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1963
1964   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1965   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1966   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1967   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1968
1969   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1970   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1971   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1972   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1973
1974   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1975
1976   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
1977   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
1978
1979   TEST_c_c (clog, 0x1.fffffep+127L, 0x1.fffffep+127L, 89.06941264234832570836679262104313101776L, M_PI_4l);
1980   TEST_c_c (clog, 0x1.fffffep+127L, 1.0L, 88.72283905206835305365817656031404273372L, 2.938736052218037251011746307725933020145e-39L);
1981   TEST_c_c (clog, 0x1p-149L, 0x1p-149L, -102.9323563131518784484589700365392203592L, M_PI_4l);
1982   TEST_c_c (clog, 0x1p-147L, 0x1p-147L, -101.5460619520319878296245057936228672231L, M_PI_4l);
1983
1984 #ifndef TEST_FLOAT
1985   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 710.1292864836639693869320059713862337880L, M_PI_4l);
1986   TEST_c_c (clog, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 709.8942846690411016323109979483151967689L, 0.4636476090008061606231772164674799632783L);
1987   TEST_c_c (clog, 0x1p-1074L, 0x1p-1074L, -744.0934983311012896593986823853525458290L, M_PI_4l);
1988   TEST_c_c (clog, 0x1p-1073L, 0x1p-1073L, -743.4003511505413443499814502638943692610L, M_PI_4l);
1989 #endif
1990
1991 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
1992   TEST_c_c (clog, 0x1.fp+16383L, 0x1.fp+16383L, 11356.83823118610934184548269774874545400L, M_PI_4l);
1993   TEST_c_c (clog, 0x1.fp+16383L, 0x1p+16383L, 11356.60974243783798653123798337822335902L, 0.4764674194737066993385333770295162295856L);
1994   TEST_c_c (clog, 0x1p-16440L, 0x1p-16441L, -11395.22807662984378194141292922726786191L, 0.4636476090008061162142562314612144020285L);
1995 #endif
1996
1997   END (clog, complex);
1998 }
1999
2000
2001 static void
2002 clog10_test (void)
2003 {
2004   errno = 0;
2005   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
2006   if (errno == ENOSYS)
2007     /* Function not implemented.  */
2008     return;
2009
2010   START (clog10);
2011
2012   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2013   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
2014
2015   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
2016   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
2017
2018   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
2019
2020   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
2021   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
2022
2023   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
2024   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
2025   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
2026   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
2027   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
2028   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
2029   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
2030   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
2031
2032   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
2033   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
2034   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
2035   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
2036
2037   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
2038   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
2039   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
2040   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
2041
2042   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
2043   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
2044
2045   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
2046   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
2047
2048   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2049   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2050   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2051   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2052
2053   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2054   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2055   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2056   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2057
2058   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
2059
2060   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
2061   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
2062
2063   TEST_c_c (clog10, 0x1.fffffep+127L, 0x1.fffffep+127L, 38.68235441693561449174780668781319348761L, M_PI4_LOG10El);
2064   TEST_c_c (clog10, 0x1.fffffep+127L, 1.0L, 38.53183941910362389414093724045094697423L, 1.276276851248440096917018665609900318458e-39L);
2065   TEST_c_c (clog10, 0x1p-149L, 0x1p-149L, -44.70295435610120748924022586658721447508L, M_PI4_LOG10El);
2066   TEST_c_c (clog10, 0x1p-147L, 0x1p-147L, -44.10089436477324509881274807713822842154L, M_PI4_LOG10El);
2067
2068 #ifndef TEST_FLOAT
2069   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 308.4052305577487344482591243175787477115L, M_PI4_LOG10El);
2070   TEST_c_c (clog10, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 308.3031705664207720674749211936626341569L, 0.2013595981366865903254995612594728746470L);
2071   TEST_c_c (clog10, 0x1p-1074L, 0x1p-1074L, -323.1557003452838130619487034867432642357L, M_PI4_LOG10El);
2072   TEST_c_c (clog10, 0x1p-1073L, 0x1p-1073L, -322.8546703496198318667349645920187712089L, M_PI4_LOG10El);
2073 #endif
2074
2075 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2076   TEST_c_c (clog10, 0x1.fp+16383L, 0x1.fp+16383L, 4932.212175672014259683102930239951947672L, M_PI4_LOG10El);
2077   TEST_c_c (clog10, 0x1.fp+16383L, 0x1p+16383L, 4932.112944269463028900262609694408579449L, 0.2069271710841128115912940666587802677383L);
2078   TEST_c_c (clog10, 0x1p-16440L, 0x1p-16441L, -4948.884673709346821106688037612752099609L, 0.2013595981366865710389502301937289472543L);
2079 #endif
2080
2081   END (clog10, complex);
2082 }
2083
2084
2085 static void
2086 conj_test (void)
2087 {
2088   START (conj);
2089   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
2090   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
2091   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
2092   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
2093   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
2094   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
2095   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
2096
2097   END (conj, complex);
2098 }
2099
2100
2101 static void
2102 copysign_test (void)
2103 {
2104   START (copysign);
2105
2106   TEST_ff_f (copysign, 0, 4, 0);
2107   TEST_ff_f (copysign, 0, -4, minus_zero);
2108   TEST_ff_f (copysign, minus_zero, 4, 0);
2109   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
2110
2111   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
2112   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
2113   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
2114   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
2115
2116   TEST_ff_f (copysign, 0, plus_infty, 0);
2117   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
2118   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
2119   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
2120
2121   /* XXX More correctly we would have to check the sign of the NaN.  */
2122   TEST_ff_f (copysign, nan_value, 0, nan_value);
2123   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
2124   TEST_ff_f (copysign, -nan_value, 0, nan_value);
2125   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
2126
2127   END (copysign);
2128 }
2129
2130
2131 static void
2132 cos_test (void)
2133 {
2134   errno = 0;
2135   FUNC(cos) (0);
2136   if (errno == ENOSYS)
2137     /* Function not implemented.  */
2138     return;
2139
2140   START (cos);
2141
2142   TEST_f_f (cos, 0, 1);
2143   TEST_f_f (cos, minus_zero, 1);
2144   errno = 0;
2145   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
2146   check_int ("errno for cos(+inf) == EDOM", errno, EDOM, 0, 0, 0);
2147   errno = 0;
2148   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
2149   check_int ("errno for cos(-inf) == EDOM", errno, EDOM, 0, 0, 0);
2150   errno = 0;
2151   TEST_f_f (cos, nan_value, nan_value);
2152   check_int ("errno for cos(NaN) unchanged", errno, 0, 0, 0, 0);
2153
2154   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
2155   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
2156   TEST_f_f (cos, M_PI_2l, 0);
2157
2158   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
2159
2160   TEST_f_f (cos, 0x1p65, 0.99888622066058013610642172179340364209972L);
2161   TEST_f_f (cos, -0x1p65, 0.99888622066058013610642172179340364209972L);
2162
2163 #ifdef TEST_DOUBLE
2164   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
2165 #endif
2166
2167 #ifndef TEST_FLOAT
2168   TEST_f_f (cos, 1e22, 0.5232147853951389454975944733847094921409L);
2169   TEST_f_f (cos, 0x1p1023, -0.826369834614147994500785680811743734805L);
2170 #endif
2171
2172 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2173   TEST_f_f (cos, 0x1p16383L, 0.9210843909921906206874509522505756251609L);
2174 #endif
2175
2176   END (cos);
2177 }
2178
2179
2180 static void
2181 cos_test_tonearest (void)
2182 {
2183   int save_round_mode;
2184   errno = 0;
2185   FUNC(cos) (0);
2186   if (errno == ENOSYS)
2187     /* Function not implemented.  */
2188     return;
2189
2190   START (cos_tonearest);
2191
2192   save_round_mode = fegetround ();
2193
2194   if (!fesetround (FE_TONEAREST))
2195     {
2196       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2197       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2198       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2199       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2200       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2201       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2202       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2203       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2204       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2205       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2206     }
2207
2208   fesetround (save_round_mode);
2209
2210   END (cos_tonearest);
2211 }
2212
2213
2214 static void
2215 cos_test_towardzero (void)
2216 {
2217   int save_round_mode;
2218   errno = 0;
2219   FUNC(cos) (0);
2220   if (errno == ENOSYS)
2221     /* Function not implemented.  */
2222     return;
2223
2224   START (cos_towardzero);
2225
2226   save_round_mode = fegetround ();
2227
2228   if (!fesetround (FE_TOWARDZERO))
2229     {
2230       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2231       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2232       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2233       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2234       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2235       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2236       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2237       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2238       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2239       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2240     }
2241
2242   fesetround (save_round_mode);
2243
2244   END (cos_towardzero);
2245 }
2246
2247
2248 static void
2249 cos_test_downward (void)
2250 {
2251   int save_round_mode;
2252   errno = 0;
2253   FUNC(cos) (0);
2254   if (errno == ENOSYS)
2255     /* Function not implemented.  */
2256     return;
2257
2258   START (cos_downward);
2259
2260   save_round_mode = fegetround ();
2261
2262   if (!fesetround (FE_DOWNWARD))
2263     {
2264       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2265       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2266       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2267       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2268       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2269       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2270       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2271       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2272       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2273       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2274     }
2275
2276   fesetround (save_round_mode);
2277
2278   END (cos_downward);
2279 }
2280
2281
2282 static void
2283 cos_test_upward (void)
2284 {
2285   int save_round_mode;
2286   errno = 0;
2287   FUNC(cos) (0);
2288   if (errno == ENOSYS)
2289     /* Function not implemented.  */
2290     return;
2291
2292   START (cos_upward);
2293
2294   save_round_mode = fegetround ();
2295
2296   if (!fesetround (FE_UPWARD))
2297     {
2298       TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L);
2299       TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L);
2300       TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L);
2301       TEST_f_f (cos, 4, -0.6536436208636119146391681830977503814241L);
2302       TEST_f_f (cos, 5, 0.2836621854632262644666391715135573083344L);
2303       TEST_f_f (cos, 6, 0.9601702866503660205456522979229244054519L);
2304       TEST_f_f (cos, 7, 0.7539022543433046381411975217191820122183L);
2305       TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L);
2306       TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L);
2307       TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L);
2308     }
2309
2310   fesetround (save_round_mode);
2311
2312   END (cos_upward);
2313 }
2314
2315
2316 static void
2317 cosh_test (void)
2318 {
2319   errno = 0;
2320   FUNC(cosh) (0.7L);
2321   if (errno == ENOSYS)
2322     /* Function not implemented.  */
2323     return;
2324
2325   START (cosh);
2326   TEST_f_f (cosh, 0, 1);
2327   TEST_f_f (cosh, minus_zero, 1);
2328
2329 #ifndef TEST_INLINE
2330   TEST_f_f (cosh, plus_infty, plus_infty);
2331   TEST_f_f (cosh, minus_infty, plus_infty);
2332 #endif
2333   TEST_f_f (cosh, nan_value, nan_value);
2334
2335   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2336
2337   END (cosh);
2338 }
2339
2340
2341 static void
2342 cosh_test_tonearest (void)
2343 {
2344   int save_round_mode;
2345   errno = 0;
2346   FUNC(cosh) (0);
2347   if (errno == ENOSYS)
2348     /* Function not implemented.  */
2349     return;
2350
2351   START (cosh_tonearest);
2352
2353   save_round_mode = fegetround ();
2354
2355   if (!fesetround (FE_TONEAREST))
2356     {
2357       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2358       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2359       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2360     }
2361
2362   fesetround (save_round_mode);
2363
2364   END (cosh_tonearest);
2365 }
2366
2367
2368 static void
2369 cosh_test_towardzero (void)
2370 {
2371   int save_round_mode;
2372   errno = 0;
2373   FUNC(cosh) (0);
2374   if (errno == ENOSYS)
2375     /* Function not implemented.  */
2376     return;
2377
2378   START (cosh_towardzero);
2379
2380   save_round_mode = fegetround ();
2381
2382   if (!fesetround (FE_TOWARDZERO))
2383     {
2384       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2385       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2386       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2387     }
2388
2389   fesetround (save_round_mode);
2390
2391   END (cosh_towardzero);
2392 }
2393
2394
2395 static void
2396 cosh_test_downward (void)
2397 {
2398   int save_round_mode;
2399   errno = 0;
2400   FUNC(cosh) (0);
2401   if (errno == ENOSYS)
2402     /* Function not implemented.  */
2403     return;
2404
2405   START (cosh_downward);
2406
2407   save_round_mode = fegetround ();
2408
2409   if (!fesetround (FE_DOWNWARD))
2410     {
2411       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2412       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2413       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2414     }
2415
2416   fesetround (save_round_mode);
2417
2418   END (cosh_downward);
2419 }
2420
2421
2422 static void
2423 cosh_test_upward (void)
2424 {
2425   int save_round_mode;
2426   errno = 0;
2427   FUNC(cosh) (0);
2428   if (errno == ENOSYS)
2429     /* Function not implemented.  */
2430     return;
2431
2432   START (cosh_upward);
2433
2434   save_round_mode = fegetround ();
2435
2436   if (!fesetround (FE_UPWARD))
2437     {
2438       TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L);
2439       TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L);
2440       TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L);
2441     }
2442
2443   fesetround (save_round_mode);
2444
2445   END (cosh_upward);
2446 }
2447
2448
2449 static void
2450 cpow_test (void)
2451 {
2452   errno = 0;
2453   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2454   if (errno == ENOSYS)
2455     /* Function not implemented.  */
2456     return;
2457
2458   START (cpow);
2459
2460   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2461   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2462
2463   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2464   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2465
2466   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2467
2468   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2469   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2470   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2471   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2472
2473   END (cpow, complex);
2474 }
2475
2476
2477 static void
2478 cproj_test (void)
2479 {
2480   START (cproj);
2481   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2482   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2483   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2484   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2485
2486   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2487
2488   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2489   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2490   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2491   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2492
2493   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2494   TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0);
2495
2496   END (cproj, complex);
2497 }
2498
2499
2500 static void
2501 creal_test (void)
2502 {
2503   START (creal);
2504   TEST_c_f (creal, 0.0, 1.0, 0.0);
2505   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2506   TEST_c_f (creal, nan_value, 1.0, nan_value);
2507   TEST_c_f (creal, nan_value, nan_value, nan_value);
2508   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2509   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2510   TEST_c_f (creal, 2.0, 3.0, 2.0);
2511
2512   END (creal);
2513 }
2514
2515 static void
2516 csin_test (void)
2517 {
2518   errno = 0;
2519   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2520   if (errno == ENOSYS)
2521     /* Function not implemented.  */
2522     return;
2523
2524   START (csin);
2525
2526   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2527   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2528   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2529   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2530
2531   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2532   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2533   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2534   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2535
2536   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2537   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2538   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2539   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2540
2541   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2542   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2543   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2544   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2545
2546   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2547   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2548   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2549   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2550
2551   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2552   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2553   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2554   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2555
2556   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2557   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2558
2559   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2560   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2561
2562   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2563   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2564
2565   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2566   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2567
2568   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2569   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2570
2571   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2572   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2573
2574   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2575
2576   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2577   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2578
2579   END (csin, complex);
2580 }
2581
2582
2583 static void
2584 csinh_test (void)
2585 {
2586   errno = 0;
2587   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2588   if (errno == ENOSYS)
2589     /* Function not implemented.  */
2590     return;
2591
2592   START (csinh);
2593
2594   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2595   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2596   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2597   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2598
2599   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2600   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2601   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2602   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2603
2604   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2605   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2606   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2607   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2608
2609   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2610   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2611   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2612   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2613
2614   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2615   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2616   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2617   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2618
2619   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2620   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2621   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2622   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2623
2624   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2625   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2626
2627   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2628   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2629
2630   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2631   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2632
2633   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2634   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2635
2636   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2637   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2638
2639   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2640   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2641
2642   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2643
2644   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2645   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2646
2647   END (csinh, complex);
2648 }
2649
2650
2651 static void
2652 csqrt_test (void)
2653 {
2654   errno = 0;
2655   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2656   if (errno == ENOSYS)
2657     /* Function not implemented.  */
2658     return;
2659
2660   START (csqrt);
2661
2662   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2663   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2664   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2665   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2666
2667   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2668   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2669   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2670   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2671
2672   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2673   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2674   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2675   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2676
2677   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2678   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2679   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2680   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2681   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2682   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2683   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2684   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2685   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2686   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2687   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2688   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2689
2690   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2691
2692   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2693
2694   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2695   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2696   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2697   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2698
2699   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2700   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2701   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2702   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2703
2704   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2705
2706   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2707   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2708   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2709   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2710   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2711   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2712   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2713   /* Principal square root should be returned (i.e., non-negative real
2714      part).  */
2715   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2716
2717   TEST_c_c (csqrt, 0x1.fffffep+127L, 0x1.fffffep+127L, 2.026714405498316804978751017492482558075e+19L, 8.394925938143272988211878516208015586281e+18L);
2718   TEST_c_c (csqrt, 0x1.fffffep+127L, 1.0L, 1.844674352395372953599975585936590505260e+19L, 2.710505511993121390769065968615872097053e-20L);
2719   TEST_c_c (csqrt, 0x1p-149L, 0x1p-149L, 4.112805464342778798097003462770175200803e-23L, 1.703579802732953750368659735601389709551e-23L);
2720   TEST_c_c (csqrt, 0x1p-147L, 0x1p-147L, 8.225610928685557596194006925540350401606e-23L, 3.407159605465907500737319471202779419102e-23L);
2721
2722 #ifndef TEST_FLOAT
2723   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1.fffffffffffffp+1023L, 1.473094556905565378990473658199034571917e+154L, 6.101757441282702188537080005372547713595e+153L);
2724   TEST_c_c (csqrt, 0x1.fffffffffffffp+1023L, 0x1p+1023L, 1.379778091031440685006200821918878702861e+154L, 3.257214233483129514781233066898042490248e+153L);
2725   TEST_c_c (csqrt, 0x1p-1074L, 0x1p-1074L, 2.442109726130830256743814843868934877597e-162L, 1.011554969366634726113090867589031782487e-162L);
2726   TEST_c_c (csqrt, 0x1p-1073L, 0x1p-1073L, 3.453664695497464982856905711457966660085e-162L, 1.430554756764195530630723976279903095110e-162L);
2727 #endif
2728
2729 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
2730   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1.fp+16383L, 1.179514222452201722651836720466795901016e+2466L, 4.885707879516577666702435054303191575148e+2465L);
2731   TEST_c_c (csqrt, 0x1.fp+16383L, 0x1p+16383L, 1.106698967236475180613254276996359485630e+2466L, 2.687568007603946993388538156299100955642e+2465L);
2732   TEST_c_c (csqrt, 0x1p-16440L, 0x1p-16441L, 3.514690655930285351254618340783294558136e-2475L,  8.297059146828716918029689466551384219370e-2476L);
2733 #endif
2734
2735   END (csqrt, complex);
2736 }
2737
2738 static void
2739 ctan_test (void)
2740 {
2741   errno = 0;
2742   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2743   if (errno == ENOSYS)
2744     /* Function not implemented.  */
2745     return;
2746
2747   START (ctan);
2748
2749   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2750   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2751   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2752   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2753
2754   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2755   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2756   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2757   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2758
2759   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2760   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2761   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2762   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2763
2764   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2765   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2766   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2767   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2768   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2769   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2770   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2771   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2772
2773   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2774   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2775
2776   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2777   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2778
2779   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2780   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2781
2782   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2783   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2784   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2785   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2786
2787   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2788
2789   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2790   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2791
2792   END (ctan, complex);
2793 }
2794
2795
2796 static void
2797 ctanh_test (void)
2798 {
2799   errno = 0;
2800   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2801   if (errno == ENOSYS)
2802     /* Function not implemented.  */
2803     return;
2804
2805   START (ctanh);
2806
2807   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2808   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2809   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2810   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2811
2812   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2813   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2814   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2815   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2816   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2817   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2818   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2819   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2820
2821   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2822   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2823   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2824   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2825   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2826   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2827   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2828   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2829
2830   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2831   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2832
2833   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2834   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2835
2836   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2837   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2838
2839   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2840   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2841   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2842   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2843
2844   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2845
2846   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2847
2848   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2849   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2850
2851   END (ctanh, complex);
2852 }
2853
2854
2855 static void
2856 erf_test (void)
2857 {
2858   errno = 0;
2859   FUNC(erf) (0);
2860   if (errno == ENOSYS)
2861     /* Function not implemented.  */
2862     return;
2863
2864   START (erf);
2865
2866   TEST_f_f (erf, 0, 0);
2867   TEST_f_f (erf, minus_zero, minus_zero);
2868   TEST_f_f (erf, plus_infty, 1);
2869   TEST_f_f (erf, minus_infty, -1);
2870   TEST_f_f (erf, nan_value, nan_value);
2871
2872   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2873   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2874   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2875   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2876   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2877   TEST_f_f (erf, 27.0L, 1.0L);
2878
2879   END (erf);
2880 }
2881
2882
2883 static void
2884 erfc_test (void)
2885 {
2886   errno = 0;
2887   FUNC(erfc) (0);
2888   if (errno == ENOSYS)
2889     /* Function not implemented.  */
2890     return;
2891
2892   START (erfc);
2893
2894   TEST_f_f (erfc, plus_infty, 0.0);
2895   TEST_f_f (erfc, minus_infty, 2.0);
2896   TEST_f_f (erfc, 0.0, 1.0);
2897   TEST_f_f (erfc, minus_zero, 1.0);
2898   TEST_f_f (erfc, nan_value, nan_value);
2899
2900   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2901   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2902   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2903   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2904   TEST_f_f (erfc, 0x1.f7303cp+1L, 2.705500297238986897105236321218861842255e-8L);
2905   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2906   TEST_f_f (erfc, 0x1.ffa002p+2L, 1.233585992097580296336099501489175967033e-29L);
2907   TEST_f_f (erfc, 0x1.ffffc8p+2L, 1.122671365033056305522366683719541099329e-29L);
2908 #ifdef TEST_LDOUBLE
2909   /* The result can only be represented in long double.  */
2910 # if LDBL_MIN_10_EXP < -319
2911   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2912 # endif
2913 # if LDBL_MANT_DIG >= 106
2914   TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L);
2915 # endif
2916 #endif
2917
2918   END (erfc);
2919 }
2920
2921
2922 static void
2923 exp_test (void)
2924 {
2925   errno = 0;
2926   FUNC(exp) (0);
2927   if (errno == ENOSYS)
2928     /* Function not implemented.  */
2929     return;
2930
2931   START (exp);
2932
2933   TEST_f_f (exp, 0, 1);
2934   TEST_f_f (exp, minus_zero, 1);
2935
2936 #ifndef TEST_INLINE
2937   TEST_f_f (exp, plus_infty, plus_infty);
2938   TEST_f_f (exp, minus_infty, 0);
2939 #endif
2940   TEST_f_f (exp, nan_value, nan_value);
2941   TEST_f_f (exp, 1, M_El);
2942
2943   TEST_f_f (exp, 2, M_E2l);
2944   TEST_f_f (exp, 3, M_E3l);
2945   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2946   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2947   TEST_f_f (exp, 88.72269439697265625L, 3.40233126623160774937554134772290447915e38L);
2948 #if defined TEST_LDOUBLE && __LDBL_MAX_EXP__ > 1024
2949   /* The result can only be represented in sane long double.  */
2950   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
2951 #endif
2952
2953   END (exp);
2954 }
2955
2956
2957 static void
2958 exp_test_tonearest (void)
2959 {
2960   int save_round_mode;
2961   errno = 0;
2962   FUNC(exp) (0);
2963   if (errno == ENOSYS)
2964     /* Function not implemented.  */
2965     return;
2966
2967   START (exp_tonearest);
2968
2969   save_round_mode = fegetround ();
2970
2971   if (!fesetround (FE_TONEAREST))
2972     {
2973       TEST_f_f (exp, 1, M_El);
2974       TEST_f_f (exp, 2, M_E2l);
2975       TEST_f_f (exp, 3, M_E3l);
2976     }
2977
2978   fesetround (save_round_mode);
2979
2980   END (exp_tonearest);
2981 }
2982
2983
2984 static void
2985 exp_test_towardzero (void)
2986 {
2987   int save_round_mode;
2988   errno = 0;
2989   FUNC(exp) (0);
2990   if (errno == ENOSYS)
2991     /* Function not implemented.  */
2992     return;
2993
2994   START (exp_towardzero);
2995
2996   save_round_mode = fegetround ();
2997
2998   if (!fesetround (FE_TOWARDZERO))
2999     {
3000       TEST_f_f (exp, 1, M_El);
3001       TEST_f_f (exp, 2, M_E2l);
3002       TEST_f_f (exp, 3, M_E3l);
3003     }
3004
3005   fesetround (save_round_mode);
3006
3007   END (exp_towardzero);
3008 }
3009
3010
3011 static void
3012 exp_test_downward (void)
3013 {
3014   int save_round_mode;
3015   errno = 0;
3016   FUNC(exp) (0);
3017   if (errno == ENOSYS)
3018     /* Function not implemented.  */
3019     return;
3020
3021   START (exp_downward);
3022
3023   save_round_mode = fegetround ();
3024
3025   if (!fesetround (FE_DOWNWARD))
3026     {
3027       TEST_f_f (exp, 1, M_El);
3028       TEST_f_f (exp, 2, M_E2l);
3029       TEST_f_f (exp, 3, M_E3l);
3030     }
3031
3032   fesetround (save_round_mode);
3033
3034   END (exp_downward);
3035 }
3036
3037
3038 static void
3039 exp_test_upward (void)
3040 {
3041   int save_round_mode;
3042   errno = 0;
3043   FUNC(exp) (0);
3044   if (errno == ENOSYS)
3045     /* Function not implemented.  */
3046     return;
3047
3048   START (exp_upward);
3049
3050   save_round_mode = fegetround ();
3051
3052   if (!fesetround (FE_UPWARD))
3053     {
3054       TEST_f_f (exp, 1, M_El);
3055       TEST_f_f (exp, 2, M_E2l);
3056       TEST_f_f (exp, 3, M_E3l);
3057     }
3058
3059   fesetround (save_round_mode);
3060
3061   END (exp_upward);
3062 }
3063
3064
3065 static void
3066 exp10_test (void)
3067 {
3068   errno = 0;
3069   FUNC(exp10) (0);
3070   if (errno == ENOSYS)
3071     /* Function not implemented.  */
3072     return;
3073
3074   START (exp10);
3075
3076   TEST_f_f (exp10, 0, 1);
3077   TEST_f_f (exp10, minus_zero, 1);
3078
3079   TEST_f_f (exp10, plus_infty, plus_infty);
3080   TEST_f_f (exp10, minus_infty, 0);
3081   TEST_f_f (exp10, nan_value, nan_value);
3082   TEST_f_f (exp10, 3, 1000);
3083   TEST_f_f (exp10, -1, 0.1L);
3084   TEST_f_f (exp10, 1e6, plus_infty, OVERFLOW_EXCEPTION);
3085   TEST_f_f (exp10, -1e6, 0);
3086   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
3087
3088   END (exp10);
3089 }
3090
3091
3092 static void
3093 exp2_test (void)
3094 {
3095   errno = 0;
3096   FUNC(exp2) (0);
3097   if (errno == ENOSYS)
3098     /* Function not implemented.  */
3099     return;
3100
3101   START (exp2);
3102
3103   TEST_f_f (exp2, 0, 1);
3104   TEST_f_f (exp2, minus_zero, 1);
3105   TEST_f_f (exp2, plus_infty, plus_infty);
3106   TEST_f_f (exp2, minus_infty, 0);
3107   TEST_f_f (exp2, nan_value, nan_value);
3108
3109   TEST_f_f (exp2, 10, 1024);
3110   TEST_f_f (exp2, -1, 0.5);
3111   /* Bug 13871: OVERFLOW exception may be missing.  */
3112   TEST_f_f (exp2, 1e6, plus_infty, OVERFLOW_EXCEPTION_OK);
3113   TEST_f_f (exp2, -1e6, 0);
3114   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
3115
3116   END (exp2);
3117 }
3118
3119
3120 static void
3121 expm1_test (void)
3122 {
3123   errno = 0;
3124   FUNC(expm1) (0);
3125   if (errno == ENOSYS)
3126     /* Function not implemented.  */
3127     return;
3128
3129   START (expm1);
3130
3131   TEST_f_f (expm1, 0, 0);
3132   TEST_f_f (expm1, minus_zero, minus_zero);
3133
3134 #ifndef TEST_INLINE
3135   TEST_f_f (expm1, plus_infty, plus_infty);
3136   TEST_f_f (expm1, minus_infty, -1);
3137 #endif
3138   TEST_f_f (expm1, nan_value, nan_value);
3139
3140   TEST_f_f (expm1, 1, M_El - 1.0);
3141   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
3142
3143 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
3144   TEST_f_f (expm1, 11356.25L, 9.05128237311923300051376115753226014206e+4931L);
3145 #endif
3146
3147   errno = 0;
3148   /* Bug 13787: OVERFLOW exception may be missing.  */
3149   TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION_OK);
3150   check_int ("errno for expm1(large) == ERANGE", errno, ERANGE, 0, 0, 0);
3151
3152   END (expm1);
3153 }
3154
3155
3156 static void
3157 fabs_test (void)
3158 {
3159   START (fabs);
3160
3161   TEST_f_f (fabs, 0, 0);
3162   TEST_f_f (fabs, minus_zero, 0);
3163
3164   TEST_f_f (fabs, plus_infty, plus_infty);
3165   TEST_f_f (fabs, minus_infty, plus_infty);
3166   TEST_f_f (fabs, nan_value, nan_value);
3167
3168   TEST_f_f (fabs, 38.0, 38.0);
3169   TEST_f_f (fabs, -M_El, M_El);
3170
3171   END (fabs);
3172 }
3173
3174
3175 static void
3176 fdim_test (void)
3177 {
3178   START (fdim);
3179
3180   TEST_ff_f (fdim, 0, 0, 0);
3181   TEST_ff_f (fdim, 9, 0, 9);
3182   TEST_ff_f (fdim, 0, 9, 0);
3183   TEST_ff_f (fdim, -9, 0, 0);
3184   TEST_ff_f (fdim, 0, -9, 9);
3185
3186   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
3187   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
3188   TEST_ff_f (fdim, minus_infty, 9, 0);
3189   TEST_ff_f (fdim, minus_infty, -9, 0);
3190   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
3191   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
3192   TEST_ff_f (fdim, 9, plus_infty, 0);
3193   TEST_ff_f (fdim, -9, plus_infty, 0);
3194
3195   TEST_ff_f (fdim, 0, nan_value, nan_value);
3196   TEST_ff_f (fdim, 9, nan_value, nan_value);
3197   TEST_ff_f (fdim, -9, nan_value, nan_value);
3198   TEST_ff_f (fdim, nan_value, 9, nan_value);
3199   TEST_ff_f (fdim, nan_value, -9, nan_value);
3200   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
3201   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
3202   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
3203   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
3204   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
3205
3206   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
3207
3208   END (fdim);
3209 }
3210
3211
3212 static void
3213 floor_test (void)
3214 {
3215   START (floor);
3216
3217   TEST_f_f (floor, 0.0, 0.0);
3218   TEST_f_f (floor, minus_zero, minus_zero);
3219   TEST_f_f (floor, plus_infty, plus_infty);
3220   TEST_f_f (floor, minus_infty, minus_infty);
3221   TEST_f_f (floor, nan_value, nan_value);
3222
3223   TEST_f_f (floor, M_PIl, 3.0);
3224   TEST_f_f (floor, -M_PIl, -4.0);
3225
3226   TEST_f_f (floor, 0.1, 0.0);
3227   TEST_f_f (floor, 0.25, 0.0);
3228   TEST_f_f (floor, 0.625, 0.0);
3229   TEST_f_f (floor, -0.1, -1.0);
3230   TEST_f_f (floor, -0.25, -1.0);
3231   TEST_f_f (floor, -0.625, -1.0);
3232
3233 #ifdef TEST_LDOUBLE
3234   /* The result can only be represented in long double.  */
3235   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
3236   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
3237   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
3238   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
3239   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
3240 # if LDBL_MANT_DIG > 100
3241   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
3242   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
3243   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
3244 # endif
3245
3246   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
3247   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
3248   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
3249   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
3250   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
3251 # if LDBL_MANT_DIG > 100
3252   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
3253   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
3254   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
3255 # endif
3256
3257   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
3258   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
3259   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
3260   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
3261   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
3262
3263 # if LDBL_MANT_DIG > 100
3264   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
3265   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
3266   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
3267   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
3268   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
3269   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
3270 # endif
3271
3272   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
3273   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
3274   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
3275   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
3276   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
3277
3278 # if LDBL_MANT_DIG > 100
3279   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
3280   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
3281   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
3282   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
3283   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
3284   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
3285 # endif
3286
3287   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
3288   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
3289   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
3290   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
3291   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
3292
3293   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
3294   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
3295   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
3296   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
3297   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
3298
3299   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
3300   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
3301   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
3302   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
3303   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
3304 #endif
3305
3306   END (floor);
3307 }
3308
3309
3310 static void
3311 fma_test (void)
3312 {
3313   START (fma);
3314
3315   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
3316   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
3317   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
3318   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3319   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3320   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
3321   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3322   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
3323   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3324   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
3325   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3326   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
3327
3328   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3329   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3330   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3331   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3332   TEST_fff_f (fma, plus_infty, 3.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3333   TEST_fff_f (fma, minus_infty, -7.5L, minus_infty, nan_value, INVALID_EXCEPTION);
3334   TEST_fff_f (fma, -13.5L, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
3335   TEST_fff_f (fma, minus_infty, 7.5L, plus_infty, nan_value, INVALID_EXCEPTION);
3336
3337   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
3338
3339   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3340                          LDBL_MAX, DBL_MAX, FLT_MAX);
3341   TEST_fff_f (fma, -fltmax, -fltmax, minus_infty, minus_infty);
3342   TEST_fff_f (fma, fltmax / 2, fltmax / 2, minus_infty, minus_infty);
3343   TEST_fff_f (fma, -fltmax, fltmax, plus_infty, plus_infty);
3344   TEST_fff_f (fma, fltmax / 2, -fltmax / 4, plus_infty, plus_infty);
3345   TEST_fff_f (fma, plus_infty, 4, plus_infty, plus_infty);
3346   TEST_fff_f (fma, 2, minus_infty, minus_infty, minus_infty);
3347   TEST_fff_f (fma, minus_infty, minus_infty, plus_infty, plus_infty);
3348   TEST_fff_f (fma, plus_infty, minus_infty, minus_infty, minus_infty);
3349
3350 #if defined (TEST_FLOAT) && FLT_MANT_DIG == 24
3351   TEST_fff_f (fma, 0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24, 0x1.7ff802p+13);
3352   TEST_fff_f (fma, 0x1.fffp+0, 0x1.00001p+0, -0x1.fffp+0, 0x1.fffp-20);
3353   TEST_fff_f (fma, 0x1.9abcdep+127, 0x0.9abcdep-126, -0x1.f08948p+0, 0x1.bb421p-25);
3354   TEST_fff_f (fma, 0x1.9abcdep+100, 0x0.9abcdep-126, -0x1.f08948p-27, 0x1.bb421p-52);
3355   TEST_fff_f (fma, 0x1.fffffep+127, 0x1.001p+0, -0x1.fffffep+127, 0x1.fffffep+115);
3356   TEST_fff_f (fma, -0x1.fffffep+127, 0x1.fffffep+0, 0x1.fffffep+127, -0x1.fffffap+127);
3357   TEST_fff_f (fma, 0x1.fffffep+127, 2.0, -0x1.fffffep+127, 0x1.fffffep+127);
3358 #endif
3359 #if defined (TEST_DOUBLE) && DBL_MANT_DIG == 53
3360   TEST_fff_f (fma, 0x1.7fp+13, 0x1.0000000000001p+0, 0x1.ffep-48, 0x1.7f00000000001p+13);
3361   TEST_fff_f (fma, 0x1.fffp+0, 0x1.0000000000001p+0, -0x1.fffp+0, 0x1.fffp-52);
3362   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, 0x1p-300, 1.0);
3363   TEST_fff_f (fma, 0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300, 0x1.fffffffffffffp-1);
3364   TEST_fff_f (fma, 0x1.deadbeef2feedp+1023, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp+1, 0x1.0989687bc9da4p-53);
3365   TEST_fff_f (fma, 0x1.deadbeef2feedp+900, 0x0.deadbeef2feedp-1022, -0x1.a05f8c01a4bfbp-122, 0x1.0989687bc9da4p-176);
3366   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 0x1.001p+0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1011);
3367   TEST_fff_f (fma, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+0, 0x1.fffffffffffffp+1023, -0x1.ffffffffffffdp+1023);
3368   TEST_fff_f (fma, 0x1.fffffffffffffp+1023, 2.0, -0x1.fffffffffffffp+1023, 0x1.fffffffffffffp+1023);
3369   TEST_fff_f (fma, 0x1.6a09e667f3bccp-538, 0x1.6a09e667f3bccp-538, 0.0, 0.0);
3370   TEST_fff_f (fma, 0x1.deadbeef2feedp-495, 0x1.deadbeef2feedp-495, -0x1.bf86a5786a574p-989, 0x0.0000042625a1fp-1022);
3371   TEST_fff_f (fma, 0x1.deadbeef2feedp-503, 0x1.deadbeef2feedp-503, -0x1.bf86a5786a574p-1005, 0x0.0000000004262p-1022);
3372   TEST_fff_f (fma, 0x1p-537, 0x1p-538, 0x1p-1074, 0x0.0000000000002p-1022);
3373   TEST_fff_f (fma, 0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000001p-1022);
3374   TEST_fff_f (fma, 0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022, 0x0.0000010000003p-1022);
3375   TEST_fff_f (fma, 0x1.4p-967, -0x1p-106, -0x0.000001p-1022, -0x0.0000010000002p-1022);
3376   TEST_fff_f (fma, -0x1.19cab66d73e17p-959, 0x1.c7108a8c5ff51p-107, -0x0.80b0ad65d9b64p-1022, -0x0.80b0ad65d9d59p-1022);
3377   TEST_fff_f (fma, -0x1.d2eaed6e8e9d3p-979, -0x1.4e066c62ac9ddp-63, -0x0.9245e6b003454p-1022, -0x0.9245c09c5fb5dp-1022);
3378   TEST_fff_f (fma, 0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022, -0x0.b22757123bbe9p-1022);
3379   TEST_fff_f (fma, -0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983, 0x1.7ffffe00007ffp-983);
3380 #endif
3381 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 64
3382   TEST_fff_f (fma, -0x8.03fcp+3696L, 0xf.fffffffffffffffp-6140L, 0x8.3ffffffffffffffp-2450L, -0x8.01ecp-2440L);
3383   TEST_fff_f (fma, 0x9.fcp+2033L, -0x8.000e1f000ff800fp-3613L, -0xf.fffffffffffc0ffp-1579L, -0xd.fc119fb093ed092p-1577L);
3384   TEST_fff_f (fma, 0xc.7fc000003ffffffp-1194L, 0x8.1e0003fffffffffp+15327L, -0x8.fffep+14072L, 0xc.ae9f164020effffp+14136L);
3385   TEST_fff_f (fma, -0x8.0001fc000000003p+1798L, 0xcp-2230L, 0x8.f7e000000000007p-468L, -0xc.0002f9ffee10404p-429L);
3386   TEST_fff_f (fma, 0xc.0000000000007ffp+10130L, -0x8.000000000000001p+4430L, 0xc.07000000001ffffp+14513L, -0xb.fffffffffffd7e4p+14563L);
3387   TEST_fff_f (fma, 0xb.ffffp-4777L, 0x8.000000fffffffffp-11612L, -0x0.3800fff8p-16385L, 0x5.c7fe80c7ffeffffp-16385L);
3388 #endif
3389 #if defined (TEST_LDOUBLE) && LDBL_MANT_DIG == 113
3390   TEST_fff_f (fma, 0x1.bb2de33e02ccbbfa6e245a7c1f71p-2584L, -0x1.6b500daf0580d987f1bc0cadfcddp-13777L, 0x1.613cd91d9fed34b33820e5ab9d8dp-16378L, -0x1.3a79fb50eb9ce887cffa0f09bd9fp-16360L);
3391   TEST_fff_f (fma, -0x1.f949b880cacb0f0c61540105321dp-5954L, -0x1.3876cec84b4140f3bd6198731b7ep-10525L, -0x0.a5dc1c6cfbc498c54fb0b504bf19p-16382L, -0x0.a5dc1c6cfbc498c54fb0b5038abbp-16382L);
3392   TEST_fff_f (fma, -0x1.0000fffffffffp-16221L, 0x1.0000001fffff8007fep-239L, 0x0.ff87ffffffffffffe000003fffffp-16382L, 0x0.ff87ffffffffffffdffc003bff7fp-16382L);
3393   TEST_fff_f (fma, -0x1.ac79c9376ef447f3827c9e9de008p-2228L, -0x1.5ba830022b6139e21fbe7270cad8p-6314L, 0x1.e8282b6a26bb6a9daf5c8e73e9f9p-8616L, 0x1.22f14a0253878a730cd1aee373adp-8541L);
3394   TEST_fff_f (fma, -0x1.c69749ec574caaa2ab8e97ddb9f3p+2652L, 0x1.f34235ff9d095449c29b4831b62dp+3311L, 0x1.fbe4302df23354dbd0c4d3cfe606p+5879L, -0x1.bb473bfdfb7a6e18886ce6e57eafp+5964L);
3395   TEST_fff_f (fma, -0x1.ca8835fc6ecfb5398625fc891be5p-1686L, 0x1.621e1972bbe2180e5be9dd7d8df5p-7671L, -0x1.7d2d21b73b52cf20dec2a83902a4p-9395L, -0x1.3d2322191c9c88bc68a62ab8042cp-9356L);
3396   TEST_fff_f (fma, -0x1.55cff679ec49c2541fab41fc843ep-11819L, 0x1.e60e9f464f9e8df0509647c7c971p+12325L, 0x1.eaa2a7649d765c2f564f7a5beca7p+454L, -0x1.447e29fa7e406a285f4e350fcf86p+507L);
3397   TEST_fff_f (fma, 0x1.f0e7b1454908576f2537d863cf9bp+11432L, 0x1.cdce52f09d4ca76e68706f34b5d5p-1417L, -0x1.2e986187c70f146235ea2066e486p+9979L, 0x1.c030dad3cc5643f3dd0f5619f661p+10016L);
3398   TEST_fff_f (fma, 0x1.f102f7da4a57a3a4aab620e29452p-3098L, -0x1.cc06a4ff40248f9e2dcc4b6afd84p-11727L, 0x1.d512a11126b5ac8ed8973b8580c8p-14849L, -0x1.be8f1cf737ab4d1c31c54f5ec23bp-14824L);
3399   TEST_fff_f (fma, -0x1.fc47ac7434b993cd8dcb2b431f25p-3816L, 0x1.fbc9750da8468852d84558e1db6dp-5773L, -0x1.00a98abf783f75c40fe5b7a37d86p-9607L, -0x1.f81917b166f45e763cfcc057e2adp-9588L);
3400   TEST_fff_f (fma, 0x1.00000000000007ffffffffffffffp-9045L, -0x1.ffffffffffff80000001ffffffffp+4773L, -0x1.f8p-4316L, -0x1.00000000000f88000000fffffdffp-4271L);
3401   TEST_fff_f (fma, 0x1.4e922764c90701d4a2f21d01893dp-8683L, -0x1.955a12e2d7c9447c27fa022fc865p+212L, -0x1.e9634462eaef96528b90b6944578p-8521L, -0x1.08e1783184a371943d3598e10865p-8470L);
3402   TEST_fff_f (fma, 0x1.801181509c03bdbef10d6165588cp-15131L, 0x1.ad86f8e57d3d40bfa8007780af63p-368L, -0x1.6e9df0dab1c9f1d7a6043c390741p-15507L, 0x1.417c9b2b15e2ad57dc9e0e920844p-15498L);
3403 #endif
3404
3405   END (fma);
3406 }
3407
3408
3409 static void
3410 fmax_test (void)
3411 {
3412   START (fmax);
3413
3414   TEST_ff_f (fmax, 0, 0, 0);
3415   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
3416   TEST_ff_f (fmax, 9, 0, 9);
3417   TEST_ff_f (fmax, 0, 9, 9);
3418   TEST_ff_f (fmax, -9, 0, 0);
3419   TEST_ff_f (fmax, 0, -9, 0);
3420
3421   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
3422   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
3423   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
3424   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
3425
3426   TEST_ff_f (fmax, minus_infty, 9, 9);
3427   TEST_ff_f (fmax, minus_infty, -9, -9);
3428   TEST_ff_f (fmax, 9, minus_infty, 9);
3429   TEST_ff_f (fmax, -9, minus_infty, -9);
3430
3431   TEST_ff_f (fmax, 0, nan_value, 0);
3432   TEST_ff_f (fmax, 9, nan_value, 9);
3433   TEST_ff_f (fmax, -9, nan_value, -9);
3434   TEST_ff_f (fmax, nan_value, 0, 0);
3435   TEST_ff_f (fmax, nan_value, 9, 9);
3436   TEST_ff_f (fmax, nan_value, -9, -9);
3437   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
3438   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
3439   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
3440   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
3441   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
3442
3443   END (fmax);
3444 }
3445
3446
3447 static void
3448 fmin_test (void)
3449 {
3450   START (fmin);
3451
3452   TEST_ff_f (fmin, 0, 0, 0);
3453   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
3454   TEST_ff_f (fmin, 9, 0, 0);
3455   TEST_ff_f (fmin, 0, 9, 0);
3456   TEST_ff_f (fmin, -9, 0, -9);
3457   TEST_ff_f (fmin, 0, -9, -9);
3458
3459   TEST_ff_f (fmin, plus_infty, 9, 9);
3460   TEST_ff_f (fmin, 9, plus_infty, 9);
3461   TEST_ff_f (fmin, plus_infty, -9, -9);
3462   TEST_ff_f (fmin, -9, plus_infty, -9);
3463   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
3464   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
3465   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
3466   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
3467
3468   TEST_ff_f (fmin, 0, nan_value, 0);
3469   TEST_ff_f (fmin, 9, nan_value, 9);
3470   TEST_ff_f (fmin, -9, nan_value, -9);
3471   TEST_ff_f (fmin, nan_value, 0, 0);
3472   TEST_ff_f (fmin, nan_value, 9, 9);
3473   TEST_ff_f (fmin, nan_value, -9, -9);
3474   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
3475   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
3476   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
3477   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
3478   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
3479
3480   END (fmin);
3481 }
3482
3483
3484 static void
3485 fmod_test (void)
3486 {
3487   errno = 0;
3488   FUNC(fmod) (6.5, 2.3L);
3489   if (errno == ENOSYS)
3490     /* Function not implemented.  */
3491     return;
3492
3493   START (fmod);
3494
3495   /* fmod (+0, y) == +0 for y != 0.  */
3496   TEST_ff_f (fmod, 0, 3, 0);
3497
3498   /* fmod (-0, y) == -0 for y != 0.  */
3499   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
3500
3501   /* fmod (+inf, y) == NaN plus invalid exception.  */
3502   errno = 0;
3503   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
3504   check_int ("errno for fmod(Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3505   /* fmod (-inf, y) == NaN plus invalid exception.  */
3506   errno = 0;
3507   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
3508   check_int ("errno for fmod(-Inf,3) unchanged", errno, EDOM, 0, 0, 0);
3509   /* fmod (x, +0) == NaN plus invalid exception.  */
3510   errno = 0;
3511   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
3512   check_int ("errno for fmod(3,0) unchanged", errno, EDOM, 0, 0, 0);
3513   /* fmod (x, -0) == NaN plus invalid exception.  */
3514   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
3515
3516   /* fmod (x, +inf) == x for x not infinite.  */
3517   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
3518   /* fmod (x, -inf) == x for x not infinite.  */
3519   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
3520
3521   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
3522
3523   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
3524   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
3525   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
3526   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
3527
3528   END (fmod);
3529 }
3530
3531
3532 static void
3533 fpclassify_test (void)
3534 {
3535   START (fpclassify);
3536
3537   TEST_f_i (fpclassify, nan_value, FP_NAN);
3538   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
3539   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
3540   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
3541   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
3542   TEST_f_i (fpclassify, 1000, FP_NORMAL);
3543
3544   END (fpclassify);
3545 }
3546
3547
3548 static void
3549 frexp_test (void)
3550 {
3551   int x;
3552
3553   START (frexp);
3554
3555   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
3556   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
3557   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
3558
3559   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
3560   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
3561
3562   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
3563   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
3564
3565   END (frexp);
3566 }
3567
3568
3569 static void
3570 gamma_test (void)
3571 {
3572   errno = 0;
3573   FUNC(gamma) (1);
3574
3575   if (errno == ENOSYS)
3576     /* Function not implemented.  */
3577     return;
3578   feclearexcept (FE_ALL_EXCEPT);
3579
3580   START (gamma);
3581
3582   TEST_f_f (gamma, plus_infty, plus_infty);
3583   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3584   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3585   TEST_f_f (gamma, minus_infty, plus_infty);
3586   TEST_f_f (gamma, nan_value, nan_value);
3587
3588   TEST_f_f1 (gamma, 1, 0, 1);
3589   TEST_f_f1 (gamma, 3, M_LN2l, 1);
3590
3591   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
3592   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3593
3594   END (gamma);
3595 }
3596
3597 static void
3598 hypot_test (void)
3599 {
3600   errno = 0;
3601   FUNC(hypot) (0.7L, 12.4L);
3602   if (errno == ENOSYS)
3603     /* Function not implemented.  */
3604     return;
3605
3606   START (hypot);
3607
3608   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3609   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
3610
3611 #ifndef TEST_INLINE
3612   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
3613   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
3614   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
3615   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
3616 #endif
3617
3618   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
3619
3620   /* hypot (x,y) == hypot (+-x, +-y)  */
3621   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
3622   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
3623   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
3624   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
3625   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
3626   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
3627   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
3628   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
3629
3630   /*  hypot (x,0) == fabs (x)  */
3631   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
3632   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
3633   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
3634
3635   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
3636
3637 #if !(defined TEST_FLOAT && defined TEST_INLINE)
3638   TEST_ff_f (hypot, 0x3p125L, 0x4p125L, 0x5p125L);
3639   TEST_ff_f (hypot, 0x1.234566p-126L, 0x1.234566p-126L, 1.891441686191081936598531534017449451173e-38L);
3640 #endif
3641
3642 #ifndef TEST_FLOAT
3643   TEST_ff_f (hypot, 0x3p1021L, 0x4p1021L, 0x5p1021L);
3644 #endif
3645
3646 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE
3647   TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L);
3648 #endif
3649
3650   END (hypot);
3651 }
3652
3653
3654 static void
3655 ilogb_test (void)
3656 {
3657   START (ilogb);
3658
3659   TEST_f_i (ilogb, 1, 0);
3660   TEST_f_i (ilogb, M_El, 1);
3661   TEST_f_i (ilogb, 1024, 10);
3662   TEST_f_i (ilogb, -2000, 10);
3663
3664   /* XXX We have a problem here: the standard does not tell us whether
3665      exceptions are allowed/required.  ignore them for now.  */
3666
3667   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
3668   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
3669   TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
3670   TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
3671
3672   END (ilogb);
3673 }
3674
3675 static void
3676 isfinite_test (void)
3677 {
3678   START (isfinite);
3679
3680   TEST_f_b (isfinite, 0, 1);
3681   TEST_f_b (isfinite, minus_zero, 1);
3682   TEST_f_b (isfinite, 10, 1);
3683   TEST_f_b (isfinite, plus_infty, 0);
3684   TEST_f_b (isfinite, minus_infty, 0);
3685   TEST_f_b (isfinite, nan_value, 0);
3686
3687   END (isfinite);
3688 }
3689
3690 static void
3691 isnormal_test (void)
3692 {
3693   START (isnormal);
3694
3695   TEST_f_b (isnormal, 0, 0);
3696   TEST_f_b (isnormal, minus_zero, 0);
3697   TEST_f_b (isnormal, 10, 1);
3698   TEST_f_b (isnormal, plus_infty, 0);
3699   TEST_f_b (isnormal, minus_infty, 0);
3700   TEST_f_b (isnormal, nan_value, 0);
3701
3702   END (isnormal);
3703 }
3704
3705 static void
3706 j0_test (void)
3707 {
3708   FLOAT s, c;
3709   errno = 0;
3710   FUNC (sincos) (0, &s, &c);
3711   if (errno == ENOSYS)
3712     /* Required function not implemented.  */
3713     return;
3714   FUNC(j0) (0);
3715   if (errno == ENOSYS)
3716     /* Function not implemented.  */
3717     return;
3718
3719   START (j0);
3720
3721   /* j0 is the Bessel function of the first kind of order 0 */
3722   TEST_f_f (j0, nan_value, nan_value);
3723   TEST_f_f (j0, plus_infty, 0);
3724   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3725   TEST_f_f (j0, 0.0, 1.0);
3726   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3727   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3728   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3729   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3730   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3731   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3732   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3733   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3734   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3735
3736   TEST_f_f (j0, 0x1.d7ce3ap+107L, 2.775523647291230802651040996274861694514e-17L);
3737
3738 #ifndef TEST_FLOAT
3739   TEST_f_f (j0, -0x1.001000001p+593L, -3.927269966354206207832593635798954916263e-90L);
3740 #endif
3741
3742   END (j0);
3743 }
3744
3745
3746 static void
3747 j1_test (void)
3748 {
3749   FLOAT s, c;
3750   errno = 0;
3751   FUNC (sincos) (0, &s, &c);
3752   if (errno == ENOSYS)
3753     /* Required function not implemented.  */
3754     return;
3755   FUNC(j1) (0);
3756   if (errno == ENOSYS)
3757     /* Function not implemented.  */
3758     return;
3759
3760   /* j1 is the Bessel function of the first kind of order 1 */
3761
3762   START (j1);
3763
3764   TEST_f_f (j1, nan_value, nan_value);
3765   TEST_f_f (j1, plus_infty, 0);
3766
3767   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3768   TEST_f_f (j1, 0.0, 0.0);
3769   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3770   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3771   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3772   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3773   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3774   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3775   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3776
3777   TEST_f_f (j1, 0x1.3ffp+74L, 1.818984347516051243459364437186082741567e-12L);
3778
3779 #ifndef TEST_FLOAT
3780   TEST_f_f (j1, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
3781 #endif
3782
3783   END (j1);
3784 }
3785
3786 static void
3787 jn_test (void)
3788 {
3789   FLOAT s, c;
3790   errno = 0;
3791   FUNC (sincos) (0, &s, &c);
3792   if (errno == ENOSYS)
3793     /* Required function not implemented.  */
3794     return;
3795   FUNC(jn) (1, 1);
3796   if (errno == ENOSYS)
3797     /* Function not implemented.  */
3798     return;
3799
3800   /* jn is the Bessel function of the first kind of order n.  */
3801   START (jn);
3802
3803   /* jn (0, x) == j0 (x)  */
3804   TEST_ff_f (jn, 0, nan_value, nan_value);
3805   TEST_ff_f (jn, 0, plus_infty, 0);
3806   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3807   TEST_ff_f (jn, 0, 0.0, 1.0);
3808   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3809   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3810   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3811   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3812   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3813   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3814   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3815   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3816   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3817
3818   /* jn (1, x) == j1 (x)  */
3819   TEST_ff_f (jn, 1, nan_value, nan_value);
3820   TEST_ff_f (jn, 1, plus_infty, 0);
3821   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3822   TEST_ff_f (jn, 1, 0.0, 0.0);
3823   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3824   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3825   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3826   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3827   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3828   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3829   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3830
3831   /* jn (3, x)  */
3832   TEST_ff_f (jn, 3, nan_value, nan_value);
3833   TEST_ff_f (jn, 3, plus_infty, 0);
3834
3835   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3836   TEST_ff_f (jn, 3, 0.0, 0.0);
3837   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3838   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3839   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3840   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3841   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3842
3843   /*  jn (10, x)  */
3844   TEST_ff_f (jn, 10, nan_value, nan_value);
3845   TEST_ff_f (jn, 10, plus_infty, 0);
3846
3847   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3848   TEST_ff_f (jn, 10, 0.0, 0.0);
3849   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3850   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3851   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3852   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3853   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3854
3855   /* BZ #11589 .*/
3856   TEST_ff_f (jn, 2, 2.4048255576957729L, 0.43175480701968038399746111312430703L);
3857   TEST_ff_f (jn, 3, 2.4048255576957729L, 0.19899990535769083404042146764530813L);
3858   TEST_ff_f (jn, 4, 2.4048255576957729L, 0.647466661641779720084932282551219891E-1L);
3859   TEST_ff_f (jn, 5, 2.4048255576957729L, 0.163892432048058525099230549946147698E-1L);
3860   TEST_ff_f (jn, 6, 2.4048255576957729L, 0.34048184720278336646673682895929161E-2L);
3861   TEST_ff_f (jn, 7, 2.4048255576957729L, 0.60068836573295394221291569249883076E-3L);
3862   TEST_ff_f (jn, 8, 2.4048255576957729L, 0.92165786705344923232879022467054148E-4L);
3863   TEST_ff_f (jn, 9, 2.4048255576957729L, 0.12517270977961513005428966643852564E-4L);
3864
3865   TEST_ff_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L);
3866
3867   END (jn);
3868 }
3869
3870
3871 static void
3872 ldexp_test (void)
3873 {
3874   TEST_ff_f (ldexp, 0, 0, 0);
3875   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3876
3877   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3878   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3879   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3880
3881   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3882   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3883
3884   /* ldexp (x, 0) == x.  */
3885   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3886 }
3887
3888
3889 static void
3890 lgamma_test (void)
3891 {
3892   errno = 0;
3893   FUNC(lgamma) (0);
3894   if (errno == ENOSYS)
3895     /* Function not implemented.  */
3896     return;
3897   feclearexcept (FE_ALL_EXCEPT);
3898
3899   START (lgamma);
3900
3901   TEST_f_f (lgamma, plus_infty, plus_infty);
3902   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3903   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
3904   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3905   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
3906   TEST_f_f (lgamma, nan_value, nan_value);
3907
3908   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3909   errno = 0;
3910   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3911   check_int ("errno for lgamma(-integer) == ERANGE", errno, ERANGE, 0, 0, 0);
3912   TEST_f_f (lgamma, minus_infty, plus_infty);
3913
3914   TEST_f_f1 (lgamma, 1, 0, 1);
3915
3916   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3917
3918   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3919   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3920   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3921   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3922
3923   END (lgamma);
3924 }
3925
3926
3927 static void
3928 lrint_test (void)
3929 {
3930   /* XXX this test is incomplete.  We need to have a way to specifiy
3931      the rounding method and test the critical cases.  So far, only
3932      unproblematic numbers are tested.  */
3933
3934   START (lrint);
3935
3936   TEST_f_l (lrint, 0.0, 0);
3937   TEST_f_l (lrint, minus_zero, 0);
3938   TEST_f_l (lrint, 0.2L, 0);
3939   TEST_f_l (lrint, -0.2L, 0);
3940
3941   TEST_f_l (lrint, 1.4L, 1);
3942   TEST_f_l (lrint, -1.4L, -1);
3943
3944   TEST_f_l (lrint, 8388600.3L, 8388600);
3945   TEST_f_l (lrint, -8388600.3L, -8388600);
3946
3947   TEST_f_l (lrint, 1071930.0008, 1071930);
3948 #ifndef TEST_FLOAT
3949   TEST_f_l (lrint, 1073741824.01, 1073741824);
3950 # if LONG_MAX > 281474976710656
3951   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3952 # endif
3953 #endif
3954
3955   END (lrint);
3956 }
3957
3958
3959 static void
3960 lrint_test_tonearest (void)
3961 {
3962   int save_round_mode;
3963   START (lrint_tonearest);
3964
3965   save_round_mode = fegetround ();
3966
3967   if (!fesetround (FE_TONEAREST))
3968     {
3969       TEST_f_l (lrint, 0.0, 0);
3970       TEST_f_l (lrint, minus_zero, 0);
3971       TEST_f_l (lrint, 0.2L, 0);
3972       TEST_f_l (lrint, -0.2L, 0);
3973       TEST_f_l (lrint, 0.5L, 0);
3974       TEST_f_l (lrint, -0.5L, 0);
3975       TEST_f_l (lrint, 0.8L, 1);
3976       TEST_f_l (lrint, -0.8L, -1);
3977
3978       TEST_f_l (lrint, 1.4L, 1);
3979       TEST_f_l (lrint, -1.4L, -1);
3980
3981       TEST_f_l (lrint, 8388600.3L, 8388600);
3982       TEST_f_l (lrint, -8388600.3L, -8388600);
3983
3984       TEST_f_l (lrint, 1071930.0008, 1071930);
3985 #ifndef TEST_FLOAT
3986       TEST_f_l (lrint, 1073741824.01, 1073741824);
3987 # if LONG_MAX > 281474976710656
3988       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3989 # endif
3990 #endif
3991     }
3992
3993   fesetround (save_round_mode);
3994
3995   END (lrint_tonearest);
3996 }
3997
3998
3999 static void
4000 lrint_test_towardzero (void)
4001 {
4002   int save_round_mode;
4003   START (lrint_towardzero);
4004
4005   save_round_mode = fegetround ();
4006
4007   if (!fesetround (FE_TOWARDZERO))
4008     {
4009       TEST_f_l (lrint, 0.0, 0);
4010       TEST_f_l (lrint, minus_zero, 0);
4011       TEST_f_l (lrint, 0.2L, 0);
4012       TEST_f_l (lrint, -0.2L, 0);
4013       TEST_f_l (lrint, 0.5L, 0);
4014       TEST_f_l (lrint, -0.5L, 0);
4015       TEST_f_l (lrint, 0.8L, 0);
4016       TEST_f_l (lrint, -0.8L, 0);
4017
4018       TEST_f_l (lrint, 1.4L, 1);
4019       TEST_f_l (lrint, -1.4L, -1);
4020
4021       TEST_f_l (lrint, 8388600.3L, 8388600);
4022       TEST_f_l (lrint, -8388600.3L, -8388600);
4023
4024       TEST_f_l (lrint, 1071930.0008, 1071930);
4025 #ifndef TEST_FLOAT
4026       TEST_f_l (lrint, 1073741824.01, 1073741824);
4027 # if LONG_MAX > 281474976710656
4028       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4029 # endif
4030 #endif
4031     }
4032
4033   fesetround (save_round_mode);
4034
4035   END (lrint_towardzero);
4036 }
4037
4038
4039 static void
4040 lrint_test_downward (void)
4041 {
4042   int save_round_mode;
4043   START (lrint_downward);
4044
4045   save_round_mode = fegetround ();
4046
4047   if (!fesetround (FE_DOWNWARD))
4048     {
4049       TEST_f_l (lrint, 0.0, 0);
4050       TEST_f_l (lrint, minus_zero, 0);
4051       TEST_f_l (lrint, 0.2L, 0);
4052       TEST_f_l (lrint, -0.2L, -1);
4053       TEST_f_l (lrint, 0.5L, 0);
4054       TEST_f_l (lrint, -0.5L, -1);
4055       TEST_f_l (lrint, 0.8L, 0);
4056       TEST_f_l (lrint, -0.8L, -1);
4057
4058       TEST_f_l (lrint, 1.4L, 1);
4059       TEST_f_l (lrint, -1.4L, -2);
4060
4061       TEST_f_l (lrint, 8388600.3L, 8388600);
4062       TEST_f_l (lrint, -8388600.3L, -8388601);
4063
4064       TEST_f_l (lrint, 1071930.0008, 1071930);
4065 #ifndef TEST_FLOAT
4066       TEST_f_l (lrint, 1073741824.01, 1073741824);
4067 # if LONG_MAX > 281474976710656
4068       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4069 # endif
4070 #endif
4071     }
4072
4073   fesetround (save_round_mode);
4074
4075   END (lrint_downward);
4076 }
4077
4078
4079 static void
4080 lrint_test_upward (void)
4081 {
4082   int save_round_mode;
4083   START (lrint_upward);
4084
4085   save_round_mode = fegetround ();
4086
4087   if (!fesetround (FE_UPWARD))
4088     {
4089       TEST_f_l (lrint, 0.0, 0);
4090       TEST_f_l (lrint, minus_zero, 0);
4091       TEST_f_l (lrint, 0.2L, 1);
4092       TEST_f_l (lrint, -0.2L, 0);
4093       TEST_f_l (lrint, 0.5L, 1);
4094       TEST_f_l (lrint, -0.5L, 0);
4095       TEST_f_l (lrint, 0.8L, 1);
4096       TEST_f_l (lrint, -0.8L, 0);
4097
4098       TEST_f_l (lrint, 1.4L, 2);
4099       TEST_f_l (lrint, -1.4L, -1);
4100
4101       TEST_f_l (lrint, 8388600.3L, 8388601);
4102       TEST_f_l (lrint, -8388600.3L, -8388600);
4103
4104 #ifndef TEST_FLOAT
4105       TEST_f_l (lrint, 1071930.0008, 1071931);
4106       TEST_f_l (lrint, 1073741824.01, 1073741825);
4107 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
4108       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
4109 # endif
4110 #endif
4111     }
4112
4113   fesetround (save_round_mode);
4114
4115   END (lrint_upward);
4116 }
4117
4118
4119 static void
4120 llrint_test (void)
4121 {
4122   /* XXX this test is incomplete.  We need to have a way to specifiy
4123      the rounding method and test the critical cases.  So far, only
4124      unproblematic numbers are tested.  */
4125
4126   START (llrint);
4127
4128   TEST_f_L (llrint, 0.0, 0);
4129   TEST_f_L (llrint, minus_zero, 0);
4130   TEST_f_L (llrint, 0.2L, 0);
4131   TEST_f_L (llrint, -0.2L, 0);
4132
4133   TEST_f_L (llrint, 1.4L, 1);
4134   TEST_f_L (llrint, -1.4L, -1);
4135
4136   TEST_f_L (llrint, 8388600.3L, 8388600);
4137   TEST_f_L (llrint, -8388600.3L, -8388600);
4138
4139   TEST_f_l (llrint, 1071930.0008, 1071930);
4140
4141   /* Test boundary conditions.  */
4142   /* 0x1FFFFF */
4143   TEST_f_L (llrint, 2097151.0,2097151LL);
4144   /* 0x800000 */
4145   TEST_f_L (llrint, 8388608.0, 8388608LL);
4146   /* 0x1000000 */
4147   TEST_f_L (llrint, 16777216.0, 16777216LL);
4148   /* 0x20000000000 */
4149   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4150   /* 0x40000000000 */
4151   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4152   /* 0x1000000000000 */
4153   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4154   /* 0x10000000000000 */
4155   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4156   /* 0x10000080000000 */
4157   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4158   /* 0x20000000000000 */
4159   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4160   /* 0x80000000000000 */
4161   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4162   /* 0x100000000000000 */
4163   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4164 #ifdef TEST_LDOUBLE
4165   /* The input can only be represented in long double.  */
4166   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4167   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4168   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4169   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4170   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4171
4172   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4173   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4174   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4175   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4176   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4177
4178 # if LDBL_MANT_DIG > 100
4179   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4180   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4181   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4182   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4183   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4184   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4185
4186   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4187   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4188   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4189   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4190   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4191   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4192 #endif
4193
4194   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4195   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4196   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4197   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4198   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4199
4200   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4201   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4202   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4203   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4204   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4205
4206 # if LDBL_MANT_DIG > 100
4207   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4208   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4209   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4210   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4211   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4212   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4213
4214   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4215   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4216   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4217   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4218   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4219   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4220 #endif
4221
4222   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4223   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4224   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4225   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4226   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4227
4228   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4229   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4230   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4231   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4232   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4233
4234 # if LDBL_MANT_DIG > 100
4235   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4236   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4237   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4238   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4239   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4240   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4241   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4242   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4243   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4244   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4245   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4246   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4247 # endif
4248 #endif
4249
4250   END (llrint);
4251 }
4252
4253 static void
4254 llrint_test_tonearest (void)
4255 {
4256   int save_round_mode;
4257   START (llrint_tonearest);
4258
4259   save_round_mode = fegetround ();
4260
4261   if (!fesetround (FE_TONEAREST))
4262     {
4263       TEST_f_L (llrint, 0.0, 0);
4264       TEST_f_L (llrint, minus_zero, 0);
4265       TEST_f_L (llrint, 0.2L, 0);
4266       TEST_f_L (llrint, -0.2L, 0);
4267
4268       TEST_f_L (llrint, 1.4L, 1);
4269       TEST_f_L (llrint, -1.4L, -1);
4270
4271       TEST_f_L (llrint, 8388600.3L, 8388600);
4272       TEST_f_L (llrint, -8388600.3L, -8388600);
4273
4274       TEST_f_l (llrint, 1071930.0008, 1071930);
4275
4276       /* Test boundary conditions.  */
4277       /* 0x1FFFFF */
4278       TEST_f_L (llrint, 2097151.0,2097151LL);
4279       /* 0x800000 */
4280       TEST_f_L (llrint, 8388608.0, 8388608LL);
4281       /* 0x1000000 */
4282       TEST_f_L (llrint, 16777216.0, 16777216LL);
4283       /* 0x20000000000 */
4284       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4285       /* 0x40000000000 */
4286       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4287       /* 0x1000000000000 */
4288       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4289       /* 0x10000000000000 */
4290       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4291       /* 0x10000080000000 */
4292       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4293       /* 0x20000000000000 */
4294       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4295       /* 0x80000000000000 */
4296       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4297       /* 0x100000000000000 */
4298       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4299 #ifdef TEST_LDOUBLE
4300       /* The input can only be represented in long double.  */
4301       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4302       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4303       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4304       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4305       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4306
4307       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4308       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4309       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4310       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4311       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4312
4313 # if LDBL_MANT_DIG > 100
4314       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4315       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4316       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4317       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4318       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4319       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4320
4321       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4322       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4323       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4324       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4325       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4326       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4327 #endif
4328
4329       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4330       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4331       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4332       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4333       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4334
4335       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4336       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4337       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4338       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4339       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4340
4341 # if LDBL_MANT_DIG > 100
4342       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4343       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4344       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4345       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4346       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4347       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4348
4349       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4350       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4351       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4352       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4353       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4354       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4355 #endif
4356
4357       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4358       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4359       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4360       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4361       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4362
4363       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4364       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4365       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4366       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4367       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4368
4369 # if LDBL_MANT_DIG > 100
4370       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4371       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4372       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4373       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4374       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4375       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4376       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4377       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4378       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4379       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4380       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4381       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4382 # endif
4383 #endif
4384     }
4385
4386   fesetround (save_round_mode);
4387
4388   END (llrint_tonearest);
4389 }
4390
4391 static void
4392 llrint_test_towardzero (void)
4393 {
4394   int save_round_mode;
4395   START (llrint_towardzero);
4396
4397   save_round_mode = fegetround ();
4398
4399   if (!fesetround (FE_TOWARDZERO))
4400     {
4401       TEST_f_L (llrint, 0.0, 0);
4402       TEST_f_L (llrint, minus_zero, 0);
4403       TEST_f_L (llrint, 0.2L, 0);
4404       TEST_f_L (llrint, -0.2L, 0);
4405
4406       TEST_f_L (llrint, 1.4L, 1);
4407       TEST_f_L (llrint, -1.4L, -1);
4408
4409       TEST_f_L (llrint, 8388600.3L, 8388600);
4410       TEST_f_L (llrint, -8388600.3L, -8388600);
4411
4412       TEST_f_l (llrint, 1071930.0008, 1071930);
4413
4414       /* Test boundary conditions.  */
4415       /* 0x1FFFFF */
4416       TEST_f_L (llrint, 2097151.0,2097151LL);
4417       /* 0x800000 */
4418       TEST_f_L (llrint, 8388608.0, 8388608LL);
4419       /* 0x1000000 */
4420       TEST_f_L (llrint, 16777216.0, 16777216LL);
4421       /* 0x20000000000 */
4422       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4423       /* 0x40000000000 */
4424       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4425       /* 0x1000000000000 */
4426       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4427       /* 0x10000000000000 */
4428       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4429       /* 0x10000080000000 */
4430       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4431       /* 0x20000000000000 */
4432       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4433       /* 0x80000000000000 */
4434       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4435       /* 0x100000000000000 */
4436       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4437 #ifdef TEST_LDOUBLE
4438       /* The input can only be represented in long double.  */
4439       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4440       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4441       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4442       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4443       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4444
4445       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4446       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4447       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4448       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4449       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4450
4451 # if LDBL_MANT_DIG > 100
4452       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4453       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4454       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4455       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4456       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4457       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4458
4459       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4460       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4461       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4462       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4463       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4464       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4465 #endif
4466
4467       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4468       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4469       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4470       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4471       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4472
4473       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4474       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4475       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4476       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4477       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4478
4479 # if LDBL_MANT_DIG > 100
4480       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4481       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4482       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4483       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4484       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4485       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4486
4487       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4488       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4489       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4490       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4491       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4492       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4493 #endif
4494
4495       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4496       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4497       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4498       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4499       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4500
4501       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4502       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4503       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4504       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4505       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4506
4507 # if LDBL_MANT_DIG > 100
4508       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4509       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4510       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4511       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4512       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4513       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4514       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4515       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4516       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4517       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4518       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4519       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4520 # endif
4521 #endif
4522     }
4523
4524   fesetround (save_round_mode);
4525
4526   END (llrint_towardzero);
4527 }
4528
4529 static void
4530 llrint_test_downward (void)
4531 {
4532   int save_round_mode;
4533   START (llrint_downward);
4534
4535   save_round_mode = fegetround ();
4536
4537   if (!fesetround (FE_DOWNWARD))
4538     {
4539       TEST_f_L (llrint, 0.0, 0);
4540       TEST_f_L (llrint, minus_zero, 0);
4541       TEST_f_L (llrint, 0.2L, 0);
4542       TEST_f_L (llrint, -0.2L, -1);
4543
4544       TEST_f_L (llrint, 1.4L, 1);
4545       TEST_f_L (llrint, -1.4L, -2);
4546
4547       TEST_f_L (llrint, 8388600.3L, 8388600);
4548       TEST_f_L (llrint, -8388600.3L, -8388601);
4549
4550       TEST_f_l (llrint, 1071930.0008, 1071930);
4551
4552       /* Test boundary conditions.  */
4553       /* 0x1FFFFF */
4554       TEST_f_L (llrint, 2097151.0,2097151LL);
4555       /* 0x800000 */
4556       TEST_f_L (llrint, 8388608.0, 8388608LL);
4557       /* 0x1000000 */
4558       TEST_f_L (llrint, 16777216.0, 16777216LL);
4559       /* 0x20000000000 */
4560       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4561       /* 0x40000000000 */
4562       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4563       /* 0x1000000000000 */
4564       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4565       /* 0x10000000000000 */
4566       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4567       /* 0x10000080000000 */
4568       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4569       /* 0x20000000000000 */
4570       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4571       /* 0x80000000000000 */
4572       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4573       /* 0x100000000000000 */
4574       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4575 #ifdef TEST_LDOUBLE
4576       /* The input can only be represented in long double.  */
4577       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
4578       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
4579       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
4580       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
4581       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
4582
4583       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
4584       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
4585       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
4586       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
4587       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
4588       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
4589
4590       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
4591       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
4592       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
4593       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
4594       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
4595
4596       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
4597       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
4598       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
4599       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
4600       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
4601       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
4602
4603       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
4604       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
4605       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
4606       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
4607       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
4608
4609       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
4610       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
4611       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
4612       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
4613       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
4614       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
4615
4616       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
4617       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
4618       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
4619       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
4620       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
4621
4622       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
4623       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
4624       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
4625       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
4626       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
4627       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
4628
4629       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
4630       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
4631       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
4632       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
4633       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
4634
4635       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
4636       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
4637       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
4638       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
4639       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
4640
4641 # if LDBL_MANT_DIG > 100
4642       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
4643       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
4644       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4645       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4646       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
4647       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
4648       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
4649       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
4650       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
4651       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
4652       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4653       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4654 # endif
4655 #endif
4656     }
4657
4658   fesetround (save_round_mode);
4659
4660   END (llrint_downward);
4661 }
4662
4663 static void
4664 llrint_test_upward (void)
4665 {
4666   int save_round_mode;
4667   START (llrint_upward);
4668
4669   save_round_mode = fegetround ();
4670
4671   if (!fesetround (FE_UPWARD))
4672     {
4673       TEST_f_L (llrint, 0.0, 0);
4674       TEST_f_L (llrint, minus_zero, 0);
4675       TEST_f_L (llrint, 0.2L, 1);
4676       TEST_f_L (llrint, -0.2L, 0);
4677
4678       TEST_f_L (llrint, 1.4L, 2);
4679       TEST_f_L (llrint, -1.4L, -1);
4680
4681       TEST_f_L (llrint, 8388600.3L, 8388601);
4682       TEST_f_L (llrint, -8388600.3L, -8388600);
4683 #ifndef TEST_FLOAT
4684       TEST_f_l (llrint, 1071930.0008, 1071931);
4685 #endif
4686       /* Test boundary conditions.  */
4687       /* 0x1FFFFF */
4688       TEST_f_L (llrint, 2097151.0,2097151LL);
4689       /* 0x800000 */
4690       TEST_f_L (llrint, 8388608.0, 8388608LL);
4691       /* 0x1000000 */
4692       TEST_f_L (llrint, 16777216.0, 16777216LL);
4693       /* 0x20000000000 */
4694       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4695       /* 0x40000000000 */
4696       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4697       /* 0x1000000000000 */
4698       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4699       /* 0x10000000000000 */
4700       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4701       /* 0x10000080000000 */
4702       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4703       /* 0x20000000000000 */
4704       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4705       /* 0x80000000000000 */
4706       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4707       /* 0x100000000000000 */
4708       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4709 #ifdef TEST_LDOUBLE
4710       /* The input can only be represented in long double.  */
4711       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4712       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
4713       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
4714       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4715       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4716
4717       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
4718       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
4719       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
4720       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4721       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4722       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4723
4724       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4725       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4726       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4727       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4728       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4729
4730       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4731       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4732       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4733       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4734       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4735       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4736
4737       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4738       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
4739       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
4740       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4741       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4742
4743       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
4744       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
4745       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
4746       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4747       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4748       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4749
4750       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4751       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4752       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4753       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4754       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4755
4756       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4757       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4758       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4759       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4760       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4761       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4762
4763       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4764       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
4765       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
4766       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4767       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4768
4769       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4770       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4771       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4772       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4773       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4774
4775 # if LDBL_MANT_DIG > 100
4776       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4777       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4778       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4779       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4780       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
4781       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4782       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
4783       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4784       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4785       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4786       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4787       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4788 # endif
4789 #endif
4790     }
4791
4792   fesetround (save_round_mode);
4793
4794   END (llrint_upward);
4795 }
4796
4797
4798 static void
4799 log_test (void)
4800 {
4801   errno = 0;
4802   FUNC(log) (1);
4803   if (errno == ENOSYS)
4804     /* Function not implemented.  */
4805     return;
4806   START (log);
4807
4808   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4809   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4810
4811   TEST_f_f (log, 1, 0);
4812
4813   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
4814   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
4815   TEST_f_f (log, plus_infty, plus_infty);
4816   TEST_f_f (log, nan_value, nan_value);
4817
4818   TEST_f_f (log, M_El, 1);
4819   TEST_f_f (log, 1.0 / M_El, -1);
4820   TEST_f_f (log, 2, M_LN2l);
4821   TEST_f_f (log, 10, M_LN10l);
4822   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
4823
4824   END (log);
4825 }
4826
4827
4828 static void
4829 log10_test (void)
4830 {
4831   errno = 0;
4832   FUNC(log10) (1);
4833   if (errno == ENOSYS)
4834     /* Function not implemented.  */
4835     return;
4836
4837   START (log10);
4838
4839   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4840   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4841
4842   TEST_f_f (log10, 1, 0);
4843
4844   /* log10 (x) == NaN plus invalid exception if x < 0.  */
4845   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
4846   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
4847
4848   TEST_f_f (log10, plus_infty, plus_infty);
4849   TEST_f_f (log10, nan_value, nan_value);
4850
4851   TEST_f_f (log10, 0.1L, -1);
4852   TEST_f_f (log10, 10.0, 1);
4853   TEST_f_f (log10, 100.0, 2);
4854   TEST_f_f (log10, 10000.0, 4);
4855   TEST_f_f (log10, M_El, M_LOG10El);
4856   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
4857
4858   END (log10);
4859 }
4860
4861
4862 static void
4863 log1p_test (void)
4864 {
4865   errno = 0;
4866   FUNC(log1p) (0);
4867   if (errno == ENOSYS)
4868     /* Function not implemented.  */
4869     return;
4870
4871   START (log1p);
4872
4873   TEST_f_f (log1p, 0, 0);
4874   TEST_f_f (log1p, minus_zero, minus_zero);
4875
4876   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4877   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
4878   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
4879
4880   TEST_f_f (log1p, plus_infty, plus_infty);
4881   TEST_f_f (log1p, nan_value, nan_value);
4882
4883   TEST_f_f (log1p, M_El - 1.0, 1);
4884
4885   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
4886   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
4887
4888   END (log1p);
4889 }
4890
4891
4892 static void
4893 log2_test (void)
4894 {
4895   errno = 0;
4896   FUNC(log2) (1);
4897   if (errno == ENOSYS)
4898     /* Function not implemented.  */
4899     return;
4900
4901   START (log2);
4902
4903   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4904   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4905
4906   TEST_f_f (log2, 1, 0);
4907
4908   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
4909   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
4910
4911   TEST_f_f (log2, plus_infty, plus_infty);
4912   TEST_f_f (log2, nan_value, nan_value);
4913
4914   TEST_f_f (log2, M_El, M_LOG2El);
4915   TEST_f_f (log2, 2.0, 1);
4916   TEST_f_f (log2, 16.0, 4);
4917   TEST_f_f (log2, 256.0, 8);
4918   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
4919
4920   END (log2);
4921 }
4922
4923
4924 static void
4925 logb_test (void)
4926 {
4927   START (logb);
4928
4929   TEST_f_f (logb, plus_infty, plus_infty);
4930   TEST_f_f (logb, minus_infty, plus_infty);
4931
4932   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4933
4934   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4935   TEST_f_f (logb, nan_value, nan_value);
4936
4937   TEST_f_f (logb, 1, 0);
4938   TEST_f_f (logb, M_El, 1);
4939   TEST_f_f (logb, 1024, 10);
4940   TEST_f_f (logb, -2000, 10);
4941
4942   END (logb);
4943 }
4944
4945
4946 static void
4947 lround_test (void)
4948 {
4949   START (lround);
4950
4951   TEST_f_l (lround, 0, 0);
4952   TEST_f_l (lround, minus_zero, 0);
4953   TEST_f_l (lround, 0.2L, 0.0);
4954   TEST_f_l (lround, -0.2L, 0);
4955   TEST_f_l (lround, 0.5, 1);
4956   TEST_f_l (lround, -0.5, -1);
4957   TEST_f_l (lround, 0.8L, 1);
4958   TEST_f_l (lround, -0.8L, -1);
4959   TEST_f_l (lround, 1.5, 2);
4960   TEST_f_l (lround, -1.5, -2);
4961   TEST_f_l (lround, 22514.5, 22515);
4962   TEST_f_l (lround, -22514.5, -22515);
4963   TEST_f_l (lround, 1071930.0008, 1071930);
4964 #ifndef TEST_FLOAT
4965   TEST_f_l (lround, 1073741824.01, 1073741824);
4966 # if LONG_MAX > 281474976710656
4967   TEST_f_l (lround, 281474976710656.025, 281474976710656);
4968   TEST_f_l (lround, 18014398509481974, 18014398509481974);
4969 # endif
4970   TEST_f_l (lround, 2097152.5, 2097153);
4971   TEST_f_l (lround, -2097152.5, -2097153);
4972   /* nextafter(0.5,-1)  */
4973   TEST_f_l (lround, 0x1.fffffffffffffp-2, 0);
4974   /* nextafter(-0.5,1)  */
4975   TEST_f_l (lround, -0x1.fffffffffffffp-2, 0);
4976 #else
4977   /* nextafter(0.5,-1)  */
4978   TEST_f_l (lround, 0x1.fffffp-2, 0);
4979   /* nextafter(-0.5,1)  */
4980   TEST_f_l (lround, -0x1.fffffp-2, 0);
4981   TEST_f_l (lround, 0x1.fffffep+23, 16777215);
4982   TEST_f_l (lround, -0x1.fffffep+23, -16777215);
4983 #endif
4984   END (lround);
4985 }
4986
4987
4988 static void
4989 llround_test (void)
4990 {
4991   START (llround);
4992
4993   TEST_f_L (llround, 0, 0);
4994   TEST_f_L (llround, minus_zero, 0);
4995   TEST_f_L (llround, 0.2L, 0.0);
4996   TEST_f_L (llround, -0.2L, 0);
4997   TEST_f_L (llround, 0.5, 1);
4998   TEST_f_L (llround, -0.5, -1);
4999   TEST_f_L (llround, 0.8L, 1);
5000   TEST_f_L (llround, -0.8L, -1);
5001   TEST_f_L (llround, 1.5, 2);
5002   TEST_f_L (llround, -1.5, -2);
5003   TEST_f_L (llround, 22514.5, 22515);
5004   TEST_f_L (llround, -22514.5, -22515);
5005   TEST_f_l (llround, 1071930.0008, 1071930);
5006 #ifndef TEST_FLOAT
5007   TEST_f_L (llround, 2097152.5, 2097153);
5008   TEST_f_L (llround, -2097152.5, -2097153);
5009   TEST_f_L (llround, 34359738368.5, 34359738369ll);
5010   TEST_f_L (llround, -34359738368.5, -34359738369ll);
5011   TEST_f_L (llround, -3.65309740835E17, -365309740835000000LL);
5012 #endif
5013
5014   /* Test boundary conditions.  */
5015   /* 0x1FFFFF */
5016   TEST_f_L (llround, 2097151.0, 2097151LL);
5017   /* 0x800000 */
5018   TEST_f_L (llround, 8388608.0, 8388608LL);
5019   /* 0x1000000 */
5020   TEST_f_L (llround, 16777216.0, 16777216LL);
5021   /* 0x20000000000 */
5022   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
5023   /* 0x40000000000 */
5024   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
5025   /* 0x1000000000000 */
5026   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
5027   /* 0x10000000000000 */
5028   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
5029   /* 0x10000080000000 */
5030   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
5031   /* 0x20000000000000 */
5032   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
5033   /* 0x80000000000000 */
5034   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
5035   /* 0x100000000000000 */
5036   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
5037
5038 #ifndef TEST_FLOAT
5039   /* 0x100000000 */
5040   TEST_f_L (llround, 4294967295.5, 4294967296LL);
5041   /* 0x200000000 */
5042   TEST_f_L (llround, 8589934591.5, 8589934592LL);
5043
5044   /* nextafter(0.5,-1)  */
5045   TEST_f_L (llround, 0x1.fffffffffffffp-2, 0);
5046   /* nextafter(-0.5,1)  */
5047   TEST_f_L (llround, -0x1.fffffffffffffp-2, 0);
5048   /* On PowerPC an exponent of '52' is the largest incrementally
5049    * representable sequence of whole-numbers in the 'double' range.  We test
5050    * lround to make sure that a guard bit set during the lround operation
5051    * hasn't forced an erroneous shift giving us an incorrect result.  The odd
5052    * numbers between +-(2^52+1 and 2^53-1) are affected since they have the
5053    * rightmost bit set.  */
5054   /* +-(2^52+1)  */
5055   TEST_f_L (llround, 0x1.0000000000001p+52,4503599627370497LL);
5056   TEST_f_L (llround, -0x1.0000000000001p+52,-4503599627370497LL);
5057   /* +-(2^53-1): Input is the last (positive and negative) incrementally
5058    * representable whole-number in the 'double' range that might round
5059    * erroneously.  */
5060   TEST_f_L (llround, 0x1.fffffffffffffp+52, 9007199254740991LL);
5061   TEST_f_L (llround, -0x1.fffffffffffffp+52, -9007199254740991LL);
5062 #else
5063   /* nextafter(0.5,-1)  */
5064   TEST_f_L (llround, 0x1.fffffep-2, 0);
5065   /* nextafter(-0.5,1)  */
5066   TEST_f_L (llround, -0x1.fffffep-2, 0);
5067   /* As above, on PowerPC an exponent of '23' is the largest incrementally
5068    * representable sequence of whole-numbers in the 'float' range.
5069    * Likewise, numbers between +-(2^23+1 and 2^24-1) are affected.  */
5070   TEST_f_L (llround, 0x1.000002p+23,8388609);
5071   TEST_f_L (llround, -0x1.000002p+23,-8388609);
5072   TEST_f_L (llround, 0x1.fffffep+23, 16777215);
5073   TEST_f_L (llround, -0x1.fffffep+23, -16777215);
5074 #endif
5075
5076
5077 #ifdef TEST_LDOUBLE
5078   /* The input can only be represented in long double.  */
5079   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
5080   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
5081   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
5082   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
5083   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
5084
5085 # if LDBL_MANT_DIG > 100
5086   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
5087   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
5088   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
5089   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
5090   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
5091   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
5092
5093   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
5094   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
5095   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
5096   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
5097   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
5098   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
5099 # endif
5100
5101   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
5102   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
5103   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
5104   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
5105   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
5106
5107   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
5108   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
5109   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
5110   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
5111   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
5112
5113 # if LDBL_MANT_DIG > 100
5114   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
5115   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
5116   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
5117   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
5118   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
5119   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
5120
5121   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
5122   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
5123   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
5124   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
5125   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
5126   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
5127 # endif
5128
5129   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
5130   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
5131   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
5132   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
5133   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
5134
5135   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
5136   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
5137   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
5138   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
5139   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
5140
5141   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
5142   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
5143   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
5144   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
5145   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
5146
5147   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
5148   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
5149   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
5150   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
5151   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
5152   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
5153 #endif
5154
5155   END (llround);
5156 }
5157
5158 static void
5159 modf_test (void)
5160 {
5161   FLOAT x;
5162
5163   START (modf);
5164
5165   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
5166   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
5167   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
5168   TEST_fF_f1 (modf, 0, 0, 0);
5169   TEST_fF_f1 (modf, 1.5, 0.5, 1);
5170   TEST_fF_f1 (modf, 2.5, 0.5, 2);
5171   TEST_fF_f1 (modf, -2.5, -0.5, -2);
5172   TEST_fF_f1 (modf, 20, 0, 20);
5173   TEST_fF_f1 (modf, 21, 0, 21);
5174   TEST_fF_f1 (modf, 89.5, 0.5, 89);
5175
5176   END (modf);
5177 }
5178
5179
5180 static void
5181 nearbyint_test (void)
5182 {
5183   START (nearbyint);
5184
5185   TEST_f_f (nearbyint, 0.0, 0.0);
5186   TEST_f_f (nearbyint, minus_zero, minus_zero);
5187   TEST_f_f (nearbyint, plus_infty, plus_infty);
5188   TEST_f_f (nearbyint, minus_infty, minus_infty);
5189   TEST_f_f (nearbyint, nan_value, nan_value);
5190
5191   /* Subnormal values */
5192   TEST_f_f (nearbyint, -8.98847e+307, -8.98847e+307);
5193   TEST_f_f (nearbyint, -4.45015e-308, minus_zero);
5194
5195   /* Default rounding mode is round to nearest.  */
5196   TEST_f_f (nearbyint, 0.5, 0.0);
5197   TEST_f_f (nearbyint, 1.5, 2.0);
5198   TEST_f_f (nearbyint, -0.5, minus_zero);
5199   TEST_f_f (nearbyint, -1.5, -2.0);
5200
5201   TEST_f_f (nearbyint, 262144.75, 262145.0);
5202   TEST_f_f (nearbyint, 262142.75, 262143.0);
5203   TEST_f_f (nearbyint, 524286.75, 524287.0);
5204   TEST_f_f (nearbyint, 524288.75, 524289.0);
5205
5206   TEST_f_f (nearbyint, 1048576.75, 1048577.0);
5207   TEST_f_f (nearbyint, 2097152.75, 2097153.0);
5208   TEST_f_f (nearbyint, 2492472.75, 2492473.0);
5209   TEST_f_f (nearbyint, 2886220.75, 2886221.0);
5210   TEST_f_f (nearbyint, 3058792.75, 3058793.0);
5211   TEST_f_f (nearbyint, -1048576.75, -1048577.0);
5212   TEST_f_f (nearbyint, -2097152.75, -2097153.0);
5213   TEST_f_f (nearbyint, -2492472.75, -2492473.0);
5214   TEST_f_f (nearbyint, -2886220.75, -2886221.0);
5215   TEST_f_f (nearbyint, -3058792.75, -3058793.0);
5216 #ifndef TEST_FLOAT
5217   TEST_f_f (nearbyint, 70368744177664.75, 70368744177665.0);
5218   TEST_f_f (nearbyint, 140737488355328.75, 140737488355329.0);
5219   TEST_f_f (nearbyint, 281474976710656.75, 281474976710657.0);
5220   TEST_f_f (nearbyint, 562949953421312.75, 562949953421313.0);
5221   TEST_f_f (nearbyint, 1125899906842624.75, 1125899906842625.0);
5222   TEST_f_f (nearbyint, -70368744177664.75, -70368744177665.0);
5223   TEST_f_f (nearbyint, -140737488355328.75, -140737488355329.0);
5224   TEST_f_f (nearbyint, -281474976710656.75, -281474976710657.0);
5225   TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0);
5226   TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0);
5227 #endif
5228
5229   END (nearbyint);
5230 }
5231
5232 static void
5233 nextafter_test (void)
5234 {
5235
5236   START (nextafter);
5237
5238   TEST_ff_f (nextafter, 0, 0, 0);
5239   TEST_ff_f (nextafter, minus_zero, 0, 0);
5240   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
5241   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
5242
5243   TEST_ff_f (nextafter, 9, 9, 9);
5244   TEST_ff_f (nextafter, -9, -9, -9);
5245   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
5246   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
5247
5248   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
5249   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
5250   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
5251
5252   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
5253                          LDBL_MAX, DBL_MAX, FLT_MAX);
5254   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty, OVERFLOW_EXCEPTION);
5255   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty, OVERFLOW_EXCEPTION);
5256
5257 #ifdef TEST_LDOUBLE
5258   // XXX Enable once gcc is fixed.
5259   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
5260 #endif
5261
5262   /* XXX We need the hexadecimal FP number representation here for further
5263      tests.  */
5264
5265   END (nextafter);
5266 }
5267
5268
5269 static void
5270 nexttoward_test (void)
5271 {
5272   START (nexttoward);
5273   TEST_ff_f (nexttoward, 0, 0, 0);
5274   TEST_ff_f (nexttoward, minus_zero, 0, 0);
5275   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
5276   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
5277
5278   TEST_ff_f (nexttoward, 9, 9, 9);
5279   TEST_ff_f (nexttoward, -9, -9, -9);
5280   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
5281   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
5282
5283   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
5284   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
5285   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
5286
5287   /* XXX We need the hexadecimal FP number representation here for further
5288      tests.  */
5289
5290   END (nexttoward);
5291 }
5292
5293
5294 static void
5295 pow_test (void)
5296 {
5297
5298   errno = 0;
5299   FUNC(pow) (0, 0);
5300   if (errno == ENOSYS)
5301     /* Function not implemented.  */
5302     return;
5303
5304   START (pow);
5305
5306   TEST_ff_f (pow, 0, 0, 1);
5307   TEST_ff_f (pow, 0, minus_zero, 1);
5308   TEST_ff_f (pow, minus_zero, 0, 1);
5309   TEST_ff_f (pow, minus_zero, minus_zero, 1);
5310
5311   TEST_ff_f (pow, 10, 0, 1);
5312   TEST_ff_f (pow, 10, minus_zero, 1);
5313   TEST_ff_f (pow, -10, 0, 1);
5314   TEST_ff_f (pow, -10, minus_zero, 1);
5315
5316   TEST_ff_f (pow, nan_value, 0, 1);
5317   TEST_ff_f (pow, nan_value, minus_zero, 1);
5318
5319
5320 #ifndef TEST_INLINE
5321   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
5322   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
5323   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
5324   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
5325
5326   TEST_ff_f (pow, 0.9L, plus_infty, 0);
5327   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
5328   TEST_ff_f (pow, -0.9L, plus_infty, 0);
5329   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
5330
5331   TEST_ff_f (pow, 1.1L, minus_infty, 0);
5332   TEST_ff_f (pow, plus_infty, minus_infty, 0);
5333   TEST_ff_f (pow, -1.1L, minus_infty, 0);
5334   TEST_ff_f (pow, minus_infty, minus_infty, 0);
5335
5336   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
5337   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
5338   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
5339   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
5340
5341   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
5342   TEST_ff_f (pow, plus_infty, 1, plus_infty);
5343   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
5344
5345   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
5346   TEST_ff_f (pow, plus_infty, -1, 0);
5347   TEST_ff_f (pow, plus_infty, -1e7L, 0);
5348
5349   TEST_ff_f (pow, minus_infty, 1, minus_infty);
5350   TEST_ff_f (pow, minus_infty, 11, minus_infty);
5351   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
5352
5353   TEST_ff_f (pow, minus_infty, 2, plus_infty);
5354   TEST_ff_f (pow, minus_infty, 12, plus_infty);
5355   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
5356   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
5357   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
5358   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
5359   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
5360
5361   TEST_ff_f (pow, minus_infty, -1, minus_zero);
5362   TEST_ff_f (pow, minus_infty, -11, minus_zero);
5363   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
5364
5365   TEST_ff_f (pow, minus_infty, -2, 0);
5366   TEST_ff_f (pow, minus_infty, -12, 0);
5367   TEST_ff_f (pow, minus_infty, -1002, 0);
5368   TEST_ff_f (pow, minus_infty, -0.1L, 0);
5369   TEST_ff_f (pow, minus_infty, -1.1L, 0);
5370   TEST_ff_f (pow, minus_infty, -11.1L, 0);
5371   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
5372 #endif
5373
5374   TEST_ff_f (pow, nan_value, nan_value, nan_value);
5375   TEST_ff_f (pow, 0, nan_value, nan_value);
5376   TEST_ff_f (pow, 1, nan_value, 1);
5377   TEST_ff_f (pow, -1, nan_value, nan_value);
5378   TEST_ff_f (pow, nan_value, 1, nan_value);
5379   TEST_ff_f (pow, nan_value, -1, nan_value);
5380
5381   /* pow (x, NaN) == NaN.  */
5382   TEST_ff_f (pow, 3.0, nan_value, nan_value);
5383   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
5384   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
5385   TEST_ff_f (pow, -3.0, nan_value, nan_value);
5386   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
5387
5388   TEST_ff_f (pow, nan_value, 3.0, nan_value);
5389   TEST_ff_f (pow, nan_value, -3.0, nan_value);
5390   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
5391   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
5392   TEST_ff_f (pow, nan_value, 2.5, nan_value);
5393   TEST_ff_f (pow, nan_value, -2.5, nan_value);
5394
5395   TEST_ff_f (pow, 1, plus_infty, 1);
5396   TEST_ff_f (pow, -1, plus_infty, 1);
5397   TEST_ff_f (pow, 1, minus_infty, 1);
5398   TEST_ff_f (pow, -1, minus_infty, 1);
5399   TEST_ff_f (pow, 1, 1, 1);
5400   TEST_ff_f (pow, 1, -1, 1);
5401   TEST_ff_f (pow, 1, 1.25, 1);
5402   TEST_ff_f (pow, 1, -1.25, 1);
5403   TEST_ff_f (pow, 1, 0x1p62L, 1);
5404   TEST_ff_f (pow, 1, 0x1p63L, 1);
5405   TEST_ff_f (pow, 1, 0x1p64L, 1);
5406   TEST_ff_f (pow, 1, 0x1p72L, 1);
5407
5408   /* pow (x, +-0) == 1.  */
5409   TEST_ff_f (pow, plus_infty, 0, 1);
5410   TEST_ff_f (pow, plus_infty, minus_zero, 1);
5411   TEST_ff_f (pow, minus_infty, 0, 1);
5412   TEST_ff_f (pow, minus_infty, minus_zero, 1);
5413   TEST_ff_f (pow, 32.75L, 0, 1);
5414   TEST_ff_f (pow, 32.75L, minus_zero, 1);
5415   TEST_ff_f (pow, -32.75L, 0, 1);
5416   TEST_ff_f (pow, -32.75L, minus_zero, 1);
5417   TEST_ff_f (pow, 0x1p72L, 0, 1);
5418   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
5419   TEST_ff_f (pow, 0x1p-72L, 0, 1);
5420   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
5421
5422   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5423   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5424   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
5425   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
5426
5427   errno = 0;
5428   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5429   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5430   errno = 0;
5431   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5432   check_int ("errno for pow(0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5433   errno = 0;
5434   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5435   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5436   errno = 0;
5437   TEST_ff_f (pow, minus_zero, -11L, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5438   check_int ("errno for pow(-0,-odd) == ERANGE", errno, ERANGE, 0, 0, 0);
5439
5440   errno = 0;
5441   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5442   check_int ("errno for pow(0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5443   errno = 0;
5444   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5445   check_int ("errno for pow(0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5446   errno = 0;
5447   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5448   check_int ("errno for pow(-0,-even) == ERANGE", errno, ERANGE, 0, 0, 0);
5449   errno = 0;
5450   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5451   check_int ("errno for pow(-0,-num) == ERANGE", errno, ERANGE, 0, 0, 0);
5452
5453   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty, OVERFLOW_EXCEPTION);
5454   TEST_ff_f (pow, 10, -0x1p72L, 0);
5455   /* Bug 13873: OVERFLOW exception may be missing.  */
5456   TEST_ff_f (pow, max_value, max_value, plus_infty, OVERFLOW_EXCEPTION_OK);
5457   /* Bug 13872: spurious OVERFLOW exception may be present.  */
5458   TEST_ff_f (pow, 10, -max_value, 0, OVERFLOW_EXCEPTION_OK);
5459
5460   TEST_ff_f (pow, 0, 1, 0);
5461   TEST_ff_f (pow, 0, 11, 0);
5462
5463   TEST_ff_f (pow, minus_zero, 1, minus_zero);
5464   TEST_ff_f (pow, minus_zero, 11, minus_zero);
5465
5466   TEST_ff_f (pow, 0, 2, 0);
5467   TEST_ff_f (pow, 0, 11.1L, 0);
5468
5469   TEST_ff_f (pow, minus_zero, 2, 0);
5470   TEST_ff_f (pow, minus_zero, 11.1L, 0);
5471   TEST_ff_f (pow, 0, plus_infty, 0);
5472   TEST_ff_f (pow, minus_zero, plus_infty, 0);
5473
5474 #ifndef TEST_INLINE
5475   /* pow (x, +inf) == +inf for |x| > 1.  */
5476   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
5477
5478   /* pow (x, +inf) == +0 for |x| < 1.  */
5479   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
5480
5481   /* pow (x, -inf) == +0 for |x| > 1.  */
5482   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
5483
5484   /* pow (x, -inf) == +inf for |x| < 1.  */
5485   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
5486 #endif
5487
5488   /* pow (+inf, y) == +inf for y > 0.  */
5489   TEST_ff_f (pow, plus_infty, 2, plus_infty);
5490
5491   /* pow (+inf, y) == +0 for y < 0.  */
5492   TEST_ff_f (pow, plus_infty, -1, 0.0);
5493
5494   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
5495   TEST_ff_f (pow, minus_infty, 27, minus_infty);
5496
5497   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
5498   TEST_ff_f (pow, minus_infty, 28, plus_infty);
5499
5500   /* pow (-inf, y) == -0 for y an odd integer < 0. */
5501   TEST_ff_f (pow, minus_infty, -3, minus_zero);
5502   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
5503   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
5504
5505   /* pow (+0, y) == +0 for y an odd integer > 0.  */
5506   TEST_ff_f (pow, 0.0, 27, 0.0);
5507
5508   /* pow (-0, y) == -0 for y an odd integer > 0.  */
5509   TEST_ff_f (pow, minus_zero, 27, minus_zero);
5510
5511   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
5512   TEST_ff_f (pow, 0.0, 4, 0.0);
5513
5514   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
5515   TEST_ff_f (pow, minus_zero, 4, 0.0);
5516
5517   TEST_ff_f (pow, 16, 0.25L, 2);
5518   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
5519   TEST_ff_f (pow, 2, 4, 16);
5520   TEST_ff_f (pow, 256, 8, 0x1p64L);
5521
5522   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
5523
5524 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
5525   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
5526 #endif
5527
5528   END (pow);
5529 }
5530
5531
5532 static void
5533 pow_test_tonearest (void)
5534 {
5535   int save_round_mode;
5536   errno = 0;
5537   FUNC(pow) (0, 0);
5538   if (errno == ENOSYS)
5539     /* Function not implemented.  */
5540     return;
5541
5542   START (pow_tonearest);
5543
5544   save_round_mode = fegetround ();
5545
5546   if (!fesetround (FE_TONEAREST))
5547     {
5548       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5549       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5550     }
5551
5552   fesetround (save_round_mode);
5553
5554   END (pow_tonearest);
5555 }
5556
5557
5558 static void
5559 pow_test_towardzero (void)
5560 {
5561   int save_round_mode;
5562   errno = 0;
5563   FUNC(pow) (0, 0);
5564   if (errno == ENOSYS)
5565     /* Function not implemented.  */
5566     return;
5567
5568   START (pow_towardzero);
5569
5570   save_round_mode = fegetround ();
5571
5572   if (!fesetround (FE_TOWARDZERO))
5573     {
5574       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5575       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5576     }
5577
5578   fesetround (save_round_mode);
5579
5580   END (pow_towardzero);
5581 }
5582
5583
5584 static void
5585 pow_test_downward (void)
5586 {
5587   int save_round_mode;
5588   errno = 0;
5589   FUNC(pow) (0, 0);
5590   if (errno == ENOSYS)
5591     /* Function not implemented.  */
5592     return;
5593
5594   START (pow_downward);
5595
5596   save_round_mode = fegetround ();
5597
5598   if (!fesetround (FE_DOWNWARD))
5599     {
5600       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5601       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5602     }
5603
5604   fesetround (save_round_mode);
5605
5606   END (pow_downward);
5607 }
5608
5609
5610 static void
5611 pow_test_upward (void)
5612 {
5613   int save_round_mode;
5614   errno = 0;
5615   FUNC(pow) (0, 0);
5616   if (errno == ENOSYS)
5617     /* Function not implemented.  */
5618     return;
5619
5620   START (pow_upward);
5621
5622   save_round_mode = fegetround ();
5623
5624   if (!fesetround (FE_UPWARD))
5625     {
5626       TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L);
5627       TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L);
5628     }
5629
5630   fesetround (save_round_mode);
5631
5632   END (pow_upward);
5633 }
5634
5635
5636 static void
5637 remainder_test (void)
5638 {
5639   errno = 0;
5640   FUNC(remainder) (1.625, 1.0);
5641   if (errno == ENOSYS)
5642     /* Function not implemented.  */
5643     return;
5644
5645   START (remainder);
5646
5647   errno = 0;
5648   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
5649   check_int ("errno for remainder(1, 0) = EDOM ", errno, EDOM, 0, 0, 0);
5650   errno = 0;
5651   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
5652   check_int ("errno for remainder(1, -0) = EDOM ", errno, EDOM, 0, 0, 0);
5653   errno = 0;
5654   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
5655   check_int ("errno for remainder(INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
5656   errno = 0;
5657   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
5658   check_int ("errno for remainder(-INF, 1) = EDOM ", errno, EDOM, 0, 0, 0);
5659   errno = 0;
5660   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
5661   check_int ("errno for remainder(NAN, NAN) unchanged", errno, 0, 0, 0, 0);
5662   errno = 0;
5663   TEST_ff_f (remainder, 0, nan_value, nan_value);
5664   check_int ("errno for remainder(0, NAN) unchanged", errno, 0, 0, 0, 0);
5665   errno = 0;
5666   TEST_ff_f (remainder, nan_value, 0, nan_value);
5667   check_int ("errno for remainder(NaN, 0) unchanged", errno, 0, 0, 0, 0);
5668
5669   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
5670   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
5671   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
5672   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
5673   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
5674   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
5675
5676   END (remainder);
5677 }
5678
5679 static void
5680 remquo_test (void)
5681 {
5682   /* x is needed.  */
5683   int x;
5684
5685   errno = 0;
5686   FUNC(remquo) (1.625, 1.0, &x);
5687   if (errno == ENOSYS)
5688     /* Function not implemented.  */
5689     return;
5690
5691   START (remquo);
5692
5693   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
5694   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
5695   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
5696   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
5697   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
5698
5699   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
5700   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
5701   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
5702   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
5703
5704   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
5705   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
5706
5707   END (remquo);
5708 }
5709
5710 static void
5711 rint_test (void)
5712 {
5713   START (rint);
5714
5715   TEST_f_f (rint, 0.0, 0.0);
5716   TEST_f_f (rint, minus_zero, minus_zero);
5717   TEST_f_f (rint, plus_infty, plus_infty);
5718   TEST_f_f (rint, minus_infty, minus_infty);
5719
5720   /* Default rounding mode is round to even.  */
5721   TEST_f_f (rint, 0.5, 0.0);
5722   TEST_f_f (rint, 1.5, 2.0);
5723   TEST_f_f (rint, 2.5, 2.0);
5724   TEST_f_f (rint, 3.5, 4.0);
5725   TEST_f_f (rint, 4.5, 4.0);
5726   TEST_f_f (rint, -0.5, -0.0);
5727   TEST_f_f (rint, -1.5, -2.0);
5728   TEST_f_f (rint, -2.5, -2.0);
5729   TEST_f_f (rint, -3.5, -4.0);
5730   TEST_f_f (rint, -4.5, -4.0);
5731   TEST_f_f (rint, 0.1, 0.0);
5732   TEST_f_f (rint, 0.25, 0.0);
5733   TEST_f_f (rint, 0.625, 1.0);
5734   TEST_f_f (rint, -0.1, -0.0);
5735   TEST_f_f (rint, -0.25, -0.0);
5736   TEST_f_f (rint, -0.625, -1.0);
5737   TEST_f_f (rint, 262144.75, 262145.0);
5738   TEST_f_f (rint, 262142.75, 262143.0);
5739   TEST_f_f (rint, 524286.75, 524287.0);
5740   TEST_f_f (rint, 524288.75, 524289.0);
5741   TEST_f_f (rint, 1048576.75, 1048577.0);
5742   TEST_f_f (rint, 2097152.75, 2097153.0);
5743   TEST_f_f (rint, -1048576.75, -1048577.0);
5744   TEST_f_f (rint, -2097152.75, -2097153.0);
5745 #ifndef TEST_FLOAT
5746   TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
5747   TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
5748   TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
5749   TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
5750   TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
5751   TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
5752   TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
5753   TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
5754   TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
5755   TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
5756 #endif
5757 #ifdef TEST_LDOUBLE
5758   /* The result can only be represented in long double.  */
5759   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
5760   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
5761   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
5762   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
5763   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
5764
5765 # if LDBL_MANT_DIG > 100
5766   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
5767   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
5768   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
5769 # endif
5770
5771   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
5772   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
5773   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
5774   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
5775   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
5776
5777 # if LDBL_MANT_DIG > 100
5778   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
5779   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
5780   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
5781
5782   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
5783   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
5784   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
5785   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
5786   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
5787   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
5788
5789   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
5790   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
5791   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
5792   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
5793   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
5794   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
5795 # endif
5796
5797   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
5798   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
5799   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
5800   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
5801   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
5802
5803   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
5804   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
5805   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
5806   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
5807   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
5808
5809   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
5810   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
5811   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
5812   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
5813   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
5814
5815   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
5816   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
5817   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
5818   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
5819   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
5820
5821   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
5822   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
5823   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
5824   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
5825   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
5826 #endif
5827
5828   END (rint);
5829 }
5830
5831 static void
5832 rint_test_tonearest (void)
5833 {
5834   int save_round_mode;
5835   START (rint_tonearest);
5836
5837   save_round_mode = fegetround ();
5838
5839   if (!fesetround (FE_TONEAREST))
5840     {
5841       TEST_f_f (rint, 2.0, 2.0);
5842       TEST_f_f (rint, 1.5, 2.0);
5843       TEST_f_f (rint, 1.0, 1.0);
5844       TEST_f_f (rint, 0.5, 0.0);
5845       TEST_f_f (rint, 0.0, 0.0);
5846       TEST_f_f (rint, minus_zero, minus_zero);
5847       TEST_f_f (rint, -0.5, -0.0);
5848       TEST_f_f (rint, -1.0, -1.0);
5849       TEST_f_f (rint, -1.5, -2.0);
5850       TEST_f_f (rint, -2.0, -2.0);
5851       TEST_f_f (rint, 0.1, 0.0);
5852       TEST_f_f (rint, 0.25, 0.0);
5853       TEST_f_f (rint, 0.625, 1.0);
5854       TEST_f_f (rint, -0.1, -0.0);
5855       TEST_f_f (rint, -0.25, -0.0);
5856       TEST_f_f (rint, -0.625, -1.0);
5857       TEST_f_f (rint, 1048576.75, 1048577.0);
5858       TEST_f_f (rint, 2097152.75, 2097153.0);
5859       TEST_f_f (rint, -1048576.75, -1048577.0);
5860       TEST_f_f (rint, -2097152.75, -2097153.0);
5861 #ifndef TEST_FLOAT
5862       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
5863       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
5864       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
5865       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
5866       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
5867       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
5868       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
5869       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
5870       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
5871       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
5872 #endif
5873 #ifdef TEST_LDOUBLE
5874       /* The result can only be represented in long double.  */
5875       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
5876       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
5877       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
5878       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
5879       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
5880 # if LDBL_MANT_DIG > 100
5881       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
5882       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
5883       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
5884 # endif
5885       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
5886       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
5887       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
5888       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
5889       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
5890 # if LDBL_MANT_DIG > 100
5891       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
5892       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
5893       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
5894
5895       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
5896       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
5897       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
5898       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
5899       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
5900       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
5901
5902       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
5903       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
5904       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
5905       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
5906       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
5907       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
5908 # endif
5909 #endif
5910     }
5911
5912   fesetround (save_round_mode);
5913
5914   END (rint_tonearest);
5915 }
5916
5917 static void
5918 rint_test_towardzero (void)
5919 {
5920   int save_round_mode;
5921   START (rint_towardzero);
5922
5923   save_round_mode = fegetround ();
5924
5925   if (!fesetround (FE_TOWARDZERO))
5926     {
5927       TEST_f_f (rint, 2.0, 2.0);
5928       TEST_f_f (rint, 1.5, 1.0);
5929       TEST_f_f (rint, 1.0, 1.0);
5930       TEST_f_f (rint, 0.5, 0.0);
5931       TEST_f_f (rint, 0.0, 0.0);
5932       TEST_f_f (rint, minus_zero, minus_zero);
5933       TEST_f_f (rint, -0.5, -0.0);
5934       TEST_f_f (rint, -1.0, -1.0);
5935       TEST_f_f (rint, -1.5, -1.0);
5936       TEST_f_f (rint, -2.0, -2.0);
5937       TEST_f_f (rint, 0.1, 0.0);
5938       TEST_f_f (rint, 0.25, 0.0);
5939       TEST_f_f (rint, 0.625, 0.0);
5940       TEST_f_f (rint, -0.1, -0.0);
5941       TEST_f_f (rint, -0.25, -0.0);
5942       TEST_f_f (rint, -0.625, -0.0);
5943       TEST_f_f (rint, 1048576.75, 1048576.0);
5944       TEST_f_f (rint, 2097152.75, 2097152.0);
5945       TEST_f_f (rint, -1048576.75, -1048576.0);
5946       TEST_f_f (rint, -2097152.75, -2097152.0);
5947 #ifndef TEST_FLOAT
5948       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
5949       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
5950       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
5951       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
5952       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
5953       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
5954       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
5955       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
5956       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
5957       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
5958 #endif
5959 #ifdef TEST_LDOUBLE
5960       /* The result can only be represented in long double.  */
5961       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
5962       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
5963       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
5964       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
5965       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
5966 # if LDBL_MANT_DIG > 100
5967       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
5968       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
5969       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
5970 # endif
5971       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
5972       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
5973       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
5974       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
5975       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
5976 # if LDBL_MANT_DIG > 100
5977       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
5978       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
5979       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
5980
5981       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
5982       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
5983       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
5984       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
5985       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
5986       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
5987
5988       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
5989       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
5990       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
5991       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
5992       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
5993       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
5994 # endif
5995 #endif
5996     }
5997
5998   fesetround (save_round_mode);
5999
6000   END (rint_towardzero);
6001 }
6002
6003 static void
6004 rint_test_downward (void)
6005 {
6006   int save_round_mode;
6007   START (rint_downward);
6008
6009   save_round_mode = fegetround ();
6010
6011   if (!fesetround (FE_DOWNWARD))
6012     {
6013       TEST_f_f (rint, 2.0, 2.0);
6014       TEST_f_f (rint, 1.5, 1.0);
6015       TEST_f_f (rint, 1.0, 1.0);
6016       TEST_f_f (rint, 0.5, 0.0);
6017       TEST_f_f (rint, 0.0, 0.0);
6018       TEST_f_f (rint, minus_zero, minus_zero);
6019       TEST_f_f (rint, -0.5, -1.0);
6020       TEST_f_f (rint, -1.0, -1.0);
6021       TEST_f_f (rint, -1.5, -2.0);
6022       TEST_f_f (rint, -2.0, -2.0);
6023       TEST_f_f (rint, 0.1, 0.0);
6024       TEST_f_f (rint, 0.25, 0.0);
6025       TEST_f_f (rint, 0.625, 0.0);
6026       TEST_f_f (rint, -0.1, -1.0);
6027       TEST_f_f (rint, -0.25, -1.0);
6028       TEST_f_f (rint, -0.625, -1.0);
6029       TEST_f_f (rint, 1048576.75, 1048576.0);
6030       TEST_f_f (rint, 2097152.75, 2097152.0);
6031       TEST_f_f (rint, -1048576.75, -1048577.0);
6032       TEST_f_f (rint, -2097152.75, -2097153.0);
6033 #ifndef TEST_FLOAT
6034       TEST_f_f (rint, 70368744177664.75, 70368744177664.0);
6035       TEST_f_f (rint, 140737488355328.75, 140737488355328.0);
6036       TEST_f_f (rint, 281474976710656.75, 281474976710656.0);
6037       TEST_f_f (rint, 562949953421312.75, 562949953421312.0);
6038       TEST_f_f (rint, 1125899906842624.75, 1125899906842624.0);
6039       TEST_f_f (rint, -70368744177664.75, -70368744177665.0);
6040       TEST_f_f (rint, -140737488355328.75, -140737488355329.0);
6041       TEST_f_f (rint, -281474976710656.75, -281474976710657.0);
6042       TEST_f_f (rint, -562949953421312.75, -562949953421313.0);
6043       TEST_f_f (rint, -1125899906842624.75, -1125899906842625.0);
6044 #endif
6045 #ifdef TEST_LDOUBLE
6046       /* The result can only be represented in long double.  */
6047       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
6048       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
6049       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
6050       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
6051       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
6052 # if LDBL_MANT_DIG > 100
6053       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
6054       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
6055       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
6056 # endif
6057       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
6058       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
6059       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
6060       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
6061       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
6062 # if LDBL_MANT_DIG > 100
6063       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
6064       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
6065       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
6066
6067       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
6068       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
6069       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
6070       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
6071       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
6072       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
6073
6074       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
6075       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
6076       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
6077       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
6078       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
6079       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
6080 # endif
6081 #endif
6082     }
6083
6084   fesetround (save_round_mode);
6085
6086   END (rint_downward);
6087 }
6088
6089 static void
6090 rint_test_upward (void)
6091 {
6092   int save_round_mode;
6093   START (rint_upward);
6094
6095   save_round_mode = fegetround ();
6096
6097   if (!fesetround (FE_UPWARD))
6098     {
6099       TEST_f_f (rint, 2.0, 2.0);
6100       TEST_f_f (rint, 1.5, 2.0);
6101       TEST_f_f (rint, 1.0, 1.0);
6102       TEST_f_f (rint, 0.5, 1.0);
6103       TEST_f_f (rint, 0.0, 0.0);
6104       TEST_f_f (rint, minus_zero, minus_zero);
6105       TEST_f_f (rint, -0.5, -0.0);
6106       TEST_f_f (rint, -1.0, -1.0);
6107       TEST_f_f (rint, -1.5, -1.0);
6108       TEST_f_f (rint, -2.0, -2.0);
6109       TEST_f_f (rint, 0.1, 1.0);
6110       TEST_f_f (rint, 0.25, 1.0);
6111       TEST_f_f (rint, 0.625, 1.0);
6112       TEST_f_f (rint, -0.1, -0.0);
6113       TEST_f_f (rint, -0.25, -0.0);
6114       TEST_f_f (rint, -0.625, -0.0);
6115       TEST_f_f (rint, 1048576.75, 1048577.0);
6116       TEST_f_f (rint, 2097152.75, 2097153.0);
6117       TEST_f_f (rint, -1048576.75, -1048576.0);
6118       TEST_f_f (rint, -2097152.75, -2097152.0);
6119 #ifndef TEST_FLOAT
6120       TEST_f_f (rint, 70368744177664.75, 70368744177665.0);
6121       TEST_f_f (rint, 140737488355328.75, 140737488355329.0);
6122       TEST_f_f (rint, 281474976710656.75, 281474976710657.0);
6123       TEST_f_f (rint, 562949953421312.75, 562949953421313.0);
6124       TEST_f_f (rint, 1125899906842624.75, 1125899906842625.0);
6125       TEST_f_f (rint, -70368744177664.75, -70368744177664.0);
6126       TEST_f_f (rint, -140737488355328.75, -140737488355328.0);
6127       TEST_f_f (rint, -281474976710656.75, -281474976710656.0);
6128       TEST_f_f (rint, -562949953421312.75, -562949953421312.0);
6129       TEST_f_f (rint, -1125899906842624.75, -1125899906842624.0);
6130 #endif
6131 #ifdef TEST_LDOUBLE
6132       /* The result can only be represented in long double.  */
6133       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
6134       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
6135       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
6136       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
6137       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
6138 # if LDBL_MANT_DIG > 100
6139       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
6140       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
6141       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
6142 # endif
6143       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
6144       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
6145       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
6146       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
6147       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
6148 # if LDBL_MANT_DIG > 100
6149       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
6150       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
6151       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
6152
6153       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
6154       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
6155       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
6156       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
6157       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
6158       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.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, -9007199254740991.0L);
6164       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
6165       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
6166 # endif
6167 #endif
6168     }
6169
6170   fesetround (save_round_mode);
6171
6172   END (rint_upward);
6173 }
6174
6175 static void
6176 round_test (void)
6177 {
6178   START (round);
6179
6180   TEST_f_f (round, 0, 0);
6181   TEST_f_f (round, minus_zero, minus_zero);
6182   TEST_f_f (round, 0.2L, 0.0);
6183   TEST_f_f (round, -0.2L, minus_zero);
6184   TEST_f_f (round, 0.5, 1.0);
6185   TEST_f_f (round, -0.5, -1.0);
6186   TEST_f_f (round, 0.8L, 1.0);
6187   TEST_f_f (round, -0.8L, -1.0);
6188   TEST_f_f (round, 1.5, 2.0);
6189   TEST_f_f (round, -1.5, -2.0);
6190   TEST_f_f (round, 0.1, 0.0);
6191   TEST_f_f (round, 0.25, 0.0);
6192   TEST_f_f (round, 0.625, 1.0);
6193   TEST_f_f (round, -0.1, -0.0);
6194   TEST_f_f (round, -0.25, -0.0);
6195   TEST_f_f (round, -0.625, -1.0);
6196   TEST_f_f (round, 2097152.5, 2097153);
6197   TEST_f_f (round, -2097152.5, -2097153);
6198
6199 #ifdef TEST_LDOUBLE
6200   /* The result can only be represented in long double.  */
6201   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
6202   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
6203   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
6204   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
6205   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
6206 # if LDBL_MANT_DIG > 100
6207   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
6208   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
6209   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
6210 # endif
6211
6212   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
6213   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
6214   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
6215   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
6216   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
6217 # if LDBL_MANT_DIG > 100
6218   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
6219   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
6220   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
6221 # endif
6222
6223   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
6224   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
6225   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
6226   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
6227   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
6228
6229   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
6230   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
6231   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
6232   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
6233   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
6234
6235 # if LDBL_MANT_DIG > 100
6236   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
6237   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
6238   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
6239   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
6240   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
6241   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
6242
6243   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
6244   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
6245   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
6246   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
6247   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
6248   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
6249 # endif
6250
6251   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
6252   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
6253   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
6254   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
6255   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
6256
6257   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
6258   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
6259   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
6260   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
6261   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
6262
6263   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
6264   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
6265   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
6266   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
6267   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
6268 #endif
6269
6270   END (round);
6271 }
6272
6273
6274 static void
6275 scalb_test (void)
6276 {
6277
6278   START (scalb);
6279
6280   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
6281   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
6282
6283   TEST_ff_f (scalb, 0, nan_value, nan_value);
6284   TEST_ff_f (scalb, 1, nan_value, nan_value);
6285
6286   TEST_ff_f (scalb, 1, 0, 1);
6287   TEST_ff_f (scalb, -1, 0, -1);
6288
6289   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
6290   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
6291
6292   TEST_ff_f (scalb, 0, 2, 0);
6293   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
6294   TEST_ff_f (scalb, 0, 0, 0);
6295   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
6296   TEST_ff_f (scalb, 0, -1, 0);
6297   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
6298   TEST_ff_f (scalb, 0, minus_infty, 0);
6299   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
6300
6301   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
6302   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
6303   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
6304   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
6305   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
6306   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
6307
6308   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
6309   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
6310
6311   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
6312   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
6313   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
6314   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
6315
6316   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6317   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
6318
6319   TEST_ff_f (scalb, nan_value, 1, nan_value);
6320   TEST_ff_f (scalb, 1, nan_value, nan_value);
6321   TEST_ff_f (scalb, nan_value, 0, nan_value);
6322   TEST_ff_f (scalb, 0, nan_value, nan_value);
6323   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
6324   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
6325   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
6326
6327   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
6328   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
6329
6330   END (scalb);
6331 }
6332
6333
6334 static void
6335 scalbn_test (void)
6336 {
6337
6338   START (scalbn);
6339
6340   TEST_fi_f (scalbn, 0, 0, 0);
6341   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
6342
6343   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
6344   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
6345   TEST_fi_f (scalbn, nan_value, 1, nan_value);
6346
6347   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
6348   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
6349
6350   TEST_fi_f (scalbn, 1, 0L, 1);
6351
6352   TEST_fi_f (scalbn, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6353   TEST_fi_f (scalbn, 1, INT_MIN, plus_zero);
6354   TEST_fi_f (scalbn, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6355   TEST_fi_f (scalbn, max_value, INT_MIN, plus_zero);
6356   TEST_fi_f (scalbn, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6357   TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero);
6358   TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6359   TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero);
6360
6361   END (scalbn);
6362 }
6363
6364
6365 static void
6366 scalbln_test (void)
6367 {
6368
6369   START (scalbln);
6370
6371   TEST_fl_f (scalbln, 0, 0, 0);
6372   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
6373
6374   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
6375   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
6376   TEST_fl_f (scalbln, nan_value, 1, nan_value);
6377
6378   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
6379   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
6380
6381   TEST_fl_f (scalbln, 1, 0L, 1);
6382
6383   TEST_fi_f (scalbln, 1, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6384   TEST_fi_f (scalbln, 1, INT_MIN, plus_zero);
6385   TEST_fi_f (scalbln, max_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6386   TEST_fi_f (scalbln, max_value, INT_MIN, plus_zero);
6387   TEST_fi_f (scalbln, min_value, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6388   TEST_fi_f (scalbln, min_value, INT_MIN, plus_zero);
6389   TEST_fi_f (scalbln, min_value / 4, INT_MAX, plus_infty, OVERFLOW_EXCEPTION);
6390   TEST_fi_f (scalbln, min_value / 4, INT_MIN, plus_zero);
6391
6392   TEST_fi_f (scalbln, 1, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6393   TEST_fi_f (scalbln, 1, LONG_MIN, plus_zero);
6394   TEST_fi_f (scalbln, max_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6395   TEST_fi_f (scalbln, max_value, LONG_MIN, plus_zero);
6396   TEST_fi_f (scalbln, min_value, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6397   TEST_fi_f (scalbln, min_value, LONG_MIN, plus_zero);
6398   TEST_fi_f (scalbln, min_value / 4, LONG_MAX, plus_infty, OVERFLOW_EXCEPTION);
6399   TEST_fi_f (scalbln, min_value / 4, LONG_MIN, plus_zero);
6400
6401 #if LONG_MAX >= 0x100000000
6402   TEST_fi_f (scalbln, 1, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6403   TEST_fi_f (scalbln, 1, -0x88000000L, plus_zero);
6404   TEST_fi_f (scalbln, max_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6405   TEST_fi_f (scalbln, max_value, -0x88000000L, plus_zero);
6406   TEST_fi_f (scalbln, min_value, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6407   TEST_fi_f (scalbln, min_value, -0x88000000L, plus_zero);
6408   TEST_fi_f (scalbln, min_value / 4, 0x88000000L, plus_infty, OVERFLOW_EXCEPTION);
6409   TEST_fi_f (scalbln, min_value / 4, -0x88000000L, plus_zero);
6410 #endif
6411
6412   END (scalbn);
6413 }
6414
6415
6416 static void
6417 signbit_test (void)
6418 {
6419
6420   START (signbit);
6421
6422   TEST_f_b (signbit, 0, 0);
6423   TEST_f_b (signbit, minus_zero, 1);
6424   TEST_f_b (signbit, plus_infty, 0);
6425   TEST_f_b (signbit, minus_infty, 1);
6426
6427   /* signbit (x) != 0 for x < 0.  */
6428   TEST_f_b (signbit, -1, 1);
6429   /* signbit (x) == 0 for x >= 0.  */
6430   TEST_f_b (signbit, 1, 0);
6431
6432   END (signbit);
6433 }
6434
6435
6436 static void
6437 sin_test (void)
6438 {
6439   errno = 0;
6440   FUNC(sin) (0);
6441   if (errno == ENOSYS)
6442     /* Function not implemented.  */
6443     return;
6444
6445   START (sin);
6446
6447   TEST_f_f (sin, 0, 0);
6448   TEST_f_f (sin, minus_zero, minus_zero);
6449   errno = 0;
6450   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
6451   check_int ("errno for sin(+inf) == EDOM", errno, EDOM, 0, 0, 0);
6452   errno = 0;
6453   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
6454   check_int ("errno for sin(-inf) == EDOM", errno, EDOM, 0, 0, 0);
6455   errno = 0;
6456   TEST_f_f (sin, nan_value, nan_value);
6457   check_int ("errno for sin(NaN) unchanged", errno, 0, 0, 0, 0);
6458
6459   TEST_f_f (sin, M_PI_6l, 0.5);
6460   TEST_f_f (sin, -M_PI_6l, -0.5);
6461   TEST_f_f (sin, M_PI_2l, 1);
6462   TEST_f_f (sin, -M_PI_2l, -1);
6463   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
6464
6465   TEST_f_f (sin, 0x1p65, -0.047183876212354673805106149805700013943218L);
6466   TEST_f_f (sin, -0x1p65, 0.047183876212354673805106149805700013943218L);
6467
6468 #ifdef TEST_DOUBLE
6469   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
6470   TEST_f_f (sin, 2.522464e-1, 2.4957989804940911e-1);
6471 #endif
6472
6473 #ifndef TEST_FLOAT
6474   TEST_f_f (sin, 1e22, -0.8522008497671888017727058937530293682618L);
6475   TEST_f_f (sin, 0x1p1023, 0.5631277798508840134529434079444683477104L);
6476 #endif
6477
6478 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
6479   TEST_f_f (sin, 0x1p16383L, 0.3893629985894208126948115852610595405563L);
6480 #endif
6481
6482   END (sin);
6483
6484 }
6485
6486
6487 static void
6488 sin_test_tonearest (void)
6489 {
6490   int save_round_mode;
6491   errno = 0;
6492   FUNC(sin) (0);
6493   if (errno == ENOSYS)
6494     /* Function not implemented.  */
6495     return;
6496
6497   START (sin_tonearest);
6498
6499   save_round_mode = fegetround ();
6500
6501   if (!fesetround (FE_TONEAREST))
6502     {
6503       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6504       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6505       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6506       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6507       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6508       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6509       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6510       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6511       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6512       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6513     }
6514
6515   fesetround (save_round_mode);
6516
6517   END (sin_tonearest);
6518 }
6519
6520
6521 static void
6522 sin_test_towardzero (void)
6523 {
6524   int save_round_mode;
6525   errno = 0;
6526   FUNC(sin) (0);
6527   if (errno == ENOSYS)
6528     /* Function not implemented.  */
6529     return;
6530
6531   START (sin_towardzero);
6532
6533   save_round_mode = fegetround ();
6534
6535   if (!fesetround (FE_TOWARDZERO))
6536     {
6537       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6538       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6539       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6540       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6541       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6542       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6543       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6544       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6545       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6546       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6547     }
6548
6549   fesetround (save_round_mode);
6550
6551   END (sin_towardzero);
6552 }
6553
6554
6555 static void
6556 sin_test_downward (void)
6557 {
6558   int save_round_mode;
6559   errno = 0;
6560   FUNC(sin) (0);
6561   if (errno == ENOSYS)
6562     /* Function not implemented.  */
6563     return;
6564
6565   START (sin_downward);
6566
6567   save_round_mode = fegetround ();
6568
6569   if (!fesetround (FE_DOWNWARD))
6570     {
6571       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6572       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6573       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6574       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6575       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6576       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6577       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6578       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6579       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6580       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6581     }
6582
6583   fesetround (save_round_mode);
6584
6585   END (sin_downward);
6586 }
6587
6588
6589 static void
6590 sin_test_upward (void)
6591 {
6592   int save_round_mode;
6593   errno = 0;
6594   FUNC(sin) (0);
6595   if (errno == ENOSYS)
6596     /* Function not implemented.  */
6597     return;
6598
6599   START (sin_upward);
6600
6601   save_round_mode = fegetround ();
6602
6603   if (!fesetround (FE_UPWARD))
6604     {
6605       TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L);
6606       TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L);
6607       TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L);
6608       TEST_f_f (sin, 4, -0.7568024953079282513726390945118290941359L);
6609       TEST_f_f (sin, 5, -0.9589242746631384688931544061559939733525L);
6610       TEST_f_f (sin, 6, -0.2794154981989258728115554466118947596280L);
6611       TEST_f_f (sin, 7, 0.6569865987187890903969990915936351779369L);
6612       TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L);
6613       TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L);
6614       TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L);
6615     }
6616
6617   fesetround (save_round_mode);
6618
6619   END (sin_upward);
6620 }
6621
6622
6623 static void
6624 sincos_test (void)
6625 {
6626   FLOAT sin_res, cos_res;
6627
6628   errno = 0;
6629   FUNC(sincos) (0, &sin_res, &cos_res);
6630   if (errno == ENOSYS)
6631     /* Function not implemented.  */
6632     return;
6633
6634   START (sincos);
6635
6636   /* sincos is treated differently because it returns void.  */
6637   TEST_extra (sincos, 0, 0, 1);
6638
6639   TEST_extra (sincos, minus_zero, minus_zero, 1);
6640   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
6641   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
6642   TEST_extra (sincos, nan_value, nan_value, nan_value);
6643
6644   TEST_extra (sincos, M_PI_2l, 1, 0);
6645   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
6646   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
6647   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
6648
6649   TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
6650   TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L);
6651
6652 #ifdef TEST_DOUBLE
6653   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
6654 #endif
6655
6656 #ifndef TEST_FLOAT
6657   TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L);
6658   TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L);
6659 #endif
6660
6661 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
6662   TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L);
6663 #endif
6664
6665   END (sincos);
6666 }
6667
6668 static void
6669 sinh_test (void)
6670 {
6671   errno = 0;
6672   FUNC(sinh) (0.7L);
6673   if (errno == ENOSYS)
6674     /* Function not implemented.  */
6675     return;
6676
6677   START (sinh);
6678   TEST_f_f (sinh, 0, 0);
6679   TEST_f_f (sinh, minus_zero, minus_zero);
6680
6681 #ifndef TEST_INLINE
6682   TEST_f_f (sinh, plus_infty, plus_infty);
6683   TEST_f_f (sinh, minus_infty, minus_infty);
6684 #endif
6685   TEST_f_f (sinh, nan_value, nan_value);
6686
6687   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
6688   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
6689
6690   END (sinh);
6691 }
6692
6693
6694 static void
6695 sinh_test_tonearest (void)
6696 {
6697   int save_round_mode;
6698   errno = 0;
6699   FUNC(sinh) (0);
6700   if (errno == ENOSYS)
6701     /* Function not implemented.  */
6702     return;
6703
6704   START (sinh_tonearest);
6705
6706   save_round_mode = fegetround ();
6707
6708   if (!fesetround (FE_TONEAREST))
6709     {
6710       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
6711       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
6712       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
6713     }
6714
6715   fesetround (save_round_mode);
6716
6717   END (sinh_tonearest);
6718 }
6719
6720
6721 static void
6722 sinh_test_towardzero (void)
6723 {
6724   int save_round_mode;
6725   errno = 0;
6726   FUNC(sinh) (0);
6727   if (errno == ENOSYS)
6728     /* Function not implemented.  */
6729     return;
6730
6731   START (sinh_towardzero);
6732
6733   save_round_mode = fegetround ();
6734
6735   if (!fesetround (FE_TOWARDZERO))
6736     {
6737       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
6738       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
6739       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
6740     }
6741
6742   fesetround (save_round_mode);
6743
6744   END (sinh_towardzero);
6745 }
6746
6747
6748 static void
6749 sinh_test_downward (void)
6750 {
6751   int save_round_mode;
6752   errno = 0;
6753   FUNC(sinh) (0);
6754   if (errno == ENOSYS)
6755     /* Function not implemented.  */
6756     return;
6757
6758   START (sinh_downward);
6759
6760   save_round_mode = fegetround ();
6761
6762   if (!fesetround (FE_DOWNWARD))
6763     {
6764       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
6765       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
6766       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
6767     }
6768
6769   fesetround (save_round_mode);
6770
6771   END (sinh_downward);
6772 }
6773
6774
6775 static void
6776 sinh_test_upward (void)
6777 {
6778   int save_round_mode;
6779   errno = 0;
6780   FUNC(sinh) (0);
6781   if (errno == ENOSYS)
6782     /* Function not implemented.  */
6783     return;
6784
6785   START (sinh_upward);
6786
6787   save_round_mode = fegetround ();
6788
6789   if (!fesetround (FE_UPWARD))
6790     {
6791       TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L);
6792       TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L);
6793       TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L);
6794     }
6795
6796   fesetround (save_round_mode);
6797
6798   END (sinh_upward);
6799 }
6800
6801
6802 static void
6803 sqrt_test (void)
6804 {
6805   errno = 0;
6806   FUNC(sqrt) (1);
6807   if (errno == ENOSYS)
6808     /* Function not implemented.  */
6809     return;
6810
6811   START (sqrt);
6812
6813   TEST_f_f (sqrt, 0, 0);
6814   TEST_f_f (sqrt, nan_value, nan_value);
6815   TEST_f_f (sqrt, plus_infty, plus_infty);
6816
6817   TEST_f_f (sqrt, minus_zero, minus_zero);
6818
6819   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
6820   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
6821   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
6822   TEST_f_f (sqrt, nan_value, nan_value);
6823
6824   TEST_f_f (sqrt, 2209, 47);
6825   TEST_f_f (sqrt, 4, 2);
6826   TEST_f_f (sqrt, 2, M_SQRT2l);
6827   TEST_f_f (sqrt, 0.25, 0.5);
6828   TEST_f_f (sqrt, 6642.25, 81.5);
6829   TEST_f_f (sqrt, 15190.5625L, 123.25L);
6830   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
6831
6832   END (sqrt);
6833 }
6834
6835
6836 static void
6837 tan_test (void)
6838 {
6839   errno = 0;
6840   FUNC(tan) (0);
6841   if (errno == ENOSYS)
6842     /* Function not implemented.  */
6843     return;
6844
6845   START (tan);
6846
6847   TEST_f_f (tan, 0, 0);
6848   TEST_f_f (tan, minus_zero, minus_zero);
6849   errno = 0;
6850   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
6851   check_int ("errno for tan(Inf) == EDOM", errno, EDOM, 0, 0, 0);
6852   errno = 0;
6853   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
6854   check_int ("errno for tan(-Inf) == EDOM", errno, EDOM, 0, 0, 0);
6855   errno = 0;
6856   TEST_f_f (tan, nan_value, nan_value);
6857   check_int ("errno for tan(NaN) == 0", errno, 0, 0, 0, 0);
6858
6859   TEST_f_f (tan, M_PI_4l, 1);
6860   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
6861
6862   TEST_f_f (tan, 0x1p65, -0.0472364872359047946798414219288370688827L);
6863   TEST_f_f (tan, -0x1p65, 0.0472364872359047946798414219288370688827L);
6864
6865 #ifndef TEST_FLOAT
6866   TEST_f_f (tan, 1e22, -1.628778225606898878549375936939548513545L);
6867   TEST_f_f (tan, 0x1p1023, -0.6814476476066215012854144040167365190368L);
6868 #endif
6869
6870 #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384
6871   TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L);
6872 #endif
6873
6874   END (tan);
6875 }
6876
6877
6878 static void
6879 tan_test_tonearest (void)
6880 {
6881   int save_round_mode;
6882   errno = 0;
6883   FUNC(tan) (0);
6884   if (errno == ENOSYS)
6885     /* Function not implemented.  */
6886     return;
6887
6888   START (tan_tonearest);
6889
6890   save_round_mode = fegetround ();
6891
6892   if (!fesetround (FE_TONEAREST))
6893     {
6894       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
6895       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
6896       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
6897       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
6898       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
6899       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
6900       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
6901       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
6902       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
6903       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
6904     }
6905
6906   fesetround (save_round_mode);
6907
6908   END (tan_tonearest);
6909 }
6910
6911
6912 static void
6913 tan_test_towardzero (void)
6914 {
6915   int save_round_mode;
6916   errno = 0;
6917   FUNC(tan) (0);
6918   if (errno == ENOSYS)
6919     /* Function not implemented.  */
6920     return;
6921
6922   START (tan_towardzero);
6923
6924   save_round_mode = fegetround ();
6925
6926   if (!fesetround (FE_TOWARDZERO))
6927     {
6928       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
6929       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
6930       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
6931       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
6932       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
6933       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
6934       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
6935       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
6936       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
6937       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
6938     }
6939
6940   fesetround (save_round_mode);
6941
6942   END (tan_towardzero);
6943 }
6944
6945
6946 static void
6947 tan_test_downward (void)
6948 {
6949   int save_round_mode;
6950   errno = 0;
6951   FUNC(tan) (0);
6952   if (errno == ENOSYS)
6953     /* Function not implemented.  */
6954     return;
6955
6956   START (tan_downward);
6957
6958   save_round_mode = fegetround ();
6959
6960   if (!fesetround (FE_DOWNWARD))
6961     {
6962       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
6963       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
6964       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
6965       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
6966       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
6967       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
6968       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
6969       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
6970       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
6971       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
6972     }
6973
6974   fesetround (save_round_mode);
6975
6976   END (tan_downward);
6977 }
6978
6979
6980 static void
6981 tan_test_upward (void)
6982 {
6983   int save_round_mode;
6984   errno = 0;
6985   FUNC(tan) (0);
6986   if (errno == ENOSYS)
6987     /* Function not implemented.  */
6988     return;
6989
6990   START (tan_upward);
6991
6992   save_round_mode = fegetround ();
6993
6994   if (!fesetround (FE_UPWARD))
6995     {
6996       TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L);
6997       TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L);
6998       TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L);
6999       TEST_f_f (tan, 4, 1.1578212823495775831373424182673239231198L);
7000       TEST_f_f (tan, 5, -3.3805150062465856369827058794473439087096L);
7001       TEST_f_f (tan, 6, -0.2910061913847491570536995888681755428312L);
7002       TEST_f_f (tan, 7, 0.8714479827243187364564508896003135663222L);
7003       TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L);
7004       TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L);
7005       TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L);
7006     }
7007
7008   fesetround (save_round_mode);
7009
7010   END (tan_upward);
7011 }
7012
7013
7014 static void
7015 tanh_test (void)
7016 {
7017   errno = 0;
7018   FUNC(tanh) (0.7L);
7019   if (errno == ENOSYS)
7020     /* Function not implemented.  */
7021     return;
7022
7023   START (tanh);
7024
7025   TEST_f_f (tanh, 0, 0);
7026   TEST_f_f (tanh, minus_zero, minus_zero);
7027
7028 #ifndef TEST_INLINE
7029   TEST_f_f (tanh, plus_infty, 1);
7030   TEST_f_f (tanh, minus_infty, -1);
7031 #endif
7032   TEST_f_f (tanh, nan_value, nan_value);
7033
7034   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
7035   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
7036
7037   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
7038   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
7039
7040   /* 2^-57  */
7041   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
7042
7043   END (tanh);
7044 }
7045
7046 static void
7047 tgamma_test (void)
7048 {
7049   errno = 0;
7050   FUNC(tgamma) (1);
7051   if (errno == ENOSYS)
7052     /* Function not implemented.  */
7053     return;
7054   feclearexcept (FE_ALL_EXCEPT);
7055
7056   START (tgamma);
7057
7058   TEST_f_f (tgamma, plus_infty, plus_infty);
7059   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7060   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
7061   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
7062   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
7063   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
7064   TEST_f_f (tgamma, nan_value, nan_value);
7065
7066   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
7067   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
7068
7069   TEST_f_f (tgamma, 1, 1);
7070   TEST_f_f (tgamma, 4, 6);
7071
7072   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
7073   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
7074
7075   END (tgamma);
7076 }
7077
7078
7079 static void
7080 trunc_test (void)
7081 {
7082   START (trunc);
7083
7084   TEST_f_f (trunc, plus_infty, plus_infty);
7085   TEST_f_f (trunc, minus_infty, minus_infty);
7086   TEST_f_f (trunc, nan_value, nan_value);
7087
7088   TEST_f_f (trunc, 0, 0);
7089   TEST_f_f (trunc, minus_zero, minus_zero);
7090   TEST_f_f (trunc, 0.1, 0);
7091   TEST_f_f (trunc, 0.25, 0);
7092   TEST_f_f (trunc, 0.625, 0);
7093   TEST_f_f (trunc, -0.1, minus_zero);
7094   TEST_f_f (trunc, -0.25, minus_zero);
7095   TEST_f_f (trunc, -0.625, minus_zero);
7096   TEST_f_f (trunc, 1, 1);
7097   TEST_f_f (trunc, -1, -1);
7098   TEST_f_f (trunc, 1.625, 1);
7099   TEST_f_f (trunc, -1.625, -1);
7100
7101   TEST_f_f (trunc, 1048580.625L, 1048580L);
7102   TEST_f_f (trunc, -1048580.625L, -1048580L);
7103
7104   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
7105   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
7106
7107   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
7108   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
7109
7110 #ifdef TEST_LDOUBLE
7111   /* The result can only be represented in long double.  */
7112   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
7113   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
7114   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
7115   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
7116   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
7117
7118 # if LDBL_MANT_DIG > 100
7119   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
7120   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
7121   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
7122 # endif
7123
7124   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
7125   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
7126   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
7127   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
7128   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
7129
7130 # if LDBL_MANT_DIG > 100
7131   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
7132   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
7133   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
7134 # endif
7135
7136   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
7137   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
7138   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
7139   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
7140   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
7141
7142 # if LDBL_MANT_DIG > 100
7143   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
7144   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
7145   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
7146   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
7147   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
7148   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
7149 # endif
7150
7151   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
7152   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
7153   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
7154   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
7155   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
7156
7157 # if LDBL_MANT_DIG > 100
7158   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
7159   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
7160   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
7161   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
7162   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
7163   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
7164 # endif
7165
7166   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
7167   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
7168   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
7169   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
7170   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
7171
7172   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
7173   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
7174   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
7175   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
7176   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
7177
7178   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
7179   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
7180   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
7181   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
7182   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
7183 #endif
7184
7185   END (trunc);
7186 }
7187
7188 static void
7189 y0_test (void)
7190 {
7191   FLOAT s, c;
7192   errno = 0;
7193   FUNC (sincos) (0, &s, &c);
7194   if (errno == ENOSYS)
7195     /* Required function not implemented.  */
7196     return;
7197   FUNC(y0) (1);
7198   if (errno == ENOSYS)
7199     /* Function not implemented.  */
7200     return;
7201
7202   /* y0 is the Bessel function of the second kind of order 0 */
7203   START (y0);
7204
7205   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
7206   TEST_f_f (y0, 0.0, minus_infty);
7207   TEST_f_f (y0, nan_value, nan_value);
7208   TEST_f_f (y0, plus_infty, 0);
7209
7210   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
7211   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
7212   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
7213   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
7214   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
7215   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
7216   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
7217
7218   TEST_f_f (y0, 0x1.3ffp+74L, 1.818984347516051243459467456433028748678e-12L);
7219
7220 #ifndef TEST_FLOAT
7221   TEST_f_f (y0, 0x1.ff00000000002p+840L, 1.846591691699331493194965158699937660696e-127L);
7222 #endif
7223
7224   END (y0);
7225 }
7226
7227
7228 static void
7229 y1_test (void)
7230 {
7231   FLOAT s, c;
7232   errno = 0;
7233   FUNC (sincos) (0, &s, &c);
7234   if (errno == ENOSYS)
7235     /* Required function not implemented.  */
7236     return;
7237   FUNC(y1) (1);
7238   if (errno == ENOSYS)
7239     /* Function not implemented.  */
7240     return;
7241
7242   /* y1 is the Bessel function of the second kind of order 1 */
7243   START (y1);
7244
7245   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
7246   TEST_f_f (y1, 0.0, minus_infty);
7247   TEST_f_f (y1, plus_infty, 0);
7248   TEST_f_f (y1, nan_value, nan_value);
7249
7250   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
7251   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
7252   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
7253   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
7254   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
7255   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
7256   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
7257
7258   TEST_f_f (y1, 0x1.27e204p+99L, -8.881610148467797208469612080785210013461e-16L);
7259
7260 #ifndef TEST_FLOAT
7261   TEST_f_f (y1, 0x1.001000001p+593L, 3.927269966354206207832593635798954916263e-90L);
7262 #endif
7263
7264   END (y1);
7265 }
7266
7267
7268 static void
7269 yn_test (void)
7270 {
7271   FLOAT s, c;
7272   errno = 0;
7273   FUNC (sincos) (0, &s, &c);
7274   if (errno == ENOSYS)
7275     /* Required function not implemented.  */
7276     return;
7277   FUNC(yn) (1, 1);
7278   if (errno == ENOSYS)
7279     /* Function not implemented.  */
7280     return;
7281
7282   /* yn is the Bessel function of the second kind of order n */
7283   START (yn);
7284
7285   /* yn (0, x) == y0 (x)  */
7286   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
7287   TEST_ff_f (yn, 0, 0.0, minus_infty);
7288   TEST_ff_f (yn, 0, nan_value, nan_value);
7289   TEST_ff_f (yn, 0, plus_infty, 0);
7290
7291   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
7292   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
7293   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
7294   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
7295   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
7296   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
7297   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
7298
7299   /* yn (1, x) == y1 (x)  */
7300   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
7301   TEST_ff_f (yn, 1, 0.0, minus_infty);
7302   TEST_ff_f (yn, 1, plus_infty, 0);
7303   TEST_ff_f (yn, 1, nan_value, nan_value);
7304
7305   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
7306   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
7307   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
7308   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
7309   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
7310   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
7311   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
7312
7313   /* yn (3, x)  */
7314   TEST_ff_f (yn, 3, plus_infty, 0);
7315   TEST_ff_f (yn, 3, nan_value, nan_value);
7316
7317   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
7318   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
7319   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
7320   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
7321   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
7322
7323   /* yn (10, x)  */
7324   TEST_ff_f (yn, 10, plus_infty, 0);
7325   TEST_ff_f (yn, 10, nan_value, nan_value);
7326
7327   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
7328   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
7329   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
7330   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
7331   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
7332
7333   END (yn);
7334
7335 }
7336
7337
7338 static void
7339 significand_test (void)
7340 {
7341   /* significand returns the mantissa of the exponential representation.  */
7342   START (significand);
7343
7344   TEST_f_f (significand, 4.0, 1.0);
7345   TEST_f_f (significand, 6.0, 1.5);
7346   TEST_f_f (significand, 8.0, 1.0);
7347
7348   END (significand);
7349 }
7350
7351
7352 static void
7353 initialize (void)
7354 {
7355   fpstack_test ("start *init*");
7356   plus_zero = 0.0;
7357   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
7358
7359   minus_zero = FUNC(copysign) (0.0, -1.0);
7360   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
7361                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
7362   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
7363                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
7364   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
7365                       LDBL_MAX, DBL_MAX, FLT_MAX);
7366   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
7367                       LDBL_MIN, DBL_MIN, FLT_MIN);
7368
7369   (void) &plus_zero;
7370   (void) &nan_value;
7371   (void) &minus_zero;
7372   (void) &plus_infty;
7373   (void) &minus_infty;
7374   (void) &max_value;
7375   (void) &min_value;
7376
7377   /* Clear all exceptions.  From now on we must not get random exceptions.  */
7378   feclearexcept (FE_ALL_EXCEPT);
7379
7380   /* Test to make sure we start correctly.  */
7381   fpstack_test ("end *init*");
7382 }
7383
7384 /* Definitions of arguments for argp functions.  */
7385 static const struct argp_option options[] =
7386 {
7387   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
7388   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
7389   { "no-max-error", 'f', NULL, 0,
7390     "Don't output maximal errors of functions"},
7391   { "no-points", 'p', NULL, 0,
7392     "Don't output results of functions invocations"},
7393   { "ignore-max-ulp", 'i', "yes/no", 0,
7394     "Ignore given maximal errors"},
7395   { NULL, 0, NULL, 0, NULL }
7396 };
7397
7398 /* Short description of program.  */
7399 static const char doc[] = "Math test suite: " TEST_MSG ;
7400
7401 /* Prototype for option handler.  */
7402 static error_t parse_opt (int key, char *arg, struct argp_state *state);
7403
7404 /* Data structure to communicate with argp functions.  */
7405 static struct argp argp =
7406 {
7407   options, parse_opt, NULL, doc,
7408 };
7409
7410
7411 /* Handle program arguments.  */
7412 static error_t
7413 parse_opt (int key, char *arg, struct argp_state *state)
7414 {
7415   switch (key)
7416     {
7417     case 'f':
7418       output_max_error = 0;
7419       break;
7420     case 'i':
7421       if (strcmp (arg, "yes") == 0)
7422         ignore_max_ulp = 1;
7423       else if (strcmp (arg, "no") == 0)
7424         ignore_max_ulp = 0;
7425       break;
7426     case 'p':
7427       output_points = 0;
7428       break;
7429     case 'u':
7430       output_ulps = 1;
7431       break;
7432     case 'v':
7433       if (optarg)
7434         verbose = (unsigned int) strtoul (optarg, NULL, 0);
7435       else
7436         verbose = 3;
7437       break;
7438     default:
7439       return ARGP_ERR_UNKNOWN;
7440     }
7441   return 0;
7442 }
7443
7444 #if 0
7445 /* function to check our ulp calculation.  */
7446 void
7447 check_ulp (void)
7448 {
7449   int i;
7450
7451   FLOAT u, diff, ulp;
7452   /* This gives one ulp.  */
7453   u = FUNC(nextafter) (10, 20);
7454   check_equal (10.0, u, 1, &diff, &ulp);
7455   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
7456
7457   /* This gives one more ulp.  */
7458   u = FUNC(nextafter) (u, 20);
7459   check_equal (10.0, u, 2, &diff, &ulp);
7460   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
7461
7462   /* And now calculate 100 ulp.  */
7463   for (i = 2; i < 100; i++)
7464     u = FUNC(nextafter) (u, 20);
7465   check_equal (10.0, u, 100, &diff, &ulp);
7466   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
7467 }
7468 #endif
7469
7470 int
7471 main (int argc, char **argv)
7472 {
7473
7474   int remaining;
7475
7476   verbose = 1;
7477   output_ulps = 0;
7478   output_max_error = 1;
7479   output_points = 1;
7480   /* XXX set to 0 for releases.  */
7481   ignore_max_ulp = 0;
7482
7483   /* Parse and process arguments.  */
7484   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
7485
7486   if (remaining != argc)
7487     {
7488       fprintf (stderr, "wrong number of arguments");
7489       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
7490       exit (EXIT_FAILURE);
7491     }
7492
7493   if (output_ulps)
7494     {
7495       ulps_file = fopen ("ULPs", "a");
7496       if (ulps_file == NULL)
7497         {
7498           perror ("can't open file `ULPs' for writing: ");
7499           exit (1);
7500         }
7501     }
7502
7503
7504   initialize ();
7505   printf (TEST_MSG);
7506
7507 #if 0
7508   check_ulp ();
7509 #endif
7510
7511   /* Keep the tests a wee bit ordered (according to ISO C99).  */
7512   /* Classification macros:  */
7513   fpclassify_test ();
7514   isfinite_test ();
7515   isnormal_test ();
7516   signbit_test ();
7517
7518   /* Trigonometric functions:  */
7519   acos_test ();
7520   asin_test ();
7521   atan_test ();
7522   atan2_test ();
7523   cos_test ();
7524   cos_test_tonearest ();
7525   cos_test_towardzero ();
7526   cos_test_downward ();
7527   cos_test_upward ();
7528   sin_test ();
7529   sin_test_tonearest ();
7530   sin_test_towardzero ();
7531   sin_test_downward ();
7532   sin_test_upward ();
7533   sincos_test ();
7534   tan_test ();
7535   tan_test_tonearest ();
7536   tan_test_towardzero ();
7537   tan_test_downward ();
7538   tan_test_upward ();
7539
7540   /* Hyperbolic functions:  */
7541   acosh_test ();
7542   asinh_test ();
7543   atanh_test ();
7544   cosh_test ();
7545   cosh_test_tonearest ();
7546   cosh_test_towardzero ();
7547   cosh_test_downward ();
7548   cosh_test_upward ();
7549   sinh_test ();
7550   sinh_test_tonearest ();
7551   sinh_test_towardzero ();
7552   sinh_test_downward ();
7553   sinh_test_upward ();
7554   tanh_test ();
7555
7556   /* Exponential and logarithmic functions:  */
7557   exp_test ();
7558   exp_test_tonearest ();
7559   exp_test_towardzero ();
7560   exp_test_downward ();
7561   exp_test_upward ();
7562   exp10_test ();
7563   exp2_test ();
7564   expm1_test ();
7565   frexp_test ();
7566   ldexp_test ();
7567   log_test ();
7568   log10_test ();
7569   log1p_test ();
7570   log2_test ();
7571   logb_test ();
7572   modf_test ();
7573   ilogb_test ();
7574   scalb_test ();
7575   scalbn_test ();
7576   scalbln_test ();
7577   significand_test ();
7578
7579   /* Power and absolute value functions:  */
7580   cbrt_test ();
7581   fabs_test ();
7582   hypot_test ();
7583   pow_test ();
7584   pow_test_tonearest ();
7585   pow_test_towardzero ();
7586   pow_test_downward ();
7587   pow_test_upward ();
7588   sqrt_test ();
7589
7590   /* Error and gamma functions:  */
7591   erf_test ();
7592   erfc_test ();
7593   gamma_test ();
7594   lgamma_test ();
7595   tgamma_test ();
7596
7597   /* Nearest integer functions:  */
7598   ceil_test ();
7599   floor_test ();
7600   nearbyint_test ();
7601   rint_test ();
7602   rint_test_tonearest ();
7603   rint_test_towardzero ();
7604   rint_test_downward ();
7605   rint_test_upward ();
7606   lrint_test ();
7607   lrint_test_tonearest ();
7608   lrint_test_towardzero ();
7609   lrint_test_downward ();
7610   lrint_test_upward ();
7611   llrint_test ();
7612   llrint_test_tonearest ();
7613   llrint_test_towardzero ();
7614   llrint_test_downward ();
7615   llrint_test_upward ();
7616   round_test ();
7617   lround_test ();
7618   llround_test ();
7619   trunc_test ();
7620
7621   /* Remainder functions:  */
7622   fmod_test ();
7623   remainder_test ();
7624   remquo_test ();
7625
7626   /* Manipulation functions:  */
7627   copysign_test ();
7628   nextafter_test ();
7629   nexttoward_test ();
7630
7631   /* maximum, minimum and positive difference functions */
7632   fdim_test ();
7633   fmax_test ();
7634   fmin_test ();
7635
7636   /* Multiply and add:  */
7637   fma_test ();
7638
7639   /* Complex functions:  */
7640   cabs_test ();
7641   cacos_test ();
7642   cacosh_test ();
7643   carg_test ();
7644   casin_test ();
7645   casinh_test ();
7646   catan_test ();
7647   catanh_test ();
7648   ccos_test ();
7649   ccosh_test ();
7650   cexp_test ();
7651   cimag_test ();
7652   clog10_test ();
7653   clog_test ();
7654   conj_test ();
7655   cpow_test ();
7656   cproj_test ();
7657   creal_test ();
7658   csin_test ();
7659   csinh_test ();
7660   csqrt_test ();
7661   ctan_test ();
7662   ctanh_test ();
7663
7664   /* Bessel functions:  */
7665   j0_test ();
7666   j1_test ();
7667   jn_test ();
7668   y0_test ();
7669   y1_test ();
7670   yn_test ();
7671
7672   if (output_ulps)
7673     fclose (ulps_file);
7674
7675   printf ("\nTest suite completed:\n");
7676   printf ("  %d test cases plus %d tests for exception flags executed.\n",
7677           noTests, noExcTests);
7678   if (noXFails)
7679     printf ("  %d expected failures occurred.\n", noXFails);
7680   if (noXPasses)
7681     printf ("  %d unexpected passes occurred.\n", noXPasses);
7682   if (noErrors)
7683     {
7684       printf ("  %d errors occurred.\n", noErrors);
7685       return 1;
7686     }
7687   printf ("  All tests passed successfully.\n");
7688
7689   return 0;
7690 }
7691
7692 /*
7693  * Local Variables:
7694  * mode:c
7695  * End:
7696  */