math/libm-test.inc

   1 /* Copyright (C) 1997-2006, 2007 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, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 /* Part of testsuite for libm.
  21
  22    This file is processed by a perl script.  The resulting file has to
  23    be included by a master file that defines:
  24
  25    Macros:
  26    FUNC(function): converts general function name (like cos) to
  27    name with correct suffix (e.g. cosl or cosf)
  28    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  29    FLOAT:          floating point type to test
  30    - TEST_MSG:     informal message to be displayed
  31    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  32    chooses one of the parameters as delta for testing
  33    equality
  34    PRINTF_EXPR     Floating point conversion specification to print a variable
  35    of type FLOAT with printf.  PRINTF_EXPR just contains
  36    the specifier, not the percent and width arguments,
  37    e.g. "f".
  38    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  39    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  40
  41 /* This testsuite has currently tests for:
  42    acos, acosh, asin, asinh, atan, atan2, atanh,
  43    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  44    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
  45    frexp, gamma, hypot,
  46    ilogb, isfinite, isinf, isnan, isnormal,
  47    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
  48    j0, j1, jn,
  49    ldexp, lgamma, log, log10, log1p, log2, logb,
  50    modf, nearbyint, nextafter,
  51    pow, remainder, remquo, rint, lrint, llrint,
  52    round, lround, llround,
  53    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
  54    y0, y1, yn, significand
  55
  56    and for the following complex math functions:
  57    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
  58    ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
  59
  60    At the moment the following functions aren't tested:
  61    drem, nan
  62
  63    Parameter handling is primitive in the moment:
  64    --verbose=[0..3] for different levels of output:
  65    0: only error count
  66    1: basic report on failed tests (default)
  67    2: full report on all tests
  68    -v for full output (equals --verbose=3)
  69    -u for generation of an ULPs file
  70  */
  71
  72 /* "Philosophy":
  73
  74    This suite tests some aspects of the correct implementation of
  75    mathematical functions in libm.  Some simple, specific parameters
  76    are tested for correctness but there's no exhaustive
  77    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  78    is also tested.  Correct handling of exceptions is checked
  79    against.  These implemented tests should check all cases that are
  80    specified in ISO C99.
  81
  82    Exception testing: At the moment only divide-by-zero and invalid
  83    exceptions are tested.  Overflow/underflow and inexact exceptions
  84    aren't checked at the moment.
  85
  86    NaN values: There exist signalling and quiet NaNs.  This implementation
  87    only uses quiet NaN as parameter but does not differenciate
  88    between the two kinds of NaNs as result.
  89
  90    Inline functions: Inlining functions should give an improvement in
  91    speed - but not in precission.  The inlined functions return
  92    reasonable values for a reasonable range of input values.  The
  93    result is not necessarily correct for all values and exceptions are
  94    not correctly raised in all cases.  Problematic input and return
  95    values are infinity, not-a-number and minus zero.  This suite
  96    therefore does not check these specific inputs and the exception
  97    handling for inlined mathematical functions - just the "reasonable"
  98    values are checked.
  99
 100    Beware: The tests might fail for any of the following reasons:
 101    - Tests are wrong
 102    - Functions are wrong
 103    - Floating Point Unit not working properly
 104    - Compiler has errors
 105
 106    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 107
 108
 109    To Do: All parameter should be numbers that can be represented as
 110    exact floating point values.  Currently some values cannot be
 111    represented exactly and therefore the result is not the expected
 112    result.  For this we will use 36 digits so that numbers can be
 113    represented exactly.  */
 114
 115 #ifndef _GNU_SOURCE
 116 # define _GNU_SOURCE
 117 #endif
 118
 119 #include "libm-test-ulps.h"
 120 #include <complex.h>
 121 #include <math.h>
 122 #include <float.h>
 123 #include <fenv.h>
 124 #include <limits.h>
 125
 126 #include <errno.h>
 127 #include <stdlib.h>
 128 #include <stdio.h>
 129 #include <string.h>
 130 #include <argp.h>
 131
 132 /* Possible exceptions */
 133 #define NO_EXCEPTION                    0x0
 134 #define INVALID_EXCEPTION               0x1
 135 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 136 /* The next flags signals that those exceptions are allowed but not required.   */
 137 #define INVALID_EXCEPTION_OK            0x4
 138 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x8
 139 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 140 /* Some special test flags, passed togther with exceptions.  */
 141 #define IGNORE_ZERO_INF_SIGN            0x10
 142
 143 /* Various constants (we must supply them precalculated for accuracy).  */
 144 #define M_PI_6l                 .52359877559829887307710723054658383L
 145 #define M_E2l                   7.389056098930650227230427460575008L
 146 #define M_E3l                   20.085536923187667740928529654581719L
 147 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
 148 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */
 149 #define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */
 150 #define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */
 151 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 152 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 153 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 154 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 155 #define M_PI_LOG10El            M_PIl * M_LOG10El
 156 #define M_SQRT_2_2              0.70710678118654752440084436210484903L /* sqrt (2) / 2 */
 157
 158 static FILE *ulps_file; /* File to document difference.  */
 159 static int output_ulps; /* Should ulps printed?  */
 160
 161 static int noErrors;    /* number of errors */
 162 static int noTests;     /* number of tests (without testing exceptions) */
 163 static int noExcTests;  /* number of tests for exception flags */
 164 static int noXFails;    /* number of expected failures.  */
 165 static int noXPasses;   /* number of unexpected passes.  */
 166
 167 static int verbose;
 168 static int output_max_error;    /* Should the maximal errors printed?  */
 169 static int output_points;       /* Should the single function results printed?  */
 170 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 171
 172 static FLOAT minus_zero, plus_zero;
 173 static FLOAT plus_infty, minus_infty, nan_value, max_value, min_value;
 174
 175 static FLOAT max_error, real_max_error, imag_max_error;
 176
 177
 178 #define BUILD_COMPLEX(real, imag) \
 179   ({ __complex__ FLOAT __retval;                                              \
 180      __real__ __retval = (real);                                              \
 181      __imag__ __retval = (imag);                                              \
 182      __retval; })
 183
 184 #define BUILD_COMPLEX_INT(real, imag) \
 185   ({ __complex__ int __retval;                                                \
 186      __real__ __retval = (real);                                              \
 187      __imag__ __retval = (imag);                                              \
 188      __retval; })
 189
 190
 191 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 192                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 193
 194 static void
 195 init_max_error (void)
 196 {
 197   max_error = 0;
 198   real_max_error = 0;
 199   imag_max_error = 0;
 200   feclearexcept (FE_ALL_EXCEPT);
 201 }
 202
 203 static void
 204 set_max_error (FLOAT current, FLOAT *curr_max_error)
 205 {
 206   if (current > *curr_max_error)
 207     *curr_max_error = current;
 208 }
 209
 210
 211 /* Should the message print to screen?  This depends on the verbose flag,
 212    and the test status.  */
 213 static int
 214 print_screen (int ok, int xfail)
 215 {
 216   if (output_points
 217       && (verbose > 1
 218           || (verbose == 1 && ok == xfail)))
 219     return 1;
 220   return 0;
 221 }
 222
 223
 224 /* Should the message print to screen?  This depends on the verbose flag,
 225    and the test status.  */
 226 static int
 227 print_screen_max_error (int ok, int xfail)
 228 {
 229   if (output_max_error
 230       && (verbose > 1
 231           || ((verbose == 1) && (ok == xfail))))
 232     return 1;
 233   return 0;
 234 }
 235
 236 /* Update statistic counters.  */
 237 static void
 238 update_stats (int ok, int xfail)
 239 {
 240   ++noTests;
 241   if (ok && xfail)
 242     ++noXPasses;
 243   else if (!ok && xfail)
 244     ++noXFails;
 245   else if (!ok && !xfail)
 246     ++noErrors;
 247 }
 248
 249 static void
 250 print_ulps (const char *test_name, FLOAT ulp)
 251 {
 252   if (output_ulps)
 253     {
 254       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 255       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 256                CHOOSE("ldouble", "double", "float",
 257                       "ildouble", "idouble", "ifloat"),
 258                FUNC(ceil) (ulp));
 259     }
 260 }
 261
 262 static void
 263 print_function_ulps (const char *function_name, FLOAT ulp)
 264 {
 265   if (output_ulps)
 266     {
 267       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 268       fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 269                CHOOSE("ldouble", "double", "float",
 270                       "ildouble", "idouble", "ifloat"),
 271                FUNC(ceil) (ulp));
 272     }
 273 }
 274
 275
 276 static void
 277 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 278                              FLOAT imag_ulp)
 279 {
 280   if (output_ulps)
 281     {
 282       if (real_ulp != 0.0)
 283         {
 284           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 285           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 286                    CHOOSE("ldouble", "double", "float",
 287                           "ildouble", "idouble", "ifloat"),
 288                    FUNC(ceil) (real_ulp));
 289         }
 290       if (imag_ulp != 0.0)
 291         {
 292           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 293           fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",
 294                    CHOOSE("ldouble", "double", "float",
 295                           "ildouble", "idouble", "ifloat"),
 296                    FUNC(ceil) (imag_ulp));
 297         }
 298
 299
 300     }
 301 }
 302
 303
 304
 305 /* Test if Floating-Point stack hasn't changed */
 306 static void
 307 fpstack_test (const char *test_name)
 308 {
 309 #ifdef i386
 310   static int old_stack;
 311   int sw;
 312
 313   asm ("fnstsw" : "=a" (sw));
 314   sw >>= 11;
 315   sw &= 7;
 316
 317   if (sw != old_stack)
 318     {
 319       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 320               test_name, sw, old_stack);
 321       ++noErrors;
 322       old_stack = sw;
 323     }
 324 #endif
 325 }
 326
 327
 328 static void
 329 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 330 {
 331   int ok = 0;
 332
 333   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 334     {
 335       ok = 1;
 336     }
 337
 338   if (!ok)
 339     print_function_ulps (func_name, max_error);
 340
 341
 342   if (print_screen_max_error (ok, xfail))
 343     {
 344       printf ("Maximal error of `%s'\n", func_name);
 345       printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));
 346       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));
 347     }
 348
 349   update_stats (ok, xfail);
 350 }
 351
 352
 353 static void
 354 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 355                          __complex__ int xfail)
 356 {
 357   int ok = 0;
 358
 359   if ((real_max_error == 0 && imag_max_error == 0)
 360       || (real_max_error <= __real__ allowed
 361           && imag_max_error <= __imag__ allowed
 362           && !ignore_max_ulp))
 363     {
 364       ok = 1;
 365     }
 366
 367   if (!ok)
 368     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 369
 370
 371   if (print_screen_max_error (ok, xfail))
 372     {
 373       printf ("Maximal error of real part of: %s\n", func_name);
 374       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 375               FUNC(ceil) (real_max_error));
 376       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 377               FUNC(ceil) (__real__ allowed));
 378       printf ("Maximal error of imaginary part of: %s\n", func_name);
 379       printf (" is      : %.0" PRINTF_NEXPR " ulp\n",
 380               FUNC(ceil) (imag_max_error));
 381       printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",
 382               FUNC(ceil) (__imag__ allowed));
 383     }
 384
 385   update_stats (ok, xfail);
 386 }
 387
 388
 389 /* Test whether a given exception was raised.  */
 390 static void
 391 test_single_exception (const char *test_name,
 392                        int exception,
 393                        int exc_flag,
 394                        int fe_flag,
 395                        const char *flag_name)
 396 {
 397 #ifndef TEST_INLINE
 398   int ok = 1;
 399   if (exception & exc_flag)
 400     {
 401       if (fetestexcept (fe_flag))
 402         {
 403           if (print_screen (1, 0))
 404             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 405         }
 406       else
 407         {
 408           ok = 0;
 409           if (print_screen (0, 0))
 410             printf ("Failure: %s: Exception \"%s\" not set\n",
 411                     test_name, flag_name);
 412         }
 413     }
 414   else
 415     {
 416       if (fetestexcept (fe_flag))
 417         {
 418           ok = 0;
 419           if (print_screen (0, 0))
 420             printf ("Failure: %s: Exception \"%s\" set\n",
 421                     test_name, flag_name);
 422         }
 423       else
 424         {
 425           if (print_screen (1, 0))
 426             printf ("%s: Exception \"%s\" not set\n", test_name,
 427                     flag_name);
 428         }
 429     }
 430   if (!ok)
 431     ++noErrors;
 432
 433 #endif
 434 }
 435
 436
 437 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 438    allowed but not required exceptions.
 439 */
 440 static void
 441 test_exceptions (const char *test_name, int exception)
 442 {
 443   ++noExcTests;
 444 #ifdef FE_DIVBYZERO
 445   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 446     test_single_exception (test_name, exception,
 447                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 448                            "Divide by zero");
 449 #endif
 450 #ifdef FE_INVALID
 451   if ((exception & INVALID_EXCEPTION_OK) == 0)
 452     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 453                          "Invalid operation");
 454 #endif
 455   feclearexcept (FE_ALL_EXCEPT);
 456 }
 457
 458
 459 static void
 460 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 461                       FLOAT max_ulp, int xfail, int exceptions,
 462                       FLOAT *curr_max_error)
 463 {
 464   int ok = 0;
 465   int print_diff = 0;
 466   FLOAT diff = 0;
 467   FLOAT ulp = 0;
 468
 469   test_exceptions (test_name, exceptions);
 470   if (isnan (computed) && isnan (expected))
 471     ok = 1;
 472   else if (isinf (computed) && isinf (expected))
 473     {
 474       /* Test for sign of infinities.  */
 475       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 476           && signbit (computed) != signbit (expected))
 477         {
 478           ok = 0;
 479           printf ("infinity has wrong sign.\n");
 480         }
 481       else
 482         ok = 1;
 483     }
 484   /* Don't calc ulp for NaNs or infinities.  */
 485   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 486     ok = 0;
 487   else
 488     {
 489       diff = FUNC(fabs) (computed - expected);
 490       /* ilogb (0) isn't allowed.  */
 491       if (expected == 0.0)
 492         ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 493       else
 494         ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 495       set_max_error (ulp, curr_max_error);
 496       print_diff = 1;
 497       if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0
 498           && computed == 0.0 && expected == 0.0
 499           && signbit(computed) != signbit (expected))
 500         ok = 0;
 501       else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp))
 502         ok = 1;
 503       else
 504         {
 505           ok = 0;
 506           print_ulps (test_name, ulp);
 507         }
 508
 509     }
 510   if (print_screen (ok, xfail))
 511     {
 512       if (!ok)
 513         printf ("Failure: ");
 514       printf ("Test: %s\n", test_name);
 515       printf ("Result:\n");
 516       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 517               computed, computed);
 518       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 519               expected, expected);
 520       if (print_diff)
 521         {
 522           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 523                   "\n", diff, diff);
 524           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 525           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 526         }
 527     }
 528   update_stats (ok, xfail);
 529
 530   fpstack_test (test_name);
 531 }
 532
 533
 534 static void
 535 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 536              FLOAT max_ulp, int xfail, int exceptions)
 537 {
 538   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 539                         exceptions, &max_error);
 540 }
 541
 542
 543 static void
 544 check_complex (const char *test_name, __complex__ FLOAT computed,
 545                __complex__ FLOAT expected,
 546                __complex__ FLOAT max_ulp, __complex__ int xfail,
 547                int exception)
 548 {
 549   FLOAT part_comp, part_exp, part_max_ulp;
 550   int part_xfail;
 551   char str[200];
 552
 553   sprintf (str, "Real part of: %s", test_name);
 554   part_comp = __real__ computed;
 555   part_exp = __real__ expected;
 556   part_max_ulp = __real__ max_ulp;
 557   part_xfail = __real__ xfail;
 558
 559   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 560                         exception, &real_max_error);
 561
 562   sprintf (str, "Imaginary part of: %s", test_name);
 563   part_comp = __imag__ computed;
 564   part_exp = __imag__ expected;
 565   part_max_ulp = __imag__ max_ulp;
 566   part_xfail = __imag__ xfail;
 567
 568   /* Don't check again for exceptions, just pass through the
 569      zero/inf sign test.  */
 570   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 571                         exception & IGNORE_ZERO_INF_SIGN,
 572                         &imag_max_error);
 573 }
 574
 575
 576 /* Check that computed and expected values are equal (int values).  */
 577 static void
 578 check_int (const char *test_name, int computed, int expected, int max_ulp,
 579            int xfail, int exceptions)
 580 {
 581   int diff = computed - expected;
 582   int ok = 0;
 583
 584   test_exceptions (test_name, exceptions);
 585   noTests++;
 586   if (abs (diff) <= max_ulp)
 587     ok = 1;
 588
 589   if (!ok)
 590     print_ulps (test_name, diff);
 591
 592   if (print_screen (ok, xfail))
 593     {
 594       if (!ok)
 595         printf ("Failure: ");
 596       printf ("Test: %s\n", test_name);
 597       printf ("Result:\n");
 598       printf (" is:         %d\n", computed);
 599       printf (" should be:  %d\n", expected);
 600     }
 601
 602   update_stats (ok, xfail);
 603   fpstack_test (test_name);
 604 }
 605
 606
 607 /* Check that computed and expected values are equal (long int values).  */
 608 static void
 609 check_long (const char *test_name, long int computed, long int expected,
 610             long int max_ulp, int xfail, int exceptions)
 611 {
 612   long int diff = computed - expected;
 613   int ok = 0;
 614
 615   test_exceptions (test_name, exceptions);
 616   noTests++;
 617   if (labs (diff) <= max_ulp)
 618     ok = 1;
 619
 620   if (!ok)
 621     print_ulps (test_name, diff);
 622
 623   if (print_screen (ok, xfail))
 624     {
 625       if (!ok)
 626         printf ("Failure: ");
 627       printf ("Test: %s\n", test_name);
 628       printf ("Result:\n");
 629       printf (" is:         %ld\n", computed);
 630       printf (" should be:  %ld\n", expected);
 631     }
 632
 633   update_stats (ok, xfail);
 634   fpstack_test (test_name);
 635 }
 636
 637
 638 /* Check that computed value is true/false.  */
 639 static void
 640 check_bool (const char *test_name, int computed, int expected,
 641             long int max_ulp, int xfail, int exceptions)
 642 {
 643   int ok = 0;
 644
 645   test_exceptions (test_name, exceptions);
 646   noTests++;
 647   if ((computed == 0) == (expected == 0))
 648     ok = 1;
 649
 650   if (print_screen (ok, xfail))
 651     {
 652       if (!ok)
 653         printf ("Failure: ");
 654       printf ("Test: %s\n", test_name);
 655       printf ("Result:\n");
 656       printf (" is:         %d\n", computed);
 657       printf (" should be:  %d\n", expected);
 658     }
 659
 660   update_stats (ok, xfail);
 661   fpstack_test (test_name);
 662 }
 663
 664
 665 /* check that computed and expected values are equal (long int values) */
 666 static void
 667 check_longlong (const char *test_name, long long int computed,
 668                 long long int expected,
 669                 long long int max_ulp, int xfail,
 670                 int exceptions)
 671 {
 672   long long int diff = computed - expected;
 673   int ok = 0;
 674
 675   test_exceptions (test_name, exceptions);
 676   noTests++;
 677   if (llabs (diff) <= max_ulp)
 678     ok = 1;
 679
 680   if (!ok)
 681     print_ulps (test_name, diff);
 682
 683   if (print_screen (ok, xfail))
 684     {
 685       if (!ok)
 686         printf ("Failure:");
 687       printf ("Test: %s\n", test_name);
 688       printf ("Result:\n");
 689       printf (" is:         %lld\n", computed);
 690       printf (" should be:  %lld\n", expected);
 691     }
 692
 693   update_stats (ok, xfail);
 694   fpstack_test (test_name);
 695 }
 696
 697
 698
 699 /* This is to prevent messages from the SVID libm emulation.  */
 700 int
 701 matherr (struct exception *x __attribute__ ((unused)))
 702 {
 703   return 1;
 704 }
 705
 706
 707 /****************************************************************************
 708   Tests for single functions of libm.
 709   Please keep them alphabetically sorted!
 710 ****************************************************************************/
 711
 712 static void
 713 acos_test (void)
 714 {
 715   errno = 0;
 716   FUNC(acos) (0);
 717   if (errno == ENOSYS)
 718     /* Function not implemented.  */
 719     return;
 720
 721   START (acos);
 722
 723   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 724   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 725   TEST_f_f (acos, nan_value, nan_value);
 726
 727   /* |x| > 1: */
 728   TEST_f_f (acos, 1.125L, nan_value, INVALID_EXCEPTION);
 729   TEST_f_f (acos, -1.125L, nan_value, INVALID_EXCEPTION);
 730
 731   TEST_f_f (acos, 0, M_PI_2l);
 732   TEST_f_f (acos, minus_zero, M_PI_2l);
 733   TEST_f_f (acos, 1, 0);
 734   TEST_f_f (acos, -1, M_PIl);
 735   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 736   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 737   TEST_f_f (acos, 0.75L, 0.722734247813415611178377352641333362L);
 738   TEST_f_f (acos, 2e-17L, 1.57079632679489659923132169163975144L);
 739   TEST_f_f (acos, 0.0625L, 1.50825556499840522843072005474337068L);
 740   END (acos);
 741 }
 742
 743 static void
 744 acosh_test (void)
 745 {
 746   errno = 0;
 747   FUNC(acosh) (7);
 748   if (errno == ENOSYS)
 749     /* Function not implemented.  */
 750     return;
 751
 752   START (acosh);
 753
 754   TEST_f_f (acosh, plus_infty, plus_infty);
 755   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 756
 757   /* x < 1:  */
 758   TEST_f_f (acosh, -1.125L, nan_value, INVALID_EXCEPTION);
 759
 760   TEST_f_f (acosh, 1, 0);
 761   TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L);
 762
 763   END (acosh);
 764 }
 765
 766 static void
 767 asin_test (void)
 768 {
 769   errno = 0;
 770   FUNC(asin) (0);
 771   if (errno == ENOSYS)
 772     /* Function not implemented.  */
 773     return;
 774
 775   START (asin);
 776
 777   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 778   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 779   TEST_f_f (asin, nan_value, nan_value);
 780
 781   /* asin x == NaN plus invalid exception for |x| > 1.  */
 782   TEST_f_f (asin, 1.125L, nan_value, INVALID_EXCEPTION);
 783   TEST_f_f (asin, -1.125L, nan_value, INVALID_EXCEPTION);
 784
 785   TEST_f_f (asin, 0, 0);
 786   TEST_f_f (asin, minus_zero, minus_zero);
 787   TEST_f_f (asin, 0.5, M_PI_6l);
 788   TEST_f_f (asin, -0.5, -M_PI_6l);
 789   TEST_f_f (asin, 1.0, M_PI_2l);
 790   TEST_f_f (asin, -1.0, -M_PI_2l);
 791   TEST_f_f (asin, 0.75L, 0.848062078981481008052944338998418080L);
 792
 793   END (asin);
 794 }
 795
 796 static void
 797 asinh_test (void)
 798 {
 799   errno = 0;
 800   FUNC(asinh) (0.7L);
 801   if (errno == ENOSYS)
 802     /* Function not implemented.  */
 803     return;
 804
 805   START (asinh);
 806
 807   TEST_f_f (asinh, 0, 0);
 808   TEST_f_f (asinh, minus_zero, minus_zero);
 809 #ifndef TEST_INLINE
 810   TEST_f_f (asinh, plus_infty, plus_infty);
 811   TEST_f_f (asinh, minus_infty, minus_infty);
 812 #endif
 813   TEST_f_f (asinh, nan_value, nan_value);
 814   TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L);
 815
 816   END (asinh);
 817 }
 818
 819 static void
 820 atan_test (void)
 821 {
 822   errno = 0;
 823   FUNC(atan) (0);
 824   if (errno == ENOSYS)
 825     /* Function not implemented.  */
 826     return;
 827
 828   START (atan);
 829
 830   TEST_f_f (atan, 0, 0);
 831   TEST_f_f (atan, minus_zero, minus_zero);
 832
 833   TEST_f_f (atan, plus_infty, M_PI_2l);
 834   TEST_f_f (atan, minus_infty, -M_PI_2l);
 835   TEST_f_f (atan, nan_value, nan_value);
 836
 837   TEST_f_f (atan, 1, M_PI_4l);
 838   TEST_f_f (atan, -1, -M_PI_4l);
 839
 840   TEST_f_f (atan, 0.75L, 0.643501108793284386802809228717322638L);
 841
 842   END (atan);
 843 }
 844
 845
 846
 847 static void
 848 atanh_test (void)
 849 {
 850   errno = 0;
 851   FUNC(atanh) (0.7L);
 852   if (errno == ENOSYS)
 853     /* Function not implemented.  */
 854     return;
 855
 856   START (atanh);
 857
 858
 859   TEST_f_f (atanh, 0, 0);
 860   TEST_f_f (atanh, minus_zero, minus_zero);
 861
 862   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 863   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 864   TEST_f_f (atanh, nan_value, nan_value);
 865
 866   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
 867   TEST_f_f (atanh, 1.125L, nan_value, INVALID_EXCEPTION);
 868   TEST_f_f (atanh, -1.125L, nan_value, INVALID_EXCEPTION);
 869
 870   TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L);
 871
 872   END (atanh);
 873 }
 874
 875 static void
 876 atan2_test (void)
 877 {
 878   errno = 0;
 879   FUNC(atan2) (-0, 1);
 880   if (errno == ENOSYS)
 881     /* Function not implemented.  */
 882     return;
 883
 884   START (atan2);
 885
 886   /* atan2 (0,x) == 0 for x > 0.  */
 887   TEST_ff_f (atan2, 0, 1, 0);
 888
 889   /* atan2 (-0,x) == -0 for x > 0.  */
 890   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
 891
 892   TEST_ff_f (atan2, 0, 0, 0);
 893   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
 894
 895   /* atan2 (+0,x) == +pi for x < 0.  */
 896   TEST_ff_f (atan2, 0, -1, M_PIl);
 897
 898   /* atan2 (-0,x) == -pi for x < 0.  */
 899   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
 900
 901   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
 902   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
 903
 904   /* atan2 (y,+0) == pi/2 for y > 0.  */
 905   TEST_ff_f (atan2, 1, 0, M_PI_2l);
 906
 907   /* atan2 (y,-0) == pi/2 for y > 0.  */
 908   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
 909
 910   /* atan2 (y,+0) == -pi/2 for y < 0.  */
 911   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
 912
 913   /* atan2 (y,-0) == -pi/2 for y < 0.  */
 914   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
 915
 916   /* atan2 (y,inf) == +0 for finite y > 0.  */
 917   TEST_ff_f (atan2, 1, plus_infty, 0);
 918
 919   /* atan2 (y,inf) == -0 for finite y < 0.  */
 920   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
 921
 922   /* atan2(+inf, x) == pi/2 for finite x.  */
 923   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
 924
 925   /* atan2(-inf, x) == -pi/2 for finite x.  */
 926   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
 927
 928   /* atan2 (y,-inf) == +pi for finite y > 0.  */
 929   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
 930
 931   /* atan2 (y,-inf) == -pi for finite y < 0.  */
 932   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
 933
 934   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
 935   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
 936   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
 937   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
 938   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
 939
 940   TEST_ff_f (atan2, 0.75L, 1, 0.643501108793284386802809228717322638L);
 941   TEST_ff_f (atan2, -0.75L, 1.0L, -0.643501108793284386802809228717322638L);
 942   TEST_ff_f (atan2, 0.75L, -1.0L, 2.49809154479650885165983415456218025L);
 943   TEST_ff_f (atan2, -0.75L, -1.0L, -2.49809154479650885165983415456218025L);
 944   TEST_ff_f (atan2, 0.390625L, .00029L, 1.57005392693128974780151246612928941L);
 945   TEST_ff_f (atan2, 1.390625L, 0.9296875L, 0.981498387184244311516296577615519772L);
 946
 947   TEST_ff_f (atan2, -0.00756827042671106339L, -.001792735857538728036L, -1.80338464113663849327153994379639112L);
 948
 949   END (atan2);
 950 }
 951
 952 static void
 953 cabs_test (void)
 954 {
 955   errno = 0;
 956   FUNC(cabs) (BUILD_COMPLEX (0.7L, 12.4L));
 957   if (errno == ENOSYS)
 958     /* Function not implemented.  */
 959     return;
 960
 961   START (cabs);
 962
 963   /* cabs (x + iy) is specified as hypot (x,y) */
 964
 965   /* cabs (+inf + i x) == +inf.  */
 966   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
 967   /* cabs (-inf + i x) == +inf.  */
 968   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
 969
 970   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
 971   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
 972
 973   TEST_c_f (cabs, nan_value, nan_value, nan_value);
 974
 975   /* cabs (x,y) == cabs (y,x).  */
 976   TEST_c_f (cabs, 0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
 977   /* cabs (x,y) == cabs (-x,y).  */
 978   TEST_c_f (cabs, -12.390625L, 0.75L, 12.4133028598606664302388810868156657L);
 979   /* cabs (x,y) == cabs (-y,x).  */
 980   TEST_c_f (cabs, -0.75L, 12.390625L, 12.4133028598606664302388810868156657L);
 981   /* cabs (x,y) == cabs (-x,-y).  */
 982   TEST_c_f (cabs, -12.390625L, -0.75L, 12.4133028598606664302388810868156657L);
 983   /* cabs (x,y) == cabs (-y,-x).  */
 984   TEST_c_f (cabs, -0.75L, -12.390625L, 12.4133028598606664302388810868156657L);
 985   /* cabs (x,0) == fabs (x).  */
 986   TEST_c_f (cabs, -0.75L, 0, 0.75L);
 987   TEST_c_f (cabs, 0.75L, 0, 0.75L);
 988   TEST_c_f (cabs, -1.0L, 0, 1.0L);
 989   TEST_c_f (cabs, 1.0L, 0, 1.0L);
 990   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
 991   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
 992
 993   TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
 994
 995   END (cabs);
 996 }
 997
 998
 999 static void
1000 cacos_test (void)
1001 {
1002   errno = 0;
1003   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1004   if (errno == ENOSYS)
1005     /* Function not implemented.  */
1006     return;
1007
1008   START (cacos);
1009
1010
1011   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1012   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1013   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1014   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1015
1016   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1017   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1018
1019   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1020   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1021
1022   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1023   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1024   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1025   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1026   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1027   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1028
1029   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1030   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1031   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1032   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1033
1034   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1035   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1036   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1037   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1038
1039   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1040   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1041
1042   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1043   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1044
1045   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1046   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1047
1048   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1049   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1050
1051   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1052   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1053
1054   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1055
1056   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1057   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1058
1059   END (cacos, complex);
1060 }
1061
1062 static void
1063 cacosh_test (void)
1064 {
1065   errno = 0;
1066   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1067   if (errno == ENOSYS)
1068     /* Function not implemented.  */
1069     return;
1070
1071   START (cacosh);
1072
1073
1074   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1075   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1076   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1077   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1078   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1079   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1080
1081   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1082   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1083
1084   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1085   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1086   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1087   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1088   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1089   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1090
1091   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1092   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1093   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1094   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1095
1096   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1097   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1098   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1099   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1100
1101   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1102   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1103
1104   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1105   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1106
1107   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1108   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1109
1110   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1111   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1112
1113   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1114   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1115
1116   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1117
1118   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1119   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1120
1121   END (cacosh, complex);
1122 }
1123
1124
1125 static void
1126 carg_test (void)
1127 {
1128   START (carg);
1129
1130   /* carg (x + iy) is specified as atan2 (y, x) */
1131
1132   /* carg (x + i 0) == 0 for x > 0.  */
1133   TEST_c_f (carg, 2.0, 0, 0);
1134   /* carg (x - i 0) == -0 for x > 0.  */
1135   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1136
1137   TEST_c_f (carg, 0, 0, 0);
1138   TEST_c_f (carg, 0, minus_zero, minus_zero);
1139
1140   /* carg (x + i 0) == +pi for x < 0.  */
1141   TEST_c_f (carg, -2.0, 0, M_PIl);
1142
1143   /* carg (x - i 0) == -pi for x < 0.  */
1144   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1145
1146   TEST_c_f (carg, minus_zero, 0, M_PIl);
1147   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1148
1149   /* carg (+0 + i y) == pi/2 for y > 0.  */
1150   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1151
1152   /* carg (-0 + i y) == pi/2 for y > 0.  */
1153   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1154
1155   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1156   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1157
1158   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1159   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1160
1161   /* carg (inf + i y) == +0 for finite y > 0.  */
1162   TEST_c_f (carg, plus_infty, 2.0, 0);
1163
1164   /* carg (inf + i y) == -0 for finite y < 0.  */
1165   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1166
1167   /* carg(x + i inf) == pi/2 for finite x.  */
1168   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1169
1170   /* carg(x - i inf) == -pi/2 for finite x.  */
1171   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1172
1173   /* carg (-inf + i y) == +pi for finite y > 0.  */
1174   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1175
1176   /* carg (-inf + i y) == -pi for finite y < 0.  */
1177   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1178
1179   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1180
1181   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1182
1183   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1184
1185   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1186
1187   TEST_c_f (carg, nan_value, nan_value, nan_value);
1188
1189   END (carg);
1190 }
1191
1192 static void
1193 casin_test (void)
1194 {
1195   errno = 0;
1196   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1197   if (errno == ENOSYS)
1198     /* Function not implemented.  */
1199     return;
1200
1201   START (casin);
1202
1203   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1204   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1205   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1206   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1207
1208   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1209   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1210   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1211   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1212
1213   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1214   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1215   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1216   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1217   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1218   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1219   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1220   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1221
1222   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1223   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1224   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1225   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1226
1227   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1228   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1229   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1230   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1231
1232   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1233   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1234
1235   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1236   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1237
1238   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1239   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1240
1241   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1242   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1243
1244   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1245   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1246
1247   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1248
1249   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1250   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1251
1252   END (casin, complex);
1253 }
1254
1255
1256 static void
1257 casinh_test (void)
1258 {
1259   errno = 0;
1260   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1261   if (errno == ENOSYS)
1262     /* Function not implemented.  */
1263     return;
1264
1265   START (casinh);
1266
1267   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1268   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1269   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1270   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1271
1272   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1273   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1274   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1275   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1276
1277   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1278   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1279   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1280   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1281   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1282   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1283   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1284   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1285
1286   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1287   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1288   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1289   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1290
1291   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1292   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1293   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1294   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1295
1296   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1297   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1298
1299   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1300   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1301
1302   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1303   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1304
1305   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1306   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1307
1308   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1309   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1310
1311   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1312
1313   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1314   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1315
1316   END (casinh, complex);
1317 }
1318
1319
1320 static void
1321 catan_test (void)
1322 {
1323   errno = 0;
1324   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1325   if (errno == ENOSYS)
1326     /* Function not implemented.  */
1327     return;
1328
1329   START (catan);
1330
1331   TEST_c_c (catan, 0, 0, 0, 0);
1332   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1333   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1334   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1335
1336   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1337   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1338   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1339   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1340
1341
1342   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1343   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1344   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1345   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1346   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1347   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1348   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1349   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1350
1351   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1352   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1353   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1354   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1355
1356   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1357   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1358   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1359   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1360
1361   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1362   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1363
1364   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1365   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1366
1367   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1368   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1369
1370   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1371   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1372
1373   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1374   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1375
1376   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1377   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1378
1379   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1380
1381   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1382   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1383
1384   END (catan, complex);
1385 }
1386
1387 static void
1388 catanh_test (void)
1389 {
1390   errno = 0;
1391   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1392   if (errno == ENOSYS)
1393     /* Function not implemented.  */
1394     return;
1395
1396   START (catanh);
1397
1398   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1399   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1400   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1401   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1402
1403   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1404   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1405   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1406   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1407
1408   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1409   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1410   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1411   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1412   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1413   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1414   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1415   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1416
1417   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1418   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1419   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1420   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1421
1422   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1423   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1424   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1425   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1426
1427   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1428   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1429
1430   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1431   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1432
1433   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1434   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1435
1436   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1437   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1438
1439   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1440   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1441
1442   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1443   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1444
1445   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1446
1447   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1448   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1449
1450   END (catanh, complex);
1451 }
1452
1453 static void
1454 cbrt_test (void)
1455 {
1456   errno = 0;
1457   FUNC(cbrt) (8);
1458   if (errno == ENOSYS)
1459     /* Function not implemented.  */
1460     return;
1461
1462   START (cbrt);
1463
1464   TEST_f_f (cbrt, 0.0, 0.0);
1465   TEST_f_f (cbrt, minus_zero, minus_zero);
1466
1467   TEST_f_f (cbrt, plus_infty, plus_infty);
1468   TEST_f_f (cbrt, minus_infty, minus_infty);
1469   TEST_f_f (cbrt, nan_value, nan_value);
1470
1471   TEST_f_f (cbrt, -0.001L, -0.1L);
1472   TEST_f_f (cbrt, 8, 2);
1473   TEST_f_f (cbrt, -27.0, -3.0);
1474   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1475   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1476
1477   END (cbrt);
1478 }
1479
1480
1481 static void
1482 ccos_test (void)
1483 {
1484   errno = 0;
1485   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1486   if (errno == ENOSYS)
1487     /* Function not implemented.  */
1488     return;
1489
1490   START (ccos);
1491
1492   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1493   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1494   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1495   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1496
1497   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1498   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1499   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1500   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1501
1502   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1503   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1504   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1505   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1506
1507   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1508   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1509   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1510   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1511
1512   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1513   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1514   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1515   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1516
1517   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1518   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1519   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1520   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1521
1522   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1523   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1524
1525   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1526   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1527
1528   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1529   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1530
1531   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1532   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1533
1534   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1535   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1536
1537   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1538   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1539
1540   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1541
1542   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1543   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1544
1545   END (ccos, complex);
1546 }
1547
1548
1549 static void
1550 ccosh_test (void)
1551 {
1552   errno = 0;
1553   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1554   if (errno == ENOSYS)
1555     /* Function not implemented.  */
1556     return;
1557
1558   START (ccosh);
1559
1560   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1561   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1562   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1563   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1564
1565   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1566   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1567   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1568   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1569
1570   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1571   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1572   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1573   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1574
1575   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1576   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1577   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1578   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1579
1580   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1581   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1582   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1583   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1584
1585   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1586   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1587   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1588   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1589
1590   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1591   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1592
1593   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1594   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1595
1596   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1597   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1598
1599   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1600   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1601
1602   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1603   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1604
1605   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1606   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1607
1608   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1609
1610   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1611
1612   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1613
1614   END (ccosh, complex);
1615 }
1616
1617
1618 static void
1619 ceil_test (void)
1620 {
1621   START (ceil);
1622
1623   TEST_f_f (ceil, 0.0, 0.0);
1624   TEST_f_f (ceil, minus_zero, minus_zero);
1625   TEST_f_f (ceil, plus_infty, plus_infty);
1626   TEST_f_f (ceil, minus_infty, minus_infty);
1627   TEST_f_f (ceil, nan_value, nan_value);
1628
1629   TEST_f_f (ceil, M_PIl, 4.0);
1630   TEST_f_f (ceil, -M_PIl, -3.0);
1631   TEST_f_f (ceil, 0.1, 1.0);
1632   TEST_f_f (ceil, 0.25, 1.0);
1633   TEST_f_f (ceil, 0.625, 1.0);
1634   TEST_f_f (ceil, -0.1, minus_zero);
1635   TEST_f_f (ceil, -0.25, minus_zero);
1636   TEST_f_f (ceil, -0.625, minus_zero);
1637
1638 #ifdef TEST_LDOUBLE
1639   /* The result can only be represented in long double.  */
1640   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
1641   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
1642   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
1643   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
1644   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
1645
1646   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
1647   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
1648   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
1649   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
1650   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
1651
1652 # if LDBL_MANT_DIG > 100
1653   TEST_f_f (ceil, 4503599627370494.5000000000001L, 4503599627370495.0L);
1654   TEST_f_f (ceil, 4503599627370495.5000000000001L, 4503599627370496.0L);
1655   TEST_f_f (ceil, 4503599627370496.5000000000001L, 4503599627370497.0L);
1656   TEST_f_f (ceil, -4503599627370494.5000000000001L, -4503599627370494.0L);
1657   TEST_f_f (ceil, -4503599627370495.5000000000001L, -4503599627370495.0L);
1658   TEST_f_f (ceil, -4503599627370496.5000000000001L, -4503599627370496.0L);
1659 # endif
1660
1661   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
1662   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
1663   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
1664   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
1665   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
1666
1667   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
1668   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
1669   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
1670   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
1671   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
1672
1673 # if LDBL_MANT_DIG > 100
1674   TEST_f_f (ceil, 9007199254740991.0000000000001L, 9007199254740992.0L);
1675   TEST_f_f (ceil, 9007199254740992.0000000000001L, 9007199254740993.0L);
1676   TEST_f_f (ceil, 9007199254740993.0000000000001L, 9007199254740994.0L);
1677   TEST_f_f (ceil, 9007199254740991.5000000000001L, 9007199254740992.0L);
1678   TEST_f_f (ceil, 9007199254740992.5000000000001L, 9007199254740993.0L);
1679   TEST_f_f (ceil, 9007199254740993.5000000000001L, 9007199254740994.0L);
1680
1681   TEST_f_f (ceil, -9007199254740991.0000000000001L, -9007199254740991.0L);
1682   TEST_f_f (ceil, -9007199254740992.0000000000001L, -9007199254740992.0L);
1683   TEST_f_f (ceil, -9007199254740993.0000000000001L, -9007199254740993.0L);
1684   TEST_f_f (ceil, -9007199254740991.5000000000001L, -9007199254740991.0L);
1685   TEST_f_f (ceil, -9007199254740992.5000000000001L, -9007199254740992.0L);
1686   TEST_f_f (ceil, -9007199254740993.5000000000001L, -9007199254740993.0L);
1687 # endif
1688
1689   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
1690   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
1691   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
1692   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
1693   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
1694
1695   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
1696   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
1697   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
1698   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
1699   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
1700
1701   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
1702   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
1703   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
1704   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
1705   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
1706 #endif
1707
1708   END (ceil);
1709 }
1710
1711
1712 static void
1713 cexp_test (void)
1714 {
1715   errno = 0;
1716   FUNC(cexp) (BUILD_COMPLEX (0, 0));
1717   if (errno == ENOSYS)
1718     /* Function not implemented.  */
1719     return;
1720
1721   START (cexp);
1722
1723   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1724   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1725   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1726   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1727
1728   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1729   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1730
1731   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1732   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1733
1734   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1735   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1736
1737   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1738   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1739
1740   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1741   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1742
1743   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1744   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1745
1746   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1747   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1748   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1749   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1750
1751   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1752   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1753
1754   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1755   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1756
1757   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1758
1759   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1760
1761   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1762   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1763
1764   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1765   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1766   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1767   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1768
1769   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1770   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1771
1772   END (cexp, complex);
1773 }
1774
1775
1776 static void
1777 cimag_test (void)
1778 {
1779   START (cimag);
1780   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1781   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1782   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1783   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1784   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1785   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1786   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1787
1788   END (cimag);
1789 }
1790
1791 static void
1792 clog_test (void)
1793 {
1794   errno = 0;
1795   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1796   if (errno == ENOSYS)
1797     /* Function not implemented.  */
1798     return;
1799
1800   START (clog);
1801
1802   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1803   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1804
1805   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1806   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1807
1808   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1809   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1810
1811   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1812   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1813
1814   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1815   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1816   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1817   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1818   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1819   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1820   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1821   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1822
1823   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1824   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1825   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1826   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1827
1828   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1829   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1830   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1831   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1832
1833   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1834   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1835
1836   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1837   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1838
1839   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1840   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1841   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1842   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1843
1844   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1845   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1846   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1847   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1848
1849   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1850
1851   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
1852   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
1853
1854   END (clog, complex);
1855 }
1856
1857
1858 static void
1859 clog10_test (void)
1860 {
1861   errno = 0;
1862   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
1863   if (errno == ENOSYS)
1864     /* Function not implemented.  */
1865     return;
1866
1867   START (clog10);
1868
1869   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1870   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1871
1872   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1873   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1874
1875   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1876
1877   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1878   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1879
1880   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1881   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1882   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1883   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1884   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1885   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1886   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1887   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1888
1889   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1890   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1891   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1892   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1893
1894   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1895   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1896   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1897   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1898
1899   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1900   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1901
1902   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1903   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1904
1905   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1906   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1907   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1908   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1909
1910   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1911   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1912   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1913   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1914
1915   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1916
1917   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
1918   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
1919
1920   END (clog10, complex);
1921 }
1922
1923
1924 static void
1925 conj_test (void)
1926 {
1927   START (conj);
1928   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1929   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1930   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1931   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1932   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1933   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1934   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1935
1936   END (conj, complex);
1937 }
1938
1939
1940 static void
1941 copysign_test (void)
1942 {
1943   START (copysign);
1944
1945   TEST_ff_f (copysign, 0, 4, 0);
1946   TEST_ff_f (copysign, 0, -4, minus_zero);
1947   TEST_ff_f (copysign, minus_zero, 4, 0);
1948   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1949
1950   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1951   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1952   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1953   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1954
1955   TEST_ff_f (copysign, 0, plus_infty, 0);
1956   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1957   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1958   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1959
1960   /* XXX More correctly we would have to check the sign of the NaN.  */
1961   TEST_ff_f (copysign, nan_value, 0, nan_value);
1962   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1963   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1964   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1965
1966   END (copysign);
1967 }
1968
1969
1970 static void
1971 cos_test (void)
1972 {
1973   errno = 0;
1974   FUNC(cos) (0);
1975   if (errno == ENOSYS)
1976     /* Function not implemented.  */
1977     return;
1978
1979   START (cos);
1980
1981   TEST_f_f (cos, 0, 1);
1982   TEST_f_f (cos, minus_zero, 1);
1983   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1984   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1985   TEST_f_f (cos, nan_value, nan_value);
1986
1987   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1988   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1989   TEST_f_f (cos, M_PI_2l, 0);
1990
1991   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
1992
1993 #ifdef TEST_DOUBLE
1994   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
1995 #endif
1996
1997   END (cos);
1998 }
1999
2000
2001 static void
2002 cosh_test (void)
2003 {
2004   errno = 0;
2005   FUNC(cosh) (0.7L);
2006   if (errno == ENOSYS)
2007     /* Function not implemented.  */
2008     return;
2009
2010   START (cosh);
2011   TEST_f_f (cosh, 0, 1);
2012   TEST_f_f (cosh, minus_zero, 1);
2013
2014 #ifndef TEST_INLINE
2015   TEST_f_f (cosh, plus_infty, plus_infty);
2016   TEST_f_f (cosh, minus_infty, plus_infty);
2017 #endif
2018   TEST_f_f (cosh, nan_value, nan_value);
2019
2020   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2021
2022   END (cosh);
2023 }
2024
2025
2026 static void
2027 cpow_test (void)
2028 {
2029   errno = 0;
2030   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2031   if (errno == ENOSYS)
2032     /* Function not implemented.  */
2033     return;
2034
2035   START (cpow);
2036
2037   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2038   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2039
2040   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2041   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2042
2043   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2044
2045   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2046   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2047   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2048   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2049
2050   END (cpow, complex);
2051 }
2052
2053
2054 static void
2055 cproj_test (void)
2056 {
2057   START (cproj);
2058   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2059   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2060   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2061   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2062
2063   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2064
2065   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2066   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2067   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2068   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2069
2070   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2071   TEST_c_c (cproj, 2.0, 3.0, 0.2857142857142857142857142857142857L, 0.42857142857142857142857142857142855L);
2072
2073   END (cproj, complex);
2074 }
2075
2076
2077 static void
2078 creal_test (void)
2079 {
2080   START (creal);
2081   TEST_c_f (creal, 0.0, 1.0, 0.0);
2082   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2083   TEST_c_f (creal, nan_value, 1.0, nan_value);
2084   TEST_c_f (creal, nan_value, nan_value, nan_value);
2085   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2086   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2087   TEST_c_f (creal, 2.0, 3.0, 2.0);
2088
2089   END (creal);
2090 }
2091
2092 static void
2093 csin_test (void)
2094 {
2095   errno = 0;
2096   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2097   if (errno == ENOSYS)
2098     /* Function not implemented.  */
2099     return;
2100
2101   START (csin);
2102
2103   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2104   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2105   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2106   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2107
2108   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2109   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2110   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2111   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2112
2113   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2114   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2115   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2116   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2117
2118   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2119   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2120   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2121   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2122
2123   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2124   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2125   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2126   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2127
2128   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2129   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2130   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2131   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2132
2133   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2134   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2135
2136   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2137   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2138
2139   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2140   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2141
2142   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2143   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2144
2145   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2146   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2147
2148   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2149   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2150
2151   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2152
2153   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2154   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2155
2156   END (csin, complex);
2157 }
2158
2159
2160 static void
2161 csinh_test (void)
2162 {
2163   errno = 0;
2164   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2165   if (errno == ENOSYS)
2166     /* Function not implemented.  */
2167     return;
2168
2169   START (csinh);
2170
2171   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2172   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2173   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2174   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2175
2176   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2177   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2178   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2179   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2180
2181   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2182   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2183   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2184   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2185
2186   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2187   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2188   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2189   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2190
2191   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2192   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2193   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2194   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2195
2196   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2197   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2198   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2199   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2200
2201   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2202   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2203
2204   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2205   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2206
2207   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2208   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2209
2210   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2211   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2212
2213   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2214   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2215
2216   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2217   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2218
2219   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2220
2221   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2222   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2223
2224   END (csinh, complex);
2225 }
2226
2227
2228 static void
2229 csqrt_test (void)
2230 {
2231   errno = 0;
2232   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2233   if (errno == ENOSYS)
2234     /* Function not implemented.  */
2235     return;
2236
2237   START (csqrt);
2238
2239   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2240   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2241   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2242   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2243
2244   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2245   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2246   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2247   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2248
2249   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2250   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2251   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2252   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2253
2254   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2255   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2256   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2257   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2258   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2259   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2260   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2261   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2262   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2263   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2264   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2265   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2266
2267   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2268
2269   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2270
2271   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2272   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2273   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2274   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2275
2276   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2277   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2278   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2279   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2280
2281   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2282
2283   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2284   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2285   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2286   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2287   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2288   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2289   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2290   /* Principal square root should be returned (i.e., non-negative real
2291      part).  */
2292   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2293
2294   END (csqrt, complex);
2295 }
2296
2297 static void
2298 ctan_test (void)
2299 {
2300   errno = 0;
2301   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2302   if (errno == ENOSYS)
2303     /* Function not implemented.  */
2304     return;
2305
2306   START (ctan);
2307
2308   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2309   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2310   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2311   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2312
2313   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2314   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2315   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2316   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2317
2318   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2319   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2320   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2321   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2322
2323   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2324   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2325   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2326   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2327   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2328   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2329   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2330   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2331
2332   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2333   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2334
2335   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2336   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2337
2338   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2339   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2340
2341   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2342   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2343   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2344   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2345
2346   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2347
2348   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2349   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2350
2351   END (ctan, complex);
2352 }
2353
2354
2355 static void
2356 ctanh_test (void)
2357 {
2358   errno = 0;
2359   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2360   if (errno == ENOSYS)
2361     /* Function not implemented.  */
2362     return;
2363
2364   START (ctanh);
2365
2366   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2367   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2368   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2369   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2370
2371   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2372   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2373   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2374   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2375   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2376   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2377   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2378   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2379
2380   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2381   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2382   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2383   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2384   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2385   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2386   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2387   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2388
2389   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2390   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2391
2392   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2393   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2394
2395   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2396   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2397
2398   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2399   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2400   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2401   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2402
2403   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2404
2405   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2406
2407   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2408   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2409
2410   END (ctanh, complex);
2411 }
2412
2413
2414 static void
2415 erf_test (void)
2416 {
2417   errno = 0;
2418   FUNC(erf) (0);
2419   if (errno == ENOSYS)
2420     /* Function not implemented.  */
2421     return;
2422
2423   START (erf);
2424
2425   TEST_f_f (erf, 0, 0);
2426   TEST_f_f (erf, minus_zero, minus_zero);
2427   TEST_f_f (erf, plus_infty, 1);
2428   TEST_f_f (erf, minus_infty, -1);
2429   TEST_f_f (erf, nan_value, nan_value);
2430
2431   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2432   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2433   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2434   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2435   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2436   TEST_f_f (erf, 27.0L, 1.0L);
2437
2438   END (erf);
2439 }
2440
2441
2442 static void
2443 erfc_test (void)
2444 {
2445   errno = 0;
2446   FUNC(erfc) (0);
2447   if (errno == ENOSYS)
2448     /* Function not implemented.  */
2449     return;
2450
2451   START (erfc);
2452
2453   TEST_f_f (erfc, plus_infty, 0.0);
2454   TEST_f_f (erfc, minus_infty, 2.0);
2455   TEST_f_f (erfc, 0.0, 1.0);
2456   TEST_f_f (erfc, minus_zero, 1.0);
2457   TEST_f_f (erfc, nan_value, nan_value);
2458
2459   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2460   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2461   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2462   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2463   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2464 #ifdef TEST_LDOUBLE
2465   /* The result can only be represented in long double.  */
2466 # if LDBL_MIN_10_EXP < -319
2467   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2468 # endif
2469 #endif
2470
2471   END (erfc);
2472 }
2473
2474
2475 static void
2476 exp_test (void)
2477 {
2478   errno = 0;
2479   FUNC(exp) (0);
2480   if (errno == ENOSYS)
2481     /* Function not implemented.  */
2482     return;
2483
2484   START (exp);
2485
2486   TEST_f_f (exp, 0, 1);
2487   TEST_f_f (exp, minus_zero, 1);
2488
2489 #ifndef TEST_INLINE
2490   TEST_f_f (exp, plus_infty, plus_infty);
2491   TEST_f_f (exp, minus_infty, 0);
2492 #endif
2493   TEST_f_f (exp, nan_value, nan_value);
2494   TEST_f_f (exp, 1, M_El);
2495
2496   TEST_f_f (exp, 2, M_E2l);
2497   TEST_f_f (exp, 3, M_E3l);
2498   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2499   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2500 #ifdef TEST_LDOUBLE
2501   /* The result can only be represented in long double.  */
2502   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
2503 #endif
2504
2505   END (exp);
2506 }
2507
2508
2509 static void
2510 exp10_test (void)
2511 {
2512   errno = 0;
2513   FUNC(exp10) (0);
2514   if (errno == ENOSYS)
2515     /* Function not implemented.  */
2516     return;
2517
2518   START (exp10);
2519
2520   TEST_f_f (exp10, 0, 1);
2521   TEST_f_f (exp10, minus_zero, 1);
2522
2523   TEST_f_f (exp10, plus_infty, plus_infty);
2524   TEST_f_f (exp10, minus_infty, 0);
2525   TEST_f_f (exp10, nan_value, nan_value);
2526   TEST_f_f (exp10, 3, 1000);
2527   TEST_f_f (exp10, -1, 0.1L);
2528   TEST_f_f (exp10, 1e6, plus_infty);
2529   TEST_f_f (exp10, -1e6, 0);
2530   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
2531
2532   END (exp10);
2533 }
2534
2535
2536 static void
2537 exp2_test (void)
2538 {
2539   errno = 0;
2540   FUNC(exp2) (0);
2541   if (errno == ENOSYS)
2542     /* Function not implemented.  */
2543     return;
2544
2545   START (exp2);
2546
2547   TEST_f_f (exp2, 0, 1);
2548   TEST_f_f (exp2, minus_zero, 1);
2549   TEST_f_f (exp2, plus_infty, plus_infty);
2550   TEST_f_f (exp2, minus_infty, 0);
2551   TEST_f_f (exp2, nan_value, nan_value);
2552
2553   TEST_f_f (exp2, 10, 1024);
2554   TEST_f_f (exp2, -1, 0.5);
2555   TEST_f_f (exp2, 1e6, plus_infty);
2556   TEST_f_f (exp2, -1e6, 0);
2557   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
2558
2559   END (exp2);
2560 }
2561
2562
2563 static void
2564 expm1_test (void)
2565 {
2566   errno = 0;
2567   FUNC(expm1) (0);
2568   if (errno == ENOSYS)
2569     /* Function not implemented.  */
2570     return;
2571
2572   START (expm1);
2573
2574   TEST_f_f (expm1, 0, 0);
2575   TEST_f_f (expm1, minus_zero, minus_zero);
2576
2577 #ifndef TEST_INLINE
2578   TEST_f_f (expm1, plus_infty, plus_infty);
2579   TEST_f_f (expm1, minus_infty, -1);
2580 #endif
2581   TEST_f_f (expm1, nan_value, nan_value);
2582
2583   TEST_f_f (expm1, 1, M_El - 1.0);
2584   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
2585
2586   END (expm1);
2587 }
2588
2589
2590 static void
2591 fabs_test (void)
2592 {
2593   START (fabs);
2594
2595   TEST_f_f (fabs, 0, 0);
2596   TEST_f_f (fabs, minus_zero, 0);
2597
2598   TEST_f_f (fabs, plus_infty, plus_infty);
2599   TEST_f_f (fabs, minus_infty, plus_infty);
2600   TEST_f_f (fabs, nan_value, nan_value);
2601
2602   TEST_f_f (fabs, 38.0, 38.0);
2603   TEST_f_f (fabs, -M_El, M_El);
2604
2605   END (fabs);
2606 }
2607
2608
2609 static void
2610 fdim_test (void)
2611 {
2612   START (fdim);
2613
2614   TEST_ff_f (fdim, 0, 0, 0);
2615   TEST_ff_f (fdim, 9, 0, 9);
2616   TEST_ff_f (fdim, 0, 9, 0);
2617   TEST_ff_f (fdim, -9, 0, 0);
2618   TEST_ff_f (fdim, 0, -9, 9);
2619
2620   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2621   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2622   TEST_ff_f (fdim, minus_infty, 9, 0);
2623   TEST_ff_f (fdim, minus_infty, -9, 0);
2624   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2625   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2626   TEST_ff_f (fdim, 9, plus_infty, 0);
2627   TEST_ff_f (fdim, -9, plus_infty, 0);
2628
2629   TEST_ff_f (fdim, 0, nan_value, nan_value);
2630   TEST_ff_f (fdim, 9, nan_value, nan_value);
2631   TEST_ff_f (fdim, -9, nan_value, nan_value);
2632   TEST_ff_f (fdim, nan_value, 9, nan_value);
2633   TEST_ff_f (fdim, nan_value, -9, nan_value);
2634   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2635   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2636   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2637   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2638   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2639
2640   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
2641
2642   END (fdim);
2643 }
2644
2645
2646 static void
2647 floor_test (void)
2648 {
2649   START (floor);
2650
2651   TEST_f_f (floor, 0.0, 0.0);
2652   TEST_f_f (floor, minus_zero, minus_zero);
2653   TEST_f_f (floor, plus_infty, plus_infty);
2654   TEST_f_f (floor, minus_infty, minus_infty);
2655   TEST_f_f (floor, nan_value, nan_value);
2656
2657   TEST_f_f (floor, M_PIl, 3.0);
2658   TEST_f_f (floor, -M_PIl, -4.0);
2659
2660   TEST_f_f (floor, 0.1, 0.0);
2661   TEST_f_f (floor, 0.25, 0.0);
2662   TEST_f_f (floor, 0.625, 0.0);
2663   TEST_f_f (floor, -0.1, -1.0);
2664   TEST_f_f (floor, -0.25, -1.0);
2665   TEST_f_f (floor, -0.625, -1.0);
2666
2667 #ifdef TEST_LDOUBLE
2668   /* The result can only be represented in long double.  */
2669   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
2670   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
2671   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
2672   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
2673   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
2674 # if LDBL_MANT_DIG > 100
2675   TEST_f_f (floor, 4503599627370494.5000000000001L, 4503599627370494.0L);
2676   TEST_f_f (floor, 4503599627370495.5000000000001L, 4503599627370495.0L);
2677   TEST_f_f (floor, 4503599627370496.5000000000001L, 4503599627370496.0L);
2678 # endif
2679
2680   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
2681   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
2682   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
2683   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
2684   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
2685 # if LDBL_MANT_DIG > 100
2686   TEST_f_f (floor, -4503599627370494.5000000000001L, -4503599627370495.0L);
2687   TEST_f_f (floor, -4503599627370495.5000000000001L, -4503599627370496.0L);
2688   TEST_f_f (floor, -4503599627370496.5000000000001L, -4503599627370497.0L);
2689 # endif
2690
2691   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
2692   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
2693   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
2694   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
2695   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
2696
2697 # if LDBL_MANT_DIG > 100
2698   TEST_f_f (floor, 9007199254740991.0000000000001L, 9007199254740991.0L);
2699   TEST_f_f (floor, 9007199254740992.0000000000001L, 9007199254740992.0L);
2700   TEST_f_f (floor, 9007199254740993.0000000000001L, 9007199254740993.0L);
2701   TEST_f_f (floor, 9007199254740991.5000000000001L, 9007199254740991.0L);
2702   TEST_f_f (floor, 9007199254740992.5000000000001L, 9007199254740992.0L);
2703   TEST_f_f (floor, 9007199254740993.5000000000001L, 9007199254740993.0L);
2704 # endif
2705
2706   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
2707   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
2708   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
2709   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
2710   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
2711
2712 # if LDBL_MANT_DIG > 100
2713   TEST_f_f (floor, -9007199254740991.0000000000001L, -9007199254740992.0L);
2714   TEST_f_f (floor, -9007199254740992.0000000000001L, -9007199254740993.0L);
2715   TEST_f_f (floor, -9007199254740993.0000000000001L, -9007199254740994.0L);
2716   TEST_f_f (floor, -9007199254740991.5000000000001L, -9007199254740992.0L);
2717   TEST_f_f (floor, -9007199254740992.5000000000001L, -9007199254740993.0L);
2718   TEST_f_f (floor, -9007199254740993.5000000000001L, -9007199254740994.0L);
2719 # endif
2720
2721   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
2722   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
2723   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
2724   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
2725   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
2726
2727   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
2728   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
2729   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
2730   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
2731   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
2732
2733   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
2734   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
2735   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
2736   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
2737   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
2738 #endif
2739
2740   END (floor);
2741 }
2742
2743
2744 static void
2745 fma_test (void)
2746 {
2747   START (fma);
2748
2749   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2750   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2751   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2752   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2753   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2754   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2755   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2756   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2757   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2758   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2759   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2760   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2761
2762   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2763   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2764   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2765   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2766
2767   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
2768
2769   END (fma);
2770 }
2771
2772
2773 static void
2774 fmax_test (void)
2775 {
2776   START (fmax);
2777
2778   TEST_ff_f (fmax, 0, 0, 0);
2779   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2780   TEST_ff_f (fmax, 9, 0, 9);
2781   TEST_ff_f (fmax, 0, 9, 9);
2782   TEST_ff_f (fmax, -9, 0, 0);
2783   TEST_ff_f (fmax, 0, -9, 0);
2784
2785   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2786   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2787   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2788   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2789
2790   TEST_ff_f (fmax, minus_infty, 9, 9);
2791   TEST_ff_f (fmax, minus_infty, -9, -9);
2792   TEST_ff_f (fmax, 9, minus_infty, 9);
2793   TEST_ff_f (fmax, -9, minus_infty, -9);
2794
2795   TEST_ff_f (fmax, 0, nan_value, 0);
2796   TEST_ff_f (fmax, 9, nan_value, 9);
2797   TEST_ff_f (fmax, -9, nan_value, -9);
2798   TEST_ff_f (fmax, nan_value, 0, 0);
2799   TEST_ff_f (fmax, nan_value, 9, 9);
2800   TEST_ff_f (fmax, nan_value, -9, -9);
2801   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2802   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2803   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2804   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2805   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2806
2807   END (fmax);
2808 }
2809
2810
2811 static void
2812 fmin_test (void)
2813 {
2814   START (fmin);
2815
2816   TEST_ff_f (fmin, 0, 0, 0);
2817   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2818   TEST_ff_f (fmin, 9, 0, 0);
2819   TEST_ff_f (fmin, 0, 9, 0);
2820   TEST_ff_f (fmin, -9, 0, -9);
2821   TEST_ff_f (fmin, 0, -9, -9);
2822
2823   TEST_ff_f (fmin, plus_infty, 9, 9);
2824   TEST_ff_f (fmin, 9, plus_infty, 9);
2825   TEST_ff_f (fmin, plus_infty, -9, -9);
2826   TEST_ff_f (fmin, -9, plus_infty, -9);
2827   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2828   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2829   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2830   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2831
2832   TEST_ff_f (fmin, 0, nan_value, 0);
2833   TEST_ff_f (fmin, 9, nan_value, 9);
2834   TEST_ff_f (fmin, -9, nan_value, -9);
2835   TEST_ff_f (fmin, nan_value, 0, 0);
2836   TEST_ff_f (fmin, nan_value, 9, 9);
2837   TEST_ff_f (fmin, nan_value, -9, -9);
2838   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2839   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2840   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2841   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2842   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2843
2844   END (fmin);
2845 }
2846
2847
2848 static void
2849 fmod_test (void)
2850 {
2851   errno = 0;
2852   FUNC(fmod) (6.5, 2.3L);
2853   if (errno == ENOSYS)
2854     /* Function not implemented.  */
2855     return;
2856
2857   START (fmod);
2858
2859   /* fmod (+0, y) == +0 for y != 0.  */
2860   TEST_ff_f (fmod, 0, 3, 0);
2861
2862   /* fmod (-0, y) == -0 for y != 0.  */
2863   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2864
2865   /* fmod (+inf, y) == NaN plus invalid exception.  */
2866   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2867   /* fmod (-inf, y) == NaN plus invalid exception.  */
2868   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2869   /* fmod (x, +0) == NaN plus invalid exception.  */
2870   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2871   /* fmod (x, -0) == NaN plus invalid exception.  */
2872   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2873
2874   /* fmod (x, +inf) == x for x not infinite.  */
2875   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2876   /* fmod (x, -inf) == x for x not infinite.  */
2877   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2878
2879   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2880
2881   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
2882   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
2883   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
2884   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
2885
2886   END (fmod);
2887 }
2888
2889
2890 static void
2891 fpclassify_test (void)
2892 {
2893   START (fpclassify);
2894
2895   TEST_f_i (fpclassify, nan_value, FP_NAN);
2896   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2897   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2898   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2899   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2900   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2901
2902   END (fpclassify);
2903 }
2904
2905
2906 static void
2907 frexp_test (void)
2908 {
2909   int x;
2910
2911   START (frexp);
2912
2913   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2914   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2915   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2916
2917   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2918   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2919
2920   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
2921   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
2922
2923   END (frexp);
2924 }
2925
2926
2927 static void
2928 gamma_test (void)
2929 {
2930   errno = 0;
2931   FUNC(gamma) (1);
2932
2933   if (errno == ENOSYS)
2934     /* Function not implemented.  */
2935     return;
2936   feclearexcept (FE_ALL_EXCEPT);
2937
2938   START (gamma);
2939
2940   TEST_f_f (gamma, plus_infty, plus_infty);
2941   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2942   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2943   TEST_f_f (gamma, minus_infty, plus_infty);
2944   TEST_f_f (gamma, nan_value, nan_value);
2945
2946   TEST_f_f1 (gamma, 1, 0, 1);
2947   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2948
2949   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2950   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2951
2952   END (gamma);
2953 }
2954
2955 static void
2956 hypot_test (void)
2957 {
2958   errno = 0;
2959   FUNC(hypot) (0.7L, 12.4L);
2960   if (errno == ENOSYS)
2961     /* Function not implemented.  */
2962     return;
2963
2964   START (hypot);
2965
2966   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2967   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2968
2969 #ifndef TEST_INLINE
2970   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2971   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2972   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2973   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2974 #endif
2975
2976   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2977
2978   /* hypot (x,y) == hypot (+-x, +-y)  */
2979   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
2980   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
2981   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
2982   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
2983   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
2984   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
2985   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
2986   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
2987
2988   /*  hypot (x,0) == fabs (x)  */
2989   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
2990   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
2991   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
2992
2993   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
2994
2995   END (hypot);
2996 }
2997
2998
2999 static void
3000 ilogb_test (void)
3001 {
3002   START (ilogb);
3003
3004   TEST_f_i (ilogb, 1, 0);
3005   TEST_f_i (ilogb, M_El, 1);
3006   TEST_f_i (ilogb, 1024, 10);
3007   TEST_f_i (ilogb, -2000, 10);
3008
3009   /* XXX We have a problem here: the standard does not tell us whether
3010      exceptions are allowed/required.  ignore them for now.  */
3011
3012   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
3013   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
3014   TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
3015   TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
3016
3017   END (ilogb);
3018 }
3019
3020 static void
3021 isfinite_test (void)
3022 {
3023   START (isfinite);
3024
3025   TEST_f_b (isfinite, 0, 1);
3026   TEST_f_b (isfinite, minus_zero, 1);
3027   TEST_f_b (isfinite, 10, 1);
3028   TEST_f_b (isfinite, plus_infty, 0);
3029   TEST_f_b (isfinite, minus_infty, 0);
3030   TEST_f_b (isfinite, nan_value, 0);
3031
3032   END (isfinite);
3033 }
3034
3035 static void
3036 isnormal_test (void)
3037 {
3038   START (isnormal);
3039
3040   TEST_f_b (isnormal, 0, 0);
3041   TEST_f_b (isnormal, minus_zero, 0);
3042   TEST_f_b (isnormal, 10, 1);
3043   TEST_f_b (isnormal, plus_infty, 0);
3044   TEST_f_b (isnormal, minus_infty, 0);
3045   TEST_f_b (isnormal, nan_value, 0);
3046
3047   END (isnormal);
3048 }
3049
3050 static void
3051 j0_test (void)
3052 {
3053   FLOAT s, c;
3054   errno = 0;
3055   FUNC (sincos) (0, &s, &c);
3056   if (errno == ENOSYS)
3057     /* Required function not implemented.  */
3058     return;
3059   FUNC(j0) (0);
3060   if (errno == ENOSYS)
3061     /* Function not implemented.  */
3062     return;
3063
3064   START (j0);
3065
3066   /* j0 is the Bessel function of the first kind of order 0 */
3067   TEST_f_f (j0, nan_value, nan_value);
3068   TEST_f_f (j0, plus_infty, 0);
3069   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3070   TEST_f_f (j0, 0.0, 1.0);
3071   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3072   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3073   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3074   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3075   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3076   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3077   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3078   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3079   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3080
3081   END (j0);
3082 }
3083
3084
3085 static void
3086 j1_test (void)
3087 {
3088   FLOAT s, c;
3089   errno = 0;
3090   FUNC (sincos) (0, &s, &c);
3091   if (errno == ENOSYS)
3092     /* Required function not implemented.  */
3093     return;
3094   FUNC(j1) (0);
3095   if (errno == ENOSYS)
3096     /* Function not implemented.  */
3097     return;
3098
3099   /* j1 is the Bessel function of the first kind of order 1 */
3100
3101   START (j1);
3102
3103   TEST_f_f (j1, nan_value, nan_value);
3104   TEST_f_f (j1, plus_infty, 0);
3105
3106   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3107   TEST_f_f (j1, 0.0, 0.0);
3108   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3109   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3110   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3111   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3112   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3113   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3114   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3115
3116   END (j1);
3117 }
3118
3119 static void
3120 jn_test (void)
3121 {
3122   FLOAT s, c;
3123   errno = 0;
3124   FUNC (sincos) (0, &s, &c);
3125   if (errno == ENOSYS)
3126     /* Required function not implemented.  */
3127     return;
3128   FUNC(jn) (1, 1);
3129   if (errno == ENOSYS)
3130     /* Function not implemented.  */
3131     return;
3132
3133   /* jn is the Bessel function of the first kind of order n.  */
3134   START (jn);
3135
3136   /* jn (0, x) == j0 (x)  */
3137   TEST_ff_f (jn, 0, nan_value, nan_value);
3138   TEST_ff_f (jn, 0, plus_infty, 0);
3139   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3140   TEST_ff_f (jn, 0, 0.0, 1.0);
3141   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3142   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3143   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3144   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3145   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3146   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3147   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3148   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3149   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3150
3151   /* jn (1, x) == j1 (x)  */
3152   TEST_ff_f (jn, 1, nan_value, nan_value);
3153   TEST_ff_f (jn, 1, plus_infty, 0);
3154   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3155   TEST_ff_f (jn, 1, 0.0, 0.0);
3156   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3157   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3158   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3159   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3160   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3161   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3162   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3163
3164   /* jn (3, x)  */
3165   TEST_ff_f (jn, 3, nan_value, nan_value);
3166   TEST_ff_f (jn, 3, plus_infty, 0);
3167
3168   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3169   TEST_ff_f (jn, 3, 0.0, 0.0);
3170   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3171   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3172   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3173   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3174   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3175
3176   /*  jn (10, x)  */
3177   TEST_ff_f (jn, 10, nan_value, nan_value);
3178   TEST_ff_f (jn, 10, plus_infty, 0);
3179
3180   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3181   TEST_ff_f (jn, 10, 0.0, 0.0);
3182   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3183   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3184   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3185   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3186   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3187
3188   END (jn);
3189 }
3190
3191
3192 static void
3193 ldexp_test (void)
3194 {
3195   TEST_ff_f (ldexp, 0, 0, 0);
3196   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3197
3198   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3199   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3200   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3201
3202   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3203   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3204
3205   /* ldexp (x, 0) == x.  */
3206   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3207 }
3208
3209
3210 static void
3211 lgamma_test (void)
3212 {
3213   errno = 0;
3214   FUNC(lgamma) (0);
3215   if (errno == ENOSYS)
3216     /* Function not implemented.  */
3217     return;
3218   feclearexcept (FE_ALL_EXCEPT);
3219
3220   START (lgamma);
3221
3222   TEST_f_f (lgamma, plus_infty, plus_infty);
3223   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3224   check_int ("signgam for lgamma(0) == 1", signgam, 1, 0, 0, 0);
3225   TEST_f_f (lgamma, minus_zero, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3226   check_int ("signgam for lgamma(-0) == -1", signgam, -1, 0, 0, 0);
3227   TEST_f_f (lgamma, nan_value, nan_value);
3228
3229   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3230   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3231   TEST_f_f (lgamma, minus_infty, plus_infty);
3232
3233   TEST_f_f1 (lgamma, 1, 0, 1);
3234
3235   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3236
3237   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3238   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3239   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3240   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3241
3242   END (lgamma);
3243 }
3244
3245
3246 static void
3247 lrint_test (void)
3248 {
3249   /* XXX this test is incomplete.  We need to have a way to specifiy
3250      the rounding method and test the critical cases.  So far, only
3251      unproblematic numbers are tested.  */
3252
3253   START (lrint);
3254
3255   TEST_f_l (lrint, 0.0, 0);
3256   TEST_f_l (lrint, minus_zero, 0);
3257   TEST_f_l (lrint, 0.2L, 0);
3258   TEST_f_l (lrint, -0.2L, 0);
3259
3260   TEST_f_l (lrint, 1.4L, 1);
3261   TEST_f_l (lrint, -1.4L, -1);
3262
3263   TEST_f_l (lrint, 8388600.3L, 8388600);
3264   TEST_f_l (lrint, -8388600.3L, -8388600);
3265
3266   TEST_f_l (lrint, 1071930.0008, 1071930);
3267 #ifndef TEST_FLOAT
3268   TEST_f_l (lrint, 1073741824.01, 1073741824);
3269 # if LONG_MAX > 281474976710656
3270   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3271 # endif
3272 #endif
3273
3274   END (lrint);
3275 }
3276
3277
3278 static void
3279 lrint_test_tonearest (void)
3280 {
3281   int save_round_mode;
3282   START (lrint_tonearest);
3283
3284   save_round_mode = fegetround ();
3285
3286   if (!fesetround (FE_TONEAREST))
3287     {
3288       TEST_f_l (lrint, 0.0, 0);
3289       TEST_f_l (lrint, minus_zero, 0);
3290       TEST_f_l (lrint, 0.2L, 0);
3291       TEST_f_l (lrint, -0.2L, 0);
3292       TEST_f_l (lrint, 0.5L, 0);
3293       TEST_f_l (lrint, -0.5L, 0);
3294       TEST_f_l (lrint, 0.8L, 1);
3295       TEST_f_l (lrint, -0.8L, -1);
3296
3297       TEST_f_l (lrint, 1.4L, 1);
3298       TEST_f_l (lrint, -1.4L, -1);
3299
3300       TEST_f_l (lrint, 8388600.3L, 8388600);
3301       TEST_f_l (lrint, -8388600.3L, -8388600);
3302
3303       TEST_f_l (lrint, 1071930.0008, 1071930);
3304 #ifndef TEST_FLOAT
3305       TEST_f_l (lrint, 1073741824.01, 1073741824);
3306 # if LONG_MAX > 281474976710656
3307       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3308 # endif
3309 #endif
3310     }
3311
3312   fesetround (save_round_mode);
3313
3314   END (lrint_tonearest);
3315 }
3316
3317
3318 static void
3319 lrint_test_towardzero (void)
3320 {
3321   int save_round_mode;
3322   START (lrint_towardzero);
3323
3324   save_round_mode = fegetround ();
3325
3326   if (!fesetround (FE_TOWARDZERO))
3327     {
3328       TEST_f_l (lrint, 0.0, 0);
3329       TEST_f_l (lrint, minus_zero, 0);
3330       TEST_f_l (lrint, 0.2L, 0);
3331       TEST_f_l (lrint, -0.2L, 0);
3332       TEST_f_l (lrint, 0.5L, 0);
3333       TEST_f_l (lrint, -0.5L, 0);
3334       TEST_f_l (lrint, 0.8L, 0);
3335       TEST_f_l (lrint, -0.8L, 0);
3336
3337       TEST_f_l (lrint, 1.4L, 1);
3338       TEST_f_l (lrint, -1.4L, -1);
3339
3340       TEST_f_l (lrint, 8388600.3L, 8388600);
3341       TEST_f_l (lrint, -8388600.3L, -8388600);
3342
3343       TEST_f_l (lrint, 1071930.0008, 1071930);
3344 #ifndef TEST_FLOAT
3345       TEST_f_l (lrint, 1073741824.01, 1073741824);
3346 # if LONG_MAX > 281474976710656
3347       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3348 # endif
3349 #endif
3350     }
3351
3352   fesetround (save_round_mode);
3353
3354   END (lrint_towardzero);
3355 }
3356
3357
3358 static void
3359 lrint_test_downward (void)
3360 {
3361   int save_round_mode;
3362   START (lrint_downward);
3363
3364   save_round_mode = fegetround ();
3365
3366   if (!fesetround (FE_DOWNWARD))
3367     {
3368       TEST_f_l (lrint, 0.0, 0);
3369       TEST_f_l (lrint, minus_zero, 0);
3370       TEST_f_l (lrint, 0.2L, 0);
3371       TEST_f_l (lrint, -0.2L, -1);
3372       TEST_f_l (lrint, 0.5L, 0);
3373       TEST_f_l (lrint, -0.5L, -1);
3374       TEST_f_l (lrint, 0.8L, 0);
3375       TEST_f_l (lrint, -0.8L, -1);
3376
3377       TEST_f_l (lrint, 1.4L, 1);
3378       TEST_f_l (lrint, -1.4L, -2);
3379
3380       TEST_f_l (lrint, 8388600.3L, 8388600);
3381       TEST_f_l (lrint, -8388600.3L, -8388601);
3382
3383       TEST_f_l (lrint, 1071930.0008, 1071930);
3384 #ifndef TEST_FLOAT
3385       TEST_f_l (lrint, 1073741824.01, 1073741824);
3386 # if LONG_MAX > 281474976710656
3387       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3388 # endif
3389 #endif
3390     }
3391
3392   fesetround (save_round_mode);
3393
3394   END (lrint_downward);
3395 }
3396
3397
3398 static void
3399 lrint_test_upward (void)
3400 {
3401   int save_round_mode;
3402   START (lrint_upward);
3403
3404   save_round_mode = fegetround ();
3405
3406   if (!fesetround (FE_UPWARD))
3407     {
3408       TEST_f_l (lrint, 0.0, 0);
3409       TEST_f_l (lrint, minus_zero, 0);
3410       TEST_f_l (lrint, 0.2L, 1);
3411       TEST_f_l (lrint, -0.2L, 0);
3412       TEST_f_l (lrint, 0.5L, 1);
3413       TEST_f_l (lrint, -0.5L, 0);
3414       TEST_f_l (lrint, 0.8L, 1);
3415       TEST_f_l (lrint, -0.8L, 0);
3416
3417       TEST_f_l (lrint, 1.4L, 2);
3418       TEST_f_l (lrint, -1.4L, -1);
3419
3420       TEST_f_l (lrint, 8388600.3L, 8388601);
3421       TEST_f_l (lrint, -8388600.3L, -8388600);
3422
3423 #ifndef TEST_FLOAT
3424       TEST_f_l (lrint, 1071930.0008, 1071931);
3425       TEST_f_l (lrint, 1073741824.01, 1073741825);
3426 # if LONG_MAX > 281474976710656 && defined (TEST_LDOUBLE)
3427       TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3428 # endif
3429 #endif
3430     }
3431
3432   fesetround (save_round_mode);
3433
3434   END (lrint_upward);
3435 }
3436
3437
3438 static void
3439 llrint_test (void)
3440 {
3441   /* XXX this test is incomplete.  We need to have a way to specifiy
3442      the rounding method and test the critical cases.  So far, only
3443      unproblematic numbers are tested.  */
3444
3445   START (llrint);
3446
3447   TEST_f_L (llrint, 0.0, 0);
3448   TEST_f_L (llrint, minus_zero, 0);
3449   TEST_f_L (llrint, 0.2L, 0);
3450   TEST_f_L (llrint, -0.2L, 0);
3451
3452   TEST_f_L (llrint, 1.4L, 1);
3453   TEST_f_L (llrint, -1.4L, -1);
3454
3455   TEST_f_L (llrint, 8388600.3L, 8388600);
3456   TEST_f_L (llrint, -8388600.3L, -8388600);
3457
3458   TEST_f_l (llrint, 1071930.0008, 1071930);
3459
3460   /* Test boundary conditions.  */
3461   /* 0x1FFFFF */
3462   TEST_f_L (llrint, 2097151.0,2097151LL);
3463   /* 0x800000 */
3464   TEST_f_L (llrint, 8388608.0, 8388608LL);
3465   /* 0x1000000 */
3466   TEST_f_L (llrint, 16777216.0, 16777216LL);
3467   /* 0x20000000000 */
3468   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3469   /* 0x40000000000 */
3470   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3471   /* 0x1000000000000 */
3472   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3473   /* 0x10000000000000 */
3474   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3475   /* 0x10000080000000 */
3476   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3477   /* 0x20000000000000 */
3478   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3479   /* 0x80000000000000 */
3480   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3481   /* 0x100000000000000 */
3482   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3483 #ifdef TEST_LDOUBLE
3484   /* The input can only be represented in long double.  */
3485   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3486   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3487   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3488   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3489   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3490
3491   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3492   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3493   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3494   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3495   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3496
3497 # if LDBL_MANT_DIG > 100
3498   TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3499   TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3500   TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3501   TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
3502   TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
3503   TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
3504
3505   TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
3506   TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
3507   TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
3508   TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
3509   TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
3510   TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
3511 #endif
3512
3513   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3514   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3515   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3516   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3517   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3518
3519   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3520   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3521   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3522   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3523   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3524
3525 # if LDBL_MANT_DIG > 100
3526   TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3527   TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3528   TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3529   TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
3530   TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
3531   TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
3532
3533   TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
3534   TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
3535   TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
3536   TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
3537   TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
3538   TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
3539 #endif
3540
3541   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3542   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3543   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3544   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3545   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3546
3547   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3548   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3549   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3550   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3551   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3552
3553 # if LDBL_MANT_DIG > 100
3554   TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
3555   TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
3556   TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3557   TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3558   TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3559   TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
3560   TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3561   TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
3562   TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
3563   TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
3564   TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3565   TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3566 # endif
3567 #endif
3568
3569   END (llrint);
3570 }
3571
3572 static void
3573 llrint_test_tonearest (void)
3574 {
3575   int save_round_mode;
3576   START (llrint_tonearest);
3577
3578   save_round_mode = fegetround ();
3579
3580   if (!fesetround (FE_TONEAREST))
3581     {
3582       TEST_f_L (llrint, 0.0, 0);
3583       TEST_f_L (llrint, minus_zero, 0);
3584       TEST_f_L (llrint, 0.2L, 0);
3585       TEST_f_L (llrint, -0.2L, 0);
3586
3587       TEST_f_L (llrint, 1.4L, 1);
3588       TEST_f_L (llrint, -1.4L, -1);
3589
3590       TEST_f_L (llrint, 8388600.3L, 8388600);
3591       TEST_f_L (llrint, -8388600.3L, -8388600);
3592
3593       TEST_f_l (llrint, 1071930.0008, 1071930);
3594
3595       /* Test boundary conditions.  */
3596       /* 0x1FFFFF */
3597       TEST_f_L (llrint, 2097151.0,2097151LL);
3598       /* 0x800000 */
3599       TEST_f_L (llrint, 8388608.0, 8388608LL);
3600       /* 0x1000000 */
3601       TEST_f_L (llrint, 16777216.0, 16777216LL);
3602       /* 0x20000000000 */
3603       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3604       /* 0x40000000000 */
3605       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3606       /* 0x1000000000000 */
3607       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3608       /* 0x10000000000000 */
3609       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3610       /* 0x10000080000000 */
3611       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3612       /* 0x20000000000000 */
3613       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3614       /* 0x80000000000000 */
3615       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3616       /* 0x100000000000000 */
3617       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3618 #ifdef TEST_LDOUBLE
3619       /* The input can only be represented in long double.  */
3620       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3621       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3622       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3623       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3624       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3625
3626       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3627       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3628       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3629       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3630       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3631
3632 # if LDBL_MANT_DIG > 100
3633       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3634       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3635       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3636       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
3637       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
3638       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
3639
3640       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
3641       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
3642       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
3643       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
3644       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
3645       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
3646 #endif
3647
3648       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3649       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3650       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3651       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3652       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3653
3654       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3655       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3656       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3657       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3658       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3659
3660 # if LDBL_MANT_DIG > 100
3661       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3662       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3663       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3664       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
3665       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
3666       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
3667
3668       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
3669       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
3670       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
3671       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
3672       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
3673       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
3674 #endif
3675
3676       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3677       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3678       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3679       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3680       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3681
3682       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3683       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3684       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3685       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3686       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3687
3688 # if LDBL_MANT_DIG > 100
3689       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
3690       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
3691       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3692       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3693       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3694       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
3695       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3696       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
3697       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
3698       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
3699       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3700       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3701 # endif
3702 #endif
3703     }
3704
3705   fesetround (save_round_mode);
3706
3707   END (llrint_tonearest);
3708 }
3709
3710 static void
3711 llrint_test_towardzero (void)
3712 {
3713   int save_round_mode;
3714   START (llrint_towardzero);
3715
3716   save_round_mode = fegetround ();
3717
3718   if (!fesetround (FE_TOWARDZERO))
3719     {
3720       TEST_f_L (llrint, 0.0, 0);
3721       TEST_f_L (llrint, minus_zero, 0);
3722       TEST_f_L (llrint, 0.2L, 0);
3723       TEST_f_L (llrint, -0.2L, 0);
3724
3725       TEST_f_L (llrint, 1.4L, 1);
3726       TEST_f_L (llrint, -1.4L, -1);
3727
3728       TEST_f_L (llrint, 8388600.3L, 8388600);
3729       TEST_f_L (llrint, -8388600.3L, -8388600);
3730
3731       TEST_f_l (llrint, 1071930.0008, 1071930);
3732
3733       /* Test boundary conditions.  */
3734       /* 0x1FFFFF */
3735       TEST_f_L (llrint, 2097151.0,2097151LL);
3736       /* 0x800000 */
3737       TEST_f_L (llrint, 8388608.0, 8388608LL);
3738       /* 0x1000000 */
3739       TEST_f_L (llrint, 16777216.0, 16777216LL);
3740       /* 0x20000000000 */
3741       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3742       /* 0x40000000000 */
3743       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3744       /* 0x1000000000000 */
3745       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3746       /* 0x10000000000000 */
3747       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3748       /* 0x10000080000000 */
3749       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3750       /* 0x20000000000000 */
3751       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3752       /* 0x80000000000000 */
3753       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3754       /* 0x100000000000000 */
3755       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3756 #ifdef TEST_LDOUBLE
3757       /* The input can only be represented in long double.  */
3758       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
3759       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3760       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3761       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
3762       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
3763
3764       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
3765       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3766       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3767       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
3768       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
3769
3770 # if LDBL_MANT_DIG > 100
3771       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3772       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3773       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3774       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
3775       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
3776       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
3777
3778       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
3779       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
3780       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
3781       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
3782       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
3783       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
3784 #endif
3785
3786       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
3787       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3788       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3789       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
3790       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
3791
3792       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
3793       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3794       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3795       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
3796       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
3797
3798 # if LDBL_MANT_DIG > 100
3799       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3800       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3801       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3802       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
3803       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
3804       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
3805
3806       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
3807       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
3808       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
3809       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
3810       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
3811       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
3812 #endif
3813
3814       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
3815       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3816       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3817       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
3818       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
3819
3820       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
3821       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3822       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3823       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
3824       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
3825
3826 # if LDBL_MANT_DIG > 100
3827       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
3828       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
3829       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3830       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3831       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3832       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
3833       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3834       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
3835       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
3836       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
3837       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3838       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3839 # endif
3840 #endif
3841     }
3842
3843   fesetround (save_round_mode);
3844
3845   END (llrint_towardzero);
3846 }
3847
3848 static void
3849 llrint_test_downward (void)
3850 {
3851   int save_round_mode;
3852   START (llrint_downward);
3853
3854   save_round_mode = fegetround ();
3855
3856   if (!fesetround (FE_DOWNWARD))
3857     {
3858       TEST_f_L (llrint, 0.0, 0);
3859       TEST_f_L (llrint, minus_zero, 0);
3860       TEST_f_L (llrint, 0.2L, 0);
3861       TEST_f_L (llrint, -0.2L, -1);
3862
3863       TEST_f_L (llrint, 1.4L, 1);
3864       TEST_f_L (llrint, -1.4L, -2);
3865
3866       TEST_f_L (llrint, 8388600.3L, 8388600);
3867       TEST_f_L (llrint, -8388600.3L, -8388601);
3868
3869       TEST_f_l (llrint, 1071930.0008, 1071930);
3870
3871       /* Test boundary conditions.  */
3872       /* 0x1FFFFF */
3873       TEST_f_L (llrint, 2097151.0,2097151LL);
3874       /* 0x800000 */
3875       TEST_f_L (llrint, 8388608.0, 8388608LL);
3876       /* 0x1000000 */
3877       TEST_f_L (llrint, 16777216.0, 16777216LL);
3878       /* 0x20000000000 */
3879       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3880       /* 0x40000000000 */
3881       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3882       /* 0x1000000000000 */
3883       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3884       /* 0x10000000000000 */
3885       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3886       /* 0x10000080000000 */
3887       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3888       /* 0x20000000000000 */
3889       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3890       /* 0x80000000000000 */
3891       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3892       /* 0x100000000000000 */
3893       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3894 #ifdef TEST_LDOUBLE
3895       /* The input can only be represented in long double.  */
3896       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370495LL);
3897       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3898       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3899       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370496LL);
3900       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370497LL);
3901
3902       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370495LL);
3903       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370496LL);
3904       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370497LL);
3905       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370494LL);
3906       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370495LL);
3907       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370496LL);
3908
3909       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3910       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370497LL);
3911       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370497LL);
3912       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3913       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3914
3915       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370496LL);
3916       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370497LL);
3917       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370498LL);
3918       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370495LL);
3919       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370496LL);
3920       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370497LL);
3921
3922       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740991LL);
3923       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3924       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3925       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740992LL);
3926       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740993LL);
3927
3928       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740991LL);
3929       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740992LL);
3930       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740993LL);
3931       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740991LL);
3932       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740992LL);
3933       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740993LL);
3934
3935       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3936       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740993LL);
3937       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740993LL);
3938       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3939       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3940
3941       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740992LL);
3942       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740993LL);
3943       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740994LL);
3944       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740992LL);
3945       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740993LL);
3946       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740994LL);
3947
3948       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927935LL);
3949       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3950       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3951       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927936LL);
3952       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927937LL);
3953
3954       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3955       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927937LL);
3956       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927937LL);
3957       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3958       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3959
3960 # if LDBL_MANT_DIG > 100
3961       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775805LL);
3962       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775806LL);
3963       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
3964       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
3965       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775806LL);
3966       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775807LL);
3967       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775806L);
3968       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775807LL);
3969       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775806LL);
3970       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775807LL);
3971       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
3972       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
3973 # endif
3974 #endif
3975     }
3976
3977   fesetround (save_round_mode);
3978
3979   END (llrint_downward);
3980 }
3981
3982 static void
3983 llrint_test_upward (void)
3984 {
3985   int save_round_mode;
3986   START (llrint_upward);
3987
3988   save_round_mode = fegetround ();
3989
3990   if (!fesetround (FE_UPWARD))
3991     {
3992       TEST_f_L (llrint, 0.0, 0);
3993       TEST_f_L (llrint, minus_zero, 0);
3994       TEST_f_L (llrint, 0.2L, 1);
3995       TEST_f_L (llrint, -0.2L, 0);
3996
3997       TEST_f_L (llrint, 1.4L, 2);
3998       TEST_f_L (llrint, -1.4L, -1);
3999
4000       TEST_f_L (llrint, 8388600.3L, 8388601);
4001       TEST_f_L (llrint, -8388600.3L, -8388600);
4002 #ifndef TEST_FLOAT
4003       TEST_f_l (llrint, 1071930.0008, 1071931);
4004 #endif
4005       /* Test boundary conditions.  */
4006       /* 0x1FFFFF */
4007       TEST_f_L (llrint, 2097151.0,2097151LL);
4008       /* 0x800000 */
4009       TEST_f_L (llrint, 8388608.0, 8388608LL);
4010       /* 0x1000000 */
4011       TEST_f_L (llrint, 16777216.0, 16777216LL);
4012       /* 0x20000000000 */
4013       TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
4014       /* 0x40000000000 */
4015       TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
4016       /* 0x1000000000000 */
4017       TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
4018       /* 0x10000000000000 */
4019       TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
4020       /* 0x10000080000000 */
4021       TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
4022       /* 0x20000000000000 */
4023       TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
4024       /* 0x80000000000000 */
4025       TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
4026       /* 0x100000000000000 */
4027       TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
4028 #ifdef TEST_LDOUBLE
4029       /* The input can only be represented in long double.  */
4030       TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
4031       TEST_f_L (llrint, 4503599627370496.25L, 4503599627370497LL);
4032       TEST_f_L (llrint, 4503599627370496.5L, 4503599627370497LL);
4033       TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
4034       TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
4035
4036       TEST_f_L (llrint, 4503599627370495.4999999999999L, 4503599627370496LL);
4037       TEST_f_L (llrint, 4503599627370496.4999999999999L, 4503599627370497LL);
4038       TEST_f_L (llrint, 4503599627370497.4999999999999L, 4503599627370498LL);
4039       TEST_f_L (llrint, 4503599627370494.5000000000001L, 4503599627370495LL);
4040       TEST_f_L (llrint, 4503599627370495.5000000000001L, 4503599627370496LL);
4041       TEST_f_L (llrint, 4503599627370496.5000000000001L, 4503599627370497LL);
4042
4043       TEST_f_L (llrint, -4503599627370495.5L, -4503599627370495LL);
4044       TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
4045       TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
4046       TEST_f_L (llrint, -4503599627370496.75L, -4503599627370496LL);
4047       TEST_f_L (llrint, -4503599627370497.5L, -4503599627370497LL);
4048
4049       TEST_f_L (llrint, -4503599627370495.4999999999999L, -4503599627370495LL);
4050       TEST_f_L (llrint, -4503599627370496.4999999999999L, -4503599627370496LL);
4051       TEST_f_L (llrint, -4503599627370497.4999999999999L, -4503599627370497LL);
4052       TEST_f_L (llrint, -4503599627370494.5000000000001L, -4503599627370494LL);
4053       TEST_f_L (llrint, -4503599627370495.5000000000001L, -4503599627370495LL);
4054       TEST_f_L (llrint, -4503599627370496.5000000000001L, -4503599627370496LL);
4055
4056       TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
4057       TEST_f_L (llrint, 9007199254740992.25L, 9007199254740993LL);
4058       TEST_f_L (llrint, 9007199254740992.5L, 9007199254740993LL);
4059       TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
4060       TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
4061
4062       TEST_f_L (llrint, 9007199254740991.4999999999999L, 9007199254740992LL);
4063       TEST_f_L (llrint, 9007199254740992.4999999999999L, 9007199254740993LL);
4064       TEST_f_L (llrint, 9007199254740993.4999999999999L, 9007199254740994LL);
4065       TEST_f_L (llrint, 9007199254740991.5000000000001L, 9007199254740992LL);
4066       TEST_f_L (llrint, 9007199254740992.5000000000001L, 9007199254740993LL);
4067       TEST_f_L (llrint, 9007199254740993.5000000000001L, 9007199254740994LL);
4068
4069       TEST_f_L (llrint, -9007199254740991.5L, -9007199254740991LL);
4070       TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
4071       TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
4072       TEST_f_L (llrint, -9007199254740992.75L, -9007199254740992LL);
4073       TEST_f_L (llrint, -9007199254740993.5L, -9007199254740993LL);
4074
4075       TEST_f_L (llrint, -9007199254740991.4999999999999L, -9007199254740991LL);
4076       TEST_f_L (llrint, -9007199254740992.4999999999999L, -9007199254740992LL);
4077       TEST_f_L (llrint, -9007199254740993.4999999999999L, -9007199254740993LL);
4078       TEST_f_L (llrint, -9007199254740991.5000000000001L, -9007199254740991LL);
4079       TEST_f_L (llrint, -9007199254740992.5000000000001L, -9007199254740992LL);
4080       TEST_f_L (llrint, -9007199254740993.5000000000001L, -9007199254740993LL);
4081
4082       TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
4083       TEST_f_L (llrint, 72057594037927936.25L, 72057594037927937LL);
4084       TEST_f_L (llrint, 72057594037927936.5L, 72057594037927937LL);
4085       TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
4086       TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
4087
4088       TEST_f_L (llrint, -72057594037927935.5L, -72057594037927935LL);
4089       TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
4090       TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
4091       TEST_f_L (llrint, -72057594037927936.75L, -72057594037927936LL);
4092       TEST_f_L (llrint, -72057594037927937.5L, -72057594037927937LL);
4093
4094 # if LDBL_MANT_DIG > 100
4095       TEST_f_L (llrint, 9223372036854775805.5L, 9223372036854775806LL);
4096       TEST_f_L (llrint, -9223372036854775805.5L, -9223372036854775805LL);
4097       TEST_f_L (llrint, 9223372036854775806.0L, 9223372036854775806LL);
4098       TEST_f_L (llrint, -9223372036854775806.0L, -9223372036854775806LL);
4099       TEST_f_L (llrint, 9223372036854775806.25L, 9223372036854775807LL);
4100       TEST_f_L (llrint, -9223372036854775806.25L, -9223372036854775806LL);
4101       TEST_f_L (llrint, 9223372036854775806.5L, 9223372036854775807L);
4102       TEST_f_L (llrint, -9223372036854775806.5L, -9223372036854775806LL);
4103       TEST_f_L (llrint, 9223372036854775806.75L, 9223372036854775807LL);
4104       TEST_f_L (llrint, -9223372036854775806.75L, -9223372036854775806LL);
4105       TEST_f_L (llrint, 9223372036854775807.0L, 9223372036854775807LL);
4106       TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL);
4107 # endif
4108 #endif
4109     }
4110
4111   fesetround (save_round_mode);
4112
4113   END (llrint_upward);
4114 }
4115
4116
4117 static void
4118 log_test (void)
4119 {
4120   errno = 0;
4121   FUNC(log) (1);
4122   if (errno == ENOSYS)
4123     /* Function not implemented.  */
4124     return;
4125   START (log);
4126
4127   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4128   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4129
4130   TEST_f_f (log, 1, 0);
4131
4132   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
4133   TEST_f_f (log, minus_infty, nan_value, INVALID_EXCEPTION);
4134   TEST_f_f (log, plus_infty, plus_infty);
4135   TEST_f_f (log, nan_value, nan_value);
4136
4137   TEST_f_f (log, M_El, 1);
4138   TEST_f_f (log, 1.0 / M_El, -1);
4139   TEST_f_f (log, 2, M_LN2l);
4140   TEST_f_f (log, 10, M_LN10l);
4141   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
4142
4143   END (log);
4144 }
4145
4146
4147 static void
4148 log10_test (void)
4149 {
4150   errno = 0;
4151   FUNC(log10) (1);
4152   if (errno == ENOSYS)
4153     /* Function not implemented.  */
4154     return;
4155
4156   START (log10);
4157
4158   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4159   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4160
4161   TEST_f_f (log10, 1, 0);
4162
4163   /* log10 (x) == NaN plus invalid exception if x < 0.  */
4164   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
4165   TEST_f_f (log10, minus_infty, nan_value, INVALID_EXCEPTION);
4166
4167   TEST_f_f (log10, plus_infty, plus_infty);
4168   TEST_f_f (log10, nan_value, nan_value);
4169
4170   TEST_f_f (log10, 0.1L, -1);
4171   TEST_f_f (log10, 10.0, 1);
4172   TEST_f_f (log10, 100.0, 2);
4173   TEST_f_f (log10, 10000.0, 4);
4174   TEST_f_f (log10, M_El, M_LOG10El);
4175   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
4176
4177   END (log10);
4178 }
4179
4180
4181 static void
4182 log1p_test (void)
4183 {
4184   errno = 0;
4185   FUNC(log1p) (0);
4186   if (errno == ENOSYS)
4187     /* Function not implemented.  */
4188     return;
4189
4190   START (log1p);
4191
4192   TEST_f_f (log1p, 0, 0);
4193   TEST_f_f (log1p, minus_zero, minus_zero);
4194
4195   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4196   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
4197   TEST_f_f (log1p, minus_infty, nan_value, INVALID_EXCEPTION);
4198
4199   TEST_f_f (log1p, plus_infty, plus_infty);
4200   TEST_f_f (log1p, nan_value, nan_value);
4201
4202   TEST_f_f (log1p, M_El - 1.0, 1);
4203
4204   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
4205   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
4206
4207   END (log1p);
4208 }
4209
4210
4211 static void
4212 log2_test (void)
4213 {
4214   errno = 0;
4215   FUNC(log2) (1);
4216   if (errno == ENOSYS)
4217     /* Function not implemented.  */
4218     return;
4219
4220   START (log2);
4221
4222   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4223   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4224
4225   TEST_f_f (log2, 1, 0);
4226
4227   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
4228   TEST_f_f (log2, minus_infty, nan_value, INVALID_EXCEPTION);
4229
4230   TEST_f_f (log2, plus_infty, plus_infty);
4231   TEST_f_f (log2, nan_value, nan_value);
4232
4233   TEST_f_f (log2, M_El, M_LOG2El);
4234   TEST_f_f (log2, 2.0, 1);
4235   TEST_f_f (log2, 16.0, 4);
4236   TEST_f_f (log2, 256.0, 8);
4237   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
4238
4239   END (log2);
4240 }
4241
4242
4243 static void
4244 logb_test (void)
4245 {
4246   START (logb);
4247
4248   TEST_f_f (logb, plus_infty, plus_infty);
4249   TEST_f_f (logb, minus_infty, plus_infty);
4250
4251   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4252
4253   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4254   TEST_f_f (logb, nan_value, nan_value);
4255
4256   TEST_f_f (logb, 1, 0);
4257   TEST_f_f (logb, M_El, 1);
4258   TEST_f_f (logb, 1024, 10);
4259   TEST_f_f (logb, -2000, 10);
4260
4261   END (logb);
4262 }
4263
4264
4265 static void
4266 lround_test (void)
4267 {
4268   START (lround);
4269
4270   TEST_f_l (lround, 0, 0);
4271   TEST_f_l (lround, minus_zero, 0);
4272   TEST_f_l (lround, 0.2L, 0.0);
4273   TEST_f_l (lround, -0.2L, 0);
4274   TEST_f_l (lround, 0.5, 1);
4275   TEST_f_l (lround, -0.5, -1);
4276   TEST_f_l (lround, 0.8L, 1);
4277   TEST_f_l (lround, -0.8L, -1);
4278   TEST_f_l (lround, 1.5, 2);
4279   TEST_f_l (lround, -1.5, -2);
4280   TEST_f_l (lround, 22514.5, 22515);
4281   TEST_f_l (lround, -22514.5, -22515);
4282   TEST_f_l (lround, 1071930.0008, 1071930);
4283 #ifndef TEST_FLOAT
4284   TEST_f_l (lround, 1073741824.01, 1073741824);
4285 # if LONG_MAX > 281474976710656
4286   TEST_f_l (lround, 281474976710656.025, 281474976710656);
4287 # endif
4288   TEST_f_l (lround, 2097152.5, 2097153);
4289   TEST_f_l (lround, -2097152.5, -2097153);
4290 #endif
4291   END (lround);
4292 }
4293
4294
4295 static void
4296 llround_test (void)
4297 {
4298   START (llround);
4299
4300   TEST_f_L (llround, 0, 0);
4301   TEST_f_L (llround, minus_zero, 0);
4302   TEST_f_L (llround, 0.2L, 0.0);
4303   TEST_f_L (llround, -0.2L, 0);
4304   TEST_f_L (llround, 0.5, 1);
4305   TEST_f_L (llround, -0.5, -1);
4306   TEST_f_L (llround, 0.8L, 1);
4307   TEST_f_L (llround, -0.8L, -1);
4308   TEST_f_L (llround, 1.5, 2);
4309   TEST_f_L (llround, -1.5, -2);
4310   TEST_f_L (llround, 22514.5, 22515);
4311   TEST_f_L (llround, -22514.5, -22515);
4312   TEST_f_l (llround, 1071930.0008, 1071930);
4313 #ifndef TEST_FLOAT
4314   TEST_f_L (llround, 2097152.5, 2097153);
4315   TEST_f_L (llround, -2097152.5, -2097153);
4316   TEST_f_L (llround, 34359738368.5, 34359738369ll);
4317   TEST_f_L (llround, -34359738368.5, -34359738369ll);
4318 #endif
4319
4320   /* Test boundary conditions.  */
4321   /* 0x1FFFFF */
4322   TEST_f_L (llround, 2097151.0, 2097151LL);
4323   /* 0x800000 */
4324   TEST_f_L (llround, 8388608.0, 8388608LL);
4325   /* 0x1000000 */
4326   TEST_f_L (llround, 16777216.0, 16777216LL);
4327   /* 0x20000000000 */
4328   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
4329   /* 0x40000000000 */
4330   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
4331   /* 0x1000000000000 */
4332   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
4333   /* 0x10000000000000 */
4334   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
4335   /* 0x10000080000000 */
4336   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
4337   /* 0x20000000000000 */
4338   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
4339   /* 0x80000000000000 */
4340   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
4341   /* 0x100000000000000 */
4342   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
4343
4344 #ifndef TEST_FLOAT
4345   /* 0x100000000 */
4346   TEST_f_L (llround, 4294967295.5, 4294967296LL);
4347   /* 0x200000000 */
4348   TEST_f_L (llround, 8589934591.5, 8589934592LL);
4349 #endif
4350
4351 #ifdef TEST_LDOUBLE
4352   /* The input can only be represented in long double.  */
4353   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
4354   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
4355   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
4356   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
4357   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
4358
4359 # if LDBL_MANT_DIG > 100
4360   TEST_f_L (llround, 4503599627370495.4999999999999L, 4503599627370495LL);
4361   TEST_f_L (llround, 4503599627370496.4999999999999L, 4503599627370496LL);
4362   TEST_f_L (llround, 4503599627370497.4999999999999L, 4503599627370497LL);
4363   TEST_f_L (llround, 4503599627370494.5000000000001L, 4503599627370495LL);
4364   TEST_f_L (llround, 4503599627370495.5000000000001L, 4503599627370496LL);
4365   TEST_f_L (llround, 4503599627370496.5000000000001L, 4503599627370497LL);
4366
4367   TEST_f_L (llround, -4503599627370495.4999999999999L, -4503599627370495LL);
4368   TEST_f_L (llround, -4503599627370496.4999999999999L, -4503599627370496LL);
4369   TEST_f_L (llround, -4503599627370497.4999999999999L, -4503599627370497LL);
4370   TEST_f_L (llround, -4503599627370494.5000000000001L, -4503599627370495LL);
4371   TEST_f_L (llround, -4503599627370495.5000000000001L, -4503599627370496LL);
4372   TEST_f_L (llround, -4503599627370496.5000000000001L, -4503599627370497LL);
4373 # endif
4374
4375   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
4376   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
4377   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
4378   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
4379   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
4380
4381   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
4382   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
4383   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
4384   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
4385   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
4386
4387 # if LDBL_MANT_DIG > 100
4388   TEST_f_L (llround, 9007199254740991.4999999999999L, 9007199254740991LL);
4389   TEST_f_L (llround, 9007199254740992.4999999999999L, 9007199254740992LL);
4390   TEST_f_L (llround, 9007199254740993.4999999999999L, 9007199254740993LL);
4391   TEST_f_L (llround, 9007199254740991.5000000000001L, 9007199254740992LL);
4392   TEST_f_L (llround, 9007199254740992.5000000000001L, 9007199254740993LL);
4393   TEST_f_L (llround, 9007199254740993.5000000000001L, 9007199254740994LL);
4394
4395   TEST_f_L (llround, -9007199254740991.4999999999999L, -9007199254740991LL);
4396   TEST_f_L (llround, -9007199254740992.4999999999999L, -9007199254740992LL);
4397   TEST_f_L (llround, -9007199254740993.4999999999999L, -9007199254740993LL);
4398   TEST_f_L (llround, -9007199254740991.5000000000001L, -9007199254740992LL);
4399   TEST_f_L (llround, -9007199254740992.5000000000001L, -9007199254740993LL);
4400   TEST_f_L (llround, -9007199254740993.5000000000001L, -9007199254740994LL);
4401 # endif
4402
4403   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
4404   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
4405   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
4406   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
4407   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
4408
4409   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
4410   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
4411   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
4412   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
4413   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
4414
4415   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
4416   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
4417   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
4418   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
4419   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
4420
4421   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
4422   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
4423   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
4424   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
4425   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
4426   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
4427 #endif
4428
4429   END (llround);
4430 }
4431
4432 static void
4433 modf_test (void)
4434 {
4435   FLOAT x;
4436
4437   START (modf);
4438
4439   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
4440   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
4441   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
4442   TEST_fF_f1 (modf, 0, 0, 0);
4443   TEST_fF_f1 (modf, 1.5, 0.5, 1);
4444   TEST_fF_f1 (modf, 2.5, 0.5, 2);
4445   TEST_fF_f1 (modf, -2.5, -0.5, -2);
4446   TEST_fF_f1 (modf, 20, 0, 20);
4447   TEST_fF_f1 (modf, 21, 0, 21);
4448   TEST_fF_f1 (modf, 89.5, 0.5, 89);
4449
4450   END (modf);
4451 }
4452
4453
4454 static void
4455 nearbyint_test (void)
4456 {
4457   START (nearbyint);
4458
4459   TEST_f_f (nearbyint, 0.0, 0.0);
4460   TEST_f_f (nearbyint, minus_zero, minus_zero);
4461   TEST_f_f (nearbyint, plus_infty, plus_infty);
4462   TEST_f_f (nearbyint, minus_infty, minus_infty);
4463   TEST_f_f (nearbyint, nan_value, nan_value);
4464
4465   /* Default rounding mode is round to nearest.  */
4466   TEST_f_f (nearbyint, 0.5, 0.0);
4467   TEST_f_f (nearbyint, 1.5, 2.0);
4468   TEST_f_f (nearbyint, -0.5, minus_zero);
4469   TEST_f_f (nearbyint, -1.5, -2.0);
4470
4471   END (nearbyint);
4472 }
4473
4474 static void
4475 nextafter_test (void)
4476 {
4477
4478   START (nextafter);
4479
4480   TEST_ff_f (nextafter, 0, 0, 0);
4481   TEST_ff_f (nextafter, minus_zero, 0, 0);
4482   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
4483   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
4484
4485   TEST_ff_f (nextafter, 9, 9, 9);
4486   TEST_ff_f (nextafter, -9, -9, -9);
4487   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
4488   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
4489
4490   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
4491   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
4492   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
4493
4494   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4495                          LDBL_MAX, DBL_MAX, FLT_MAX);
4496   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
4497   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
4498
4499 #ifdef TEST_LDOUBLE
4500   // XXX Enable once gcc is fixed.
4501   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
4502 #endif
4503
4504   /* XXX We need the hexadecimal FP number representation here for further
4505      tests.  */
4506
4507   END (nextafter);
4508 }
4509
4510
4511 static void
4512 nexttoward_test (void)
4513 {
4514   START (nexttoward);
4515   TEST_ff_f (nexttoward, 0, 0, 0);
4516   TEST_ff_f (nexttoward, minus_zero, 0, 0);
4517   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
4518   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
4519
4520   TEST_ff_f (nexttoward, 9, 9, 9);
4521   TEST_ff_f (nexttoward, -9, -9, -9);
4522   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
4523   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
4524
4525   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
4526   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
4527   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
4528
4529   /* XXX We need the hexadecimal FP number representation here for further
4530      tests.  */
4531
4532   END (nexttoward);
4533 }
4534
4535
4536 static void
4537 pow_test (void)
4538 {
4539
4540   errno = 0;
4541   FUNC(pow) (0, 0);
4542   if (errno == ENOSYS)
4543     /* Function not implemented.  */
4544     return;
4545
4546   START (pow);
4547
4548   TEST_ff_f (pow, 0, 0, 1);
4549   TEST_ff_f (pow, 0, minus_zero, 1);
4550   TEST_ff_f (pow, minus_zero, 0, 1);
4551   TEST_ff_f (pow, minus_zero, minus_zero, 1);
4552
4553   TEST_ff_f (pow, 10, 0, 1);
4554   TEST_ff_f (pow, 10, minus_zero, 1);
4555   TEST_ff_f (pow, -10, 0, 1);
4556   TEST_ff_f (pow, -10, minus_zero, 1);
4557
4558   TEST_ff_f (pow, nan_value, 0, 1);
4559   TEST_ff_f (pow, nan_value, minus_zero, 1);
4560
4561
4562 #ifndef TEST_INLINE
4563   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
4564   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
4565   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
4566   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
4567
4568   TEST_ff_f (pow, 0.9L, plus_infty, 0);
4569   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
4570   TEST_ff_f (pow, -0.9L, plus_infty, 0);
4571   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
4572
4573   TEST_ff_f (pow, 1.1L, minus_infty, 0);
4574   TEST_ff_f (pow, plus_infty, minus_infty, 0);
4575   TEST_ff_f (pow, -1.1L, minus_infty, 0);
4576   TEST_ff_f (pow, minus_infty, minus_infty, 0);
4577
4578   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
4579   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
4580   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
4581   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
4582
4583   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
4584   TEST_ff_f (pow, plus_infty, 1, plus_infty);
4585   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
4586
4587   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
4588   TEST_ff_f (pow, plus_infty, -1, 0);
4589   TEST_ff_f (pow, plus_infty, -1e7L, 0);
4590
4591   TEST_ff_f (pow, minus_infty, 1, minus_infty);
4592   TEST_ff_f (pow, minus_infty, 11, minus_infty);
4593   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
4594
4595   TEST_ff_f (pow, minus_infty, 2, plus_infty);
4596   TEST_ff_f (pow, minus_infty, 12, plus_infty);
4597   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
4598   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
4599   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
4600   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
4601   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
4602
4603   TEST_ff_f (pow, minus_infty, -1, minus_zero);
4604   TEST_ff_f (pow, minus_infty, -11, minus_zero);
4605   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
4606
4607   TEST_ff_f (pow, minus_infty, -2, 0);
4608   TEST_ff_f (pow, minus_infty, -12, 0);
4609   TEST_ff_f (pow, minus_infty, -1002, 0);
4610   TEST_ff_f (pow, minus_infty, -0.1L, 0);
4611   TEST_ff_f (pow, minus_infty, -1.1L, 0);
4612   TEST_ff_f (pow, minus_infty, -11.1L, 0);
4613   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
4614 #endif
4615
4616   TEST_ff_f (pow, nan_value, nan_value, nan_value);
4617   TEST_ff_f (pow, 0, nan_value, nan_value);
4618   TEST_ff_f (pow, 1, nan_value, 1);
4619   TEST_ff_f (pow, -1, nan_value, nan_value);
4620   TEST_ff_f (pow, nan_value, 1, nan_value);
4621   TEST_ff_f (pow, nan_value, -1, nan_value);
4622
4623   /* pow (x, NaN) == NaN.  */
4624   TEST_ff_f (pow, 3.0, nan_value, nan_value);
4625   TEST_ff_f (pow, minus_zero, nan_value, nan_value);
4626   TEST_ff_f (pow, plus_infty, nan_value, nan_value);
4627   TEST_ff_f (pow, -3.0, nan_value, nan_value);
4628   TEST_ff_f (pow, minus_infty, nan_value, nan_value);
4629
4630   TEST_ff_f (pow, nan_value, 3.0, nan_value);
4631   TEST_ff_f (pow, nan_value, -3.0, nan_value);
4632   TEST_ff_f (pow, nan_value, plus_infty, nan_value);
4633   TEST_ff_f (pow, nan_value, minus_infty, nan_value);
4634   TEST_ff_f (pow, nan_value, 2.5, nan_value);
4635   TEST_ff_f (pow, nan_value, -2.5, nan_value);
4636
4637   TEST_ff_f (pow, 1, plus_infty, 1);
4638   TEST_ff_f (pow, -1, plus_infty, 1);
4639   TEST_ff_f (pow, 1, minus_infty, 1);
4640   TEST_ff_f (pow, -1, minus_infty, 1);
4641   TEST_ff_f (pow, 1, 1, 1);
4642   TEST_ff_f (pow, 1, -1, 1);
4643   TEST_ff_f (pow, 1, 1.25, 1);
4644   TEST_ff_f (pow, 1, -1.25, 1);
4645   TEST_ff_f (pow, 1, 0x1p62L, 1);
4646   TEST_ff_f (pow, 1, 0x1p63L, 1);
4647   TEST_ff_f (pow, 1, 0x1p64L, 1);
4648   TEST_ff_f (pow, 1, 0x1p72L, 1);
4649
4650   /* pow (x, +-0) == 1.  */
4651   TEST_ff_f (pow, plus_infty, 0, 1);
4652   TEST_ff_f (pow, plus_infty, minus_zero, 1);
4653   TEST_ff_f (pow, minus_infty, 0, 1);
4654   TEST_ff_f (pow, minus_infty, minus_zero, 1);
4655   TEST_ff_f (pow, 32.75L, 0, 1);
4656   TEST_ff_f (pow, 32.75L, minus_zero, 1);
4657   TEST_ff_f (pow, -32.75L, 0, 1);
4658   TEST_ff_f (pow, -32.75L, minus_zero, 1);
4659   TEST_ff_f (pow, 0x1p72L, 0, 1);
4660   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
4661   TEST_ff_f (pow, 0x1p-72L, 0, 1);
4662   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
4663
4664   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
4665   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
4666   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
4667   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
4668
4669   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4670   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4671   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4672   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4673
4674   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4675   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4676   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4677   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4678
4679   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty);
4680   TEST_ff_f (pow, 10, -0x1p72L, 0);
4681   TEST_ff_f (pow, max_value, max_value, plus_infty);
4682   TEST_ff_f (pow, 10, -max_value, 0);
4683
4684   TEST_ff_f (pow, 0, 1, 0);
4685   TEST_ff_f (pow, 0, 11, 0);
4686
4687   TEST_ff_f (pow, minus_zero, 1, minus_zero);
4688   TEST_ff_f (pow, minus_zero, 11, minus_zero);
4689
4690
4691   TEST_ff_f (pow, 0, 2, 0);
4692   TEST_ff_f (pow, 0, 11.1L, 0);
4693
4694
4695   TEST_ff_f (pow, minus_zero, 2, 0);
4696   TEST_ff_f (pow, minus_zero, 11.1L, 0);
4697   TEST_ff_f (pow, 0, plus_infty, 0);
4698   TEST_ff_f (pow, minus_zero, plus_infty, 0);
4699
4700 #ifndef TEST_INLINE
4701   /* pow (x, +inf) == +inf for |x| > 1.  */
4702   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
4703
4704   /* pow (x, +inf) == +0 for |x| < 1.  */
4705   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
4706
4707   /* pow (x, -inf) == +0 for |x| > 1.  */
4708   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
4709
4710   /* pow (x, -inf) == +inf for |x| < 1.  */
4711   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
4712 #endif
4713
4714   /* pow (+inf, y) == +inf for y > 0.  */
4715   TEST_ff_f (pow, plus_infty, 2, plus_infty);
4716
4717   /* pow (+inf, y) == +0 for y < 0.  */
4718   TEST_ff_f (pow, plus_infty, -1, 0.0);
4719
4720   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
4721   TEST_ff_f (pow, minus_infty, 27, minus_infty);
4722
4723   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
4724   TEST_ff_f (pow, minus_infty, 28, plus_infty);
4725
4726   /* pow (-inf, y) == -0 for y an odd integer < 0. */
4727   TEST_ff_f (pow, minus_infty, -3, minus_zero);
4728   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
4729   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
4730
4731   /* pow (+0, y) == +0 for y an odd integer > 0.  */
4732   TEST_ff_f (pow, 0.0, 27, 0.0);
4733
4734   /* pow (-0, y) == -0 for y an odd integer > 0.  */
4735   TEST_ff_f (pow, minus_zero, 27, minus_zero);
4736
4737   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
4738   TEST_ff_f (pow, 0.0, 4, 0.0);
4739
4740   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
4741   TEST_ff_f (pow, minus_zero, 4, 0.0);
4742
4743   TEST_ff_f (pow, 16, 0.25L, 2);
4744   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
4745   TEST_ff_f (pow, 2, 4, 16);
4746   TEST_ff_f (pow, 256, 8, 0x1p64L);
4747
4748   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
4749
4750 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
4751   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
4752 #endif
4753
4754   END (pow);
4755 }
4756
4757 static void
4758 remainder_test (void)
4759 {
4760   errno = 0;
4761   FUNC(remainder) (1.625, 1.0);
4762   if (errno == ENOSYS)
4763     /* Function not implemented.  */
4764     return;
4765
4766   START (remainder);
4767
4768   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
4769   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
4770   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
4771   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
4772   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
4773
4774   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
4775   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
4776   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
4777   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
4778   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
4779   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
4780
4781   END (remainder);
4782 }
4783
4784 static void
4785 remquo_test (void)
4786 {
4787   /* x is needed.  */
4788   int x;
4789
4790   errno = 0;
4791   FUNC(remquo) (1.625, 1.0, &x);
4792   if (errno == ENOSYS)
4793     /* Function not implemented.  */
4794     return;
4795
4796   START (remquo);
4797
4798   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
4799   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
4800   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
4801   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
4802   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
4803
4804   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
4805   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
4806   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
4807   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
4808
4809   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
4810   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
4811
4812   END (remquo);
4813 }
4814
4815 static void
4816 rint_test (void)
4817 {
4818   START (rint);
4819
4820   TEST_f_f (rint, 0.0, 0.0);
4821   TEST_f_f (rint, minus_zero, minus_zero);
4822   TEST_f_f (rint, plus_infty, plus_infty);
4823   TEST_f_f (rint, minus_infty, minus_infty);
4824
4825   /* Default rounding mode is round to even.  */
4826   TEST_f_f (rint, 0.5, 0.0);
4827   TEST_f_f (rint, 1.5, 2.0);
4828   TEST_f_f (rint, 2.5, 2.0);
4829   TEST_f_f (rint, 3.5, 4.0);
4830   TEST_f_f (rint, 4.5, 4.0);
4831   TEST_f_f (rint, -0.5, -0.0);
4832   TEST_f_f (rint, -1.5, -2.0);
4833   TEST_f_f (rint, -2.5, -2.0);
4834   TEST_f_f (rint, -3.5, -4.0);
4835   TEST_f_f (rint, -4.5, -4.0);
4836   TEST_f_f (rint, 0.1, 0.0);
4837   TEST_f_f (rint, 0.25, 0.0);
4838   TEST_f_f (rint, 0.625, 1.0);
4839   TEST_f_f (rint, -0.1, -0.0);
4840   TEST_f_f (rint, -0.25, -0.0);
4841   TEST_f_f (rint, -0.625, -1.0);
4842 #ifdef TEST_LDOUBLE
4843   /* The result can only be represented in long double.  */
4844   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
4845   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
4846   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
4847   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
4848   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
4849
4850 # if LDBL_MANT_DIG > 100
4851   TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
4852   TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
4853   TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
4854 # endif
4855
4856   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
4857   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
4858   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
4859   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
4860   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
4861
4862 # if LDBL_MANT_DIG > 100
4863   TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
4864   TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
4865   TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
4866
4867   TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
4868   TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
4869   TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
4870   TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
4871   TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
4872   TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
4873
4874   TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
4875   TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
4876   TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
4877   TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
4878   TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
4879   TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
4880 # endif
4881
4882   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
4883   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
4884   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
4885   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
4886   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
4887
4888   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
4889   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
4890   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
4891   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
4892   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
4893
4894   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
4895   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
4896   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
4897   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
4898   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
4899
4900   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
4901   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
4902   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
4903   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
4904   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
4905
4906   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
4907   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4908   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4909   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
4910   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
4911 #endif
4912
4913   END (rint);
4914 }
4915
4916 static void
4917 rint_test_tonearest (void)
4918 {
4919   int save_round_mode;
4920   START (rint_tonearest);
4921
4922   save_round_mode = fegetround ();
4923
4924   if (!fesetround (FE_TONEAREST))
4925     {
4926       TEST_f_f (rint, 2.0, 2.0);
4927       TEST_f_f (rint, 1.5, 2.0);
4928       TEST_f_f (rint, 1.0, 1.0);
4929       TEST_f_f (rint, 0.5, 0.0);
4930       TEST_f_f (rint, 0.0, 0.0);
4931       TEST_f_f (rint, minus_zero, minus_zero);
4932       TEST_f_f (rint, -0.5, -0.0);
4933       TEST_f_f (rint, -1.0, -1.0);
4934       TEST_f_f (rint, -1.5, -2.0);
4935       TEST_f_f (rint, -2.0, -2.0);
4936       TEST_f_f (rint, 0.1, 0.0);
4937       TEST_f_f (rint, 0.25, 0.0);
4938       TEST_f_f (rint, 0.625, 1.0);
4939       TEST_f_f (rint, -0.1, -0.0);
4940       TEST_f_f (rint, -0.25, -0.0);
4941       TEST_f_f (rint, -0.625, -1.0);
4942 #ifdef TEST_LDOUBLE
4943       /* The result can only be represented in long double.  */
4944       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
4945       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
4946       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
4947       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
4948       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
4949 # if LDBL_MANT_DIG > 100
4950       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
4951       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
4952       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
4953 # endif
4954       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
4955       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
4956       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
4957       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
4958       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
4959 # if LDBL_MANT_DIG > 100
4960       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
4961       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
4962       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
4963
4964       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
4965       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
4966       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
4967       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
4968       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
4969       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
4970
4971       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
4972       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
4973       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
4974       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
4975       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
4976       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
4977 # endif
4978 #endif
4979     }
4980
4981   fesetround (save_round_mode);
4982
4983   END (rint_tonearest);
4984 }
4985
4986 static void
4987 rint_test_towardzero (void)
4988 {
4989   int save_round_mode;
4990   START (rint_towardzero);
4991
4992   save_round_mode = fegetround ();
4993
4994   if (!fesetround (FE_TOWARDZERO))
4995     {
4996       TEST_f_f (rint, 2.0, 2.0);
4997       TEST_f_f (rint, 1.5, 1.0);
4998       TEST_f_f (rint, 1.0, 1.0);
4999       TEST_f_f (rint, 0.5, 0.0);
5000       TEST_f_f (rint, 0.0, 0.0);
5001       TEST_f_f (rint, minus_zero, minus_zero);
5002       TEST_f_f (rint, -0.5, -0.0);
5003       TEST_f_f (rint, -1.0, -1.0);
5004       TEST_f_f (rint, -1.5, -1.0);
5005       TEST_f_f (rint, -2.0, -2.0);
5006       TEST_f_f (rint, 0.1, 0.0);
5007       TEST_f_f (rint, 0.25, 0.0);
5008       TEST_f_f (rint, 0.625, 0.0);
5009       TEST_f_f (rint, -0.1, -0.0);
5010       TEST_f_f (rint, -0.25, -0.0);
5011       TEST_f_f (rint, -0.625, -0.0);
5012 #ifdef TEST_LDOUBLE
5013       /* The result can only be represented in long double.  */
5014       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
5015       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
5016       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
5017       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
5018       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
5019 # if LDBL_MANT_DIG > 100
5020       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
5021       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
5022       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
5023 # endif
5024       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
5025       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
5026       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
5027       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
5028       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
5029 # if LDBL_MANT_DIG > 100
5030       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
5031       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
5032       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
5033
5034       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
5035       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
5036       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
5037       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
5038       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
5039       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
5040
5041       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
5042       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
5043       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
5044       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
5045       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
5046       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
5047 # endif
5048 #endif
5049     }
5050
5051   fesetround (save_round_mode);
5052
5053   END (rint_towardzero);
5054 }
5055
5056 static void
5057 rint_test_downward (void)
5058 {
5059   int save_round_mode;
5060   START (rint_downward);
5061
5062   save_round_mode = fegetround ();
5063
5064   if (!fesetround (FE_DOWNWARD))
5065     {
5066       TEST_f_f (rint, 2.0, 2.0);
5067       TEST_f_f (rint, 1.5, 1.0);
5068       TEST_f_f (rint, 1.0, 1.0);
5069       TEST_f_f (rint, 0.5, 0.0);
5070       TEST_f_f (rint, 0.0, 0.0);
5071       TEST_f_f (rint, minus_zero, minus_zero);
5072       TEST_f_f (rint, -0.5, -1.0);
5073       TEST_f_f (rint, -1.0, -1.0);
5074       TEST_f_f (rint, -1.5, -2.0);
5075       TEST_f_f (rint, -2.0, -2.0);
5076       TEST_f_f (rint, 0.1, 0.0);
5077       TEST_f_f (rint, 0.25, 0.0);
5078       TEST_f_f (rint, 0.625, 0.0);
5079       TEST_f_f (rint, -0.1, -1.0);
5080       TEST_f_f (rint, -0.25, -1.0);
5081       TEST_f_f (rint, -0.625, -1.0);
5082 #ifdef TEST_LDOUBLE
5083       /* The result can only be represented in long double.  */
5084       TEST_f_f (rint, 4503599627370495.5L, 4503599627370495.0L);
5085       TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
5086       TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
5087       TEST_f_f (rint, 4503599627370496.75L, 4503599627370496.0L);
5088       TEST_f_f (rint, 4503599627370497.5L, 4503599627370497.0L);
5089 # if LDBL_MANT_DIG > 100
5090       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370494.0L);
5091       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370495.0L);
5092       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370496.0L);
5093 # endif
5094       TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
5095       TEST_f_f (rint, -4503599627370496.25L, -4503599627370497.0L);
5096       TEST_f_f (rint, -4503599627370496.5L, -4503599627370497.0L);
5097       TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
5098       TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
5099 # if LDBL_MANT_DIG > 100
5100       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370495.0L);
5101       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370496.0L);
5102       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370497.0L);
5103
5104       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740991.0L);
5105       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740992.0L);
5106       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740993.0L);
5107       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740991.0L);
5108       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740992.0L);
5109       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740993.0L);
5110
5111       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740992.0L);
5112       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740993.0L);
5113       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740994.0L);
5114       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740992.0L);
5115       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740993.0L);
5116       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L);
5117 # endif
5118 #endif
5119     }
5120
5121   fesetround (save_round_mode);
5122
5123   END (rint_downward);
5124 }
5125
5126 static void
5127 rint_test_upward (void)
5128 {
5129   int save_round_mode;
5130   START (rint_upward);
5131
5132   save_round_mode = fegetround ();
5133
5134   if (!fesetround (FE_UPWARD))
5135     {
5136       TEST_f_f (rint, 2.0, 2.0);
5137       TEST_f_f (rint, 1.5, 2.0);
5138       TEST_f_f (rint, 1.0, 1.0);
5139       TEST_f_f (rint, 0.5, 1.0);
5140       TEST_f_f (rint, 0.0, 0.0);
5141       TEST_f_f (rint, minus_zero, minus_zero);
5142       TEST_f_f (rint, -0.5, -0.0);
5143       TEST_f_f (rint, -1.0, -1.0);
5144       TEST_f_f (rint, -1.5, -1.0);
5145       TEST_f_f (rint, -2.0, -2.0);
5146       TEST_f_f (rint, 0.1, 1.0);
5147       TEST_f_f (rint, 0.25, 1.0);
5148       TEST_f_f (rint, 0.625, 1.0);
5149       TEST_f_f (rint, -0.1, -0.0);
5150       TEST_f_f (rint, -0.25, -0.0);
5151       TEST_f_f (rint, -0.625, -0.0);
5152 #ifdef TEST_LDOUBLE
5153       /* The result can only be represented in long double.  */
5154       TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
5155       TEST_f_f (rint, 4503599627370496.25L, 4503599627370497.0L);
5156       TEST_f_f (rint, 4503599627370496.5L, 4503599627370497.0L);
5157       TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
5158       TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
5159 # if LDBL_MANT_DIG > 100
5160       TEST_f_f (rint, 4503599627370494.5000000000001L, 4503599627370495.0L);
5161       TEST_f_f (rint, 4503599627370495.5000000000001L, 4503599627370496.0L);
5162       TEST_f_f (rint, 4503599627370496.5000000000001L, 4503599627370497.0L);
5163 # endif
5164       TEST_f_f (rint, -4503599627370495.5L, -4503599627370495.0L);
5165       TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
5166       TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
5167       TEST_f_f (rint, -4503599627370496.75L, -4503599627370496.0L);
5168       TEST_f_f (rint, -4503599627370497.5L, -4503599627370497.0L);
5169 # if LDBL_MANT_DIG > 100
5170       TEST_f_f (rint, -4503599627370494.5000000000001L, -4503599627370494.0L);
5171       TEST_f_f (rint, -4503599627370495.5000000000001L, -4503599627370495.0L);
5172       TEST_f_f (rint, -4503599627370496.5000000000001L, -4503599627370496.0L);
5173
5174       TEST_f_f (rint, 9007199254740991.0000000000001L, 9007199254740992.0L);
5175       TEST_f_f (rint, 9007199254740992.0000000000001L, 9007199254740993.0L);
5176       TEST_f_f (rint, 9007199254740993.0000000000001L, 9007199254740994.0L);
5177       TEST_f_f (rint, 9007199254740991.5000000000001L, 9007199254740992.0L);
5178       TEST_f_f (rint, 9007199254740992.5000000000001L, 9007199254740993.0L);
5179       TEST_f_f (rint, 9007199254740993.5000000000001L, 9007199254740994.0L);
5180
5181       TEST_f_f (rint, -9007199254740991.0000000000001L, -9007199254740991.0L);
5182       TEST_f_f (rint, -9007199254740992.0000000000001L, -9007199254740992.0L);
5183       TEST_f_f (rint, -9007199254740993.0000000000001L, -9007199254740993.0L);
5184       TEST_f_f (rint, -9007199254740991.5000000000001L, -9007199254740991.0L);
5185       TEST_f_f (rint, -9007199254740992.5000000000001L, -9007199254740992.0L);
5186       TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L);
5187 # endif
5188 #endif
5189     }
5190
5191   fesetround (save_round_mode);
5192
5193   END (rint_upward);
5194 }
5195
5196 static void
5197 round_test (void)
5198 {
5199   START (round);
5200
5201   TEST_f_f (round, 0, 0);
5202   TEST_f_f (round, minus_zero, minus_zero);
5203   TEST_f_f (round, 0.2L, 0.0);
5204   TEST_f_f (round, -0.2L, minus_zero);
5205   TEST_f_f (round, 0.5, 1.0);
5206   TEST_f_f (round, -0.5, -1.0);
5207   TEST_f_f (round, 0.8L, 1.0);
5208   TEST_f_f (round, -0.8L, -1.0);
5209   TEST_f_f (round, 1.5, 2.0);
5210   TEST_f_f (round, -1.5, -2.0);
5211   TEST_f_f (round, 0.1, 0.0);
5212   TEST_f_f (round, 0.25, 0.0);
5213   TEST_f_f (round, 0.625, 1.0);
5214   TEST_f_f (round, -0.1, -0.0);
5215   TEST_f_f (round, -0.25, -0.0);
5216   TEST_f_f (round, -0.625, -1.0);
5217   TEST_f_f (round, 2097152.5, 2097153);
5218   TEST_f_f (round, -2097152.5, -2097153);
5219
5220 #ifdef TEST_LDOUBLE
5221   /* The result can only be represented in long double.  */
5222   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
5223   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
5224   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
5225   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
5226   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
5227 # if LDBL_MANT_DIG > 100
5228   TEST_f_f (round, 4503599627370494.5000000000001L, 4503599627370495.0L);
5229   TEST_f_f (round, 4503599627370495.5000000000001L, 4503599627370496.0L);
5230   TEST_f_f (round, 4503599627370496.5000000000001L, 4503599627370497.0L);
5231 # endif
5232
5233   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
5234   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
5235   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
5236   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
5237   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
5238 # if LDBL_MANT_DIG > 100
5239   TEST_f_f (round, -4503599627370494.5000000000001L, -4503599627370495.0L);
5240   TEST_f_f (round, -4503599627370495.5000000000001L, -4503599627370496.0L);
5241   TEST_f_f (round, -4503599627370496.5000000000001L, -4503599627370497.0L);
5242 # endif
5243
5244   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
5245   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
5246   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
5247   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
5248   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
5249
5250   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
5251   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
5252   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
5253   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
5254   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
5255
5256 # if LDBL_MANT_DIG > 100
5257   TEST_f_f (round, 9007199254740991.0000000000001L, 9007199254740991.0L);
5258   TEST_f_f (round, 9007199254740992.0000000000001L, 9007199254740992.0L);
5259   TEST_f_f (round, 9007199254740993.0000000000001L, 9007199254740993.0L);
5260   TEST_f_f (round, 9007199254740991.5000000000001L, 9007199254740992.0L);
5261   TEST_f_f (round, 9007199254740992.5000000000001L, 9007199254740993.0L);
5262   TEST_f_f (round, 9007199254740993.5000000000001L, 9007199254740994.0L);
5263
5264   TEST_f_f (round, -9007199254740991.0000000000001L, -9007199254740991.0L);
5265   TEST_f_f (round, -9007199254740992.0000000000001L, -9007199254740992.0L);
5266   TEST_f_f (round, -9007199254740993.0000000000001L, -9007199254740993.0L);
5267   TEST_f_f (round, -9007199254740991.5000000000001L, -9007199254740992.0L);
5268   TEST_f_f (round, -9007199254740992.5000000000001L, -9007199254740993.0L);
5269   TEST_f_f (round, -9007199254740993.5000000000001L, -9007199254740994.0L);
5270 # endif
5271
5272   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
5273   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
5274   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
5275   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
5276   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
5277
5278   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
5279   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
5280   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
5281   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
5282   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
5283
5284   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
5285   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
5286   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
5287   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
5288   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
5289 #endif
5290
5291   END (round);
5292 }
5293
5294
5295 static void
5296 scalb_test (void)
5297 {
5298
5299   START (scalb);
5300
5301   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
5302   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
5303
5304   TEST_ff_f (scalb, 0, nan_value, nan_value);
5305   TEST_ff_f (scalb, 1, nan_value, nan_value);
5306
5307   TEST_ff_f (scalb, 1, 0, 1);
5308   TEST_ff_f (scalb, -1, 0, -1);
5309
5310   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
5311   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
5312
5313   TEST_ff_f (scalb, 0, 2, 0);
5314   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
5315   TEST_ff_f (scalb, 0, 0, 0);
5316   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
5317   TEST_ff_f (scalb, 0, -1, 0);
5318   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
5319   TEST_ff_f (scalb, 0, minus_infty, 0);
5320   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
5321
5322   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
5323   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
5324   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
5325   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
5326   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
5327   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
5328
5329   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
5330   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
5331
5332   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
5333   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
5334   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
5335   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
5336
5337   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
5338   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
5339
5340   TEST_ff_f (scalb, nan_value, 1, nan_value);
5341   TEST_ff_f (scalb, 1, nan_value, nan_value);
5342   TEST_ff_f (scalb, nan_value, 0, nan_value);
5343   TEST_ff_f (scalb, 0, nan_value, nan_value);
5344   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
5345   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
5346   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
5347
5348   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
5349   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
5350
5351   END (scalb);
5352 }
5353
5354
5355 static void
5356 scalbn_test (void)
5357 {
5358
5359   START (scalbn);
5360
5361   TEST_fi_f (scalbn, 0, 0, 0);
5362   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
5363
5364   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
5365   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
5366   TEST_fi_f (scalbn, nan_value, 1, nan_value);
5367
5368   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
5369   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
5370
5371   TEST_fi_f (scalbn, 1, 0L, 1);
5372
5373   END (scalbn);
5374 }
5375
5376
5377 static void
5378 scalbln_test (void)
5379 {
5380
5381   START (scalbln);
5382
5383   TEST_fl_f (scalbln, 0, 0, 0);
5384   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
5385
5386   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
5387   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
5388   TEST_fl_f (scalbln, nan_value, 1, nan_value);
5389
5390   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
5391   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
5392
5393   TEST_fl_f (scalbln, 1, 0L, 1);
5394
5395   END (scalbn);
5396 }
5397
5398
5399 static void
5400 signbit_test (void)
5401 {
5402
5403   START (signbit);
5404
5405   TEST_f_b (signbit, 0, 0);
5406   TEST_f_b (signbit, minus_zero, 1);
5407   TEST_f_b (signbit, plus_infty, 0);
5408   TEST_f_b (signbit, minus_infty, 1);
5409
5410   /* signbit (x) != 0 for x < 0.  */
5411   TEST_f_b (signbit, -1, 1);
5412   /* signbit (x) == 0 for x >= 0.  */
5413   TEST_f_b (signbit, 1, 0);
5414
5415   END (signbit);
5416 }
5417
5418
5419 static void
5420 sin_test (void)
5421 {
5422   errno = 0;
5423   FUNC(sin) (0);
5424   if (errno == ENOSYS)
5425     /* Function not implemented.  */
5426     return;
5427
5428   START (sin);
5429
5430   TEST_f_f (sin, 0, 0);
5431   TEST_f_f (sin, minus_zero, minus_zero);
5432   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
5433   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
5434   TEST_f_f (sin, nan_value, nan_value);
5435
5436   TEST_f_f (sin, M_PI_6l, 0.5);
5437   TEST_f_f (sin, -M_PI_6l, -0.5);
5438   TEST_f_f (sin, M_PI_2l, 1);
5439   TEST_f_f (sin, -M_PI_2l, -1);
5440   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
5441
5442 #ifdef TEST_DOUBLE
5443   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
5444 #endif
5445
5446   END (sin);
5447
5448 }
5449
5450
5451 static void
5452 sincos_test (void)
5453 {
5454   FLOAT sin_res, cos_res;
5455
5456   errno = 0;
5457   FUNC(sincos) (0, &sin_res, &cos_res);
5458   if (errno == ENOSYS)
5459     /* Function not implemented.  */
5460     return;
5461
5462   START (sincos);
5463
5464   /* sincos is treated differently because it returns void.  */
5465   TEST_extra (sincos, 0, 0, 1);
5466
5467   TEST_extra (sincos, minus_zero, minus_zero, 1);
5468   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
5469   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
5470   TEST_extra (sincos, nan_value, nan_value, nan_value);
5471
5472   TEST_extra (sincos, M_PI_2l, 1, 0);
5473   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
5474   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
5475   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
5476
5477 #ifdef TEST_DOUBLE
5478   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
5479 #endif
5480
5481   END (sincos);
5482 }
5483
5484 static void
5485 sinh_test (void)
5486 {
5487   errno = 0;
5488   FUNC(sinh) (0.7L);
5489   if (errno == ENOSYS)
5490     /* Function not implemented.  */
5491     return;
5492
5493   START (sinh);
5494   TEST_f_f (sinh, 0, 0);
5495   TEST_f_f (sinh, minus_zero, minus_zero);
5496
5497 #ifndef TEST_INLINE
5498   TEST_f_f (sinh, plus_infty, plus_infty);
5499   TEST_f_f (sinh, minus_infty, minus_infty);
5500 #endif
5501   TEST_f_f (sinh, nan_value, nan_value);
5502
5503   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
5504   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
5505
5506   END (sinh);
5507 }
5508
5509 static void
5510 sqrt_test (void)
5511 {
5512   errno = 0;
5513   FUNC(sqrt) (1);
5514   if (errno == ENOSYS)
5515     /* Function not implemented.  */
5516     return;
5517
5518   START (sqrt);
5519
5520   TEST_f_f (sqrt, 0, 0);
5521   TEST_f_f (sqrt, nan_value, nan_value);
5522   TEST_f_f (sqrt, plus_infty, plus_infty);
5523
5524   TEST_f_f (sqrt, minus_zero, minus_zero);
5525
5526   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
5527   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
5528   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
5529   TEST_f_f (sqrt, nan_value, nan_value);
5530
5531   TEST_f_f (sqrt, 2209, 47);
5532   TEST_f_f (sqrt, 4, 2);
5533   TEST_f_f (sqrt, 2, M_SQRT2l);
5534   TEST_f_f (sqrt, 0.25, 0.5);
5535   TEST_f_f (sqrt, 6642.25, 81.5);
5536   TEST_f_f (sqrt, 15190.5625L, 123.25L);
5537   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
5538
5539   END (sqrt);
5540 }
5541
5542
5543 static void
5544 tan_test (void)
5545 {
5546   errno = 0;
5547   FUNC(tan) (0);
5548   if (errno == ENOSYS)
5549     /* Function not implemented.  */
5550     return;
5551
5552   START (tan);
5553
5554   TEST_f_f (tan, 0, 0);
5555   TEST_f_f (tan, minus_zero, minus_zero);
5556   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
5557   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
5558   TEST_f_f (tan, nan_value, nan_value);
5559
5560   TEST_f_f (tan, M_PI_4l, 1);
5561   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
5562
5563   END (tan);
5564 }
5565
5566 static void
5567 tanh_test (void)
5568 {
5569   errno = 0;
5570   FUNC(tanh) (0.7L);
5571   if (errno == ENOSYS)
5572     /* Function not implemented.  */
5573     return;
5574
5575   START (tanh);
5576
5577   TEST_f_f (tanh, 0, 0);
5578   TEST_f_f (tanh, minus_zero, minus_zero);
5579
5580 #ifndef TEST_INLINE
5581   TEST_f_f (tanh, plus_infty, 1);
5582   TEST_f_f (tanh, minus_infty, -1);
5583 #endif
5584   TEST_f_f (tanh, nan_value, nan_value);
5585
5586   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
5587   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
5588
5589   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
5590   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
5591
5592   /* 2^-57  */
5593   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
5594
5595   END (tanh);
5596 }
5597
5598 static void
5599 tgamma_test (void)
5600 {
5601   errno = 0;
5602   FUNC(tgamma) (1);
5603   if (errno == ENOSYS)
5604     /* Function not implemented.  */
5605     return;
5606   feclearexcept (FE_ALL_EXCEPT);
5607
5608   START (tgamma);
5609
5610   TEST_f_f (tgamma, plus_infty, plus_infty);
5611   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5612   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
5613   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
5614   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
5615   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
5616   TEST_f_f (tgamma, nan_value, nan_value);
5617
5618   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
5619   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
5620
5621   TEST_f_f (tgamma, 1, 1);
5622   TEST_f_f (tgamma, 4, 6);
5623
5624   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
5625   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
5626
5627   END (tgamma);
5628 }
5629
5630
5631 static void
5632 trunc_test (void)
5633 {
5634   START (trunc);
5635
5636   TEST_f_f (trunc, plus_infty, plus_infty);
5637   TEST_f_f (trunc, minus_infty, minus_infty);
5638   TEST_f_f (trunc, nan_value, nan_value);
5639
5640   TEST_f_f (trunc, 0, 0);
5641   TEST_f_f (trunc, minus_zero, minus_zero);
5642   TEST_f_f (trunc, 0.1, 0);
5643   TEST_f_f (trunc, 0.25, 0);
5644   TEST_f_f (trunc, 0.625, 0);
5645   TEST_f_f (trunc, -0.1, minus_zero);
5646   TEST_f_f (trunc, -0.25, minus_zero);
5647   TEST_f_f (trunc, -0.625, minus_zero);
5648   TEST_f_f (trunc, 1, 1);
5649   TEST_f_f (trunc, -1, -1);
5650   TEST_f_f (trunc, 1.625, 1);
5651   TEST_f_f (trunc, -1.625, -1);
5652
5653   TEST_f_f (trunc, 1048580.625L, 1048580L);
5654   TEST_f_f (trunc, -1048580.625L, -1048580L);
5655
5656   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
5657   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
5658
5659   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
5660   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
5661
5662 #ifdef TEST_LDOUBLE
5663   /* The result can only be represented in long double.  */
5664   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
5665   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
5666   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
5667   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
5668   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
5669
5670 # if LDBL_MANT_DIG > 100
5671   TEST_f_f (trunc, 4503599627370494.5000000000001L, 4503599627370494.0L);
5672   TEST_f_f (trunc, 4503599627370495.5000000000001L, 4503599627370495.0L);
5673   TEST_f_f (trunc, 4503599627370496.5000000000001L, 4503599627370496.0L);
5674 # endif
5675
5676   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
5677   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
5678   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
5679   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
5680   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
5681
5682 # if LDBL_MANT_DIG > 100
5683   TEST_f_f (trunc, -4503599627370494.5000000000001L, -4503599627370494.0L);
5684   TEST_f_f (trunc, -4503599627370495.5000000000001L, -4503599627370495.0L);
5685   TEST_f_f (trunc, -4503599627370496.5000000000001L, -4503599627370496.0L);
5686 # endif
5687
5688   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
5689   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
5690   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
5691   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
5692   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
5693
5694 # if LDBL_MANT_DIG > 100
5695   TEST_f_f (trunc, 9007199254740991.0000000000001L, 9007199254740991.0L);
5696   TEST_f_f (trunc, 9007199254740992.0000000000001L, 9007199254740992.0L);
5697   TEST_f_f (trunc, 9007199254740993.0000000000001L, 9007199254740993.0L);
5698   TEST_f_f (trunc, 9007199254740991.5000000000001L, 9007199254740991.0L);
5699   TEST_f_f (trunc, 9007199254740992.5000000000001L, 9007199254740992.0L);
5700   TEST_f_f (trunc, 9007199254740993.5000000000001L, 9007199254740993.0L);
5701 # endif
5702
5703   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
5704   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
5705   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
5706   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
5707   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
5708
5709 # if LDBL_MANT_DIG > 100
5710   TEST_f_f (trunc, -9007199254740991.0000000000001L, -9007199254740991.0L);
5711   TEST_f_f (trunc, -9007199254740992.0000000000001L, -9007199254740992.0L);
5712   TEST_f_f (trunc, -9007199254740993.0000000000001L, -9007199254740993.0L);
5713   TEST_f_f (trunc, -9007199254740991.5000000000001L, -9007199254740991.0L);
5714   TEST_f_f (trunc, -9007199254740992.5000000000001L, -9007199254740992.0L);
5715   TEST_f_f (trunc, -9007199254740993.5000000000001L, -9007199254740993.0L);
5716 # endif
5717
5718   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
5719   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
5720   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
5721   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
5722   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
5723
5724   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
5725   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
5726   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
5727   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
5728   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
5729
5730   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
5731   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
5732   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
5733   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
5734   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
5735 #endif
5736
5737   END (trunc);
5738 }
5739
5740 static void
5741 y0_test (void)
5742 {
5743   FLOAT s, c;
5744   errno = 0;
5745   FUNC (sincos) (0, &s, &c);
5746   if (errno == ENOSYS)
5747     /* Required function not implemented.  */
5748     return;
5749   FUNC(y0) (1);
5750   if (errno == ENOSYS)
5751     /* Function not implemented.  */
5752     return;
5753
5754   /* y0 is the Bessel function of the second kind of order 0 */
5755   START (y0);
5756
5757   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
5758   TEST_f_f (y0, 0.0, minus_infty);
5759   TEST_f_f (y0, nan_value, nan_value);
5760   TEST_f_f (y0, plus_infty, 0);
5761
5762   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
5763   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
5764   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
5765   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
5766   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
5767   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
5768   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
5769
5770   END (y0);
5771 }
5772
5773
5774 static void
5775 y1_test (void)
5776 {
5777   FLOAT s, c;
5778   errno = 0;
5779   FUNC (sincos) (0, &s, &c);
5780   if (errno == ENOSYS)
5781     /* Required function not implemented.  */
5782     return;
5783   FUNC(y1) (1);
5784   if (errno == ENOSYS)
5785     /* Function not implemented.  */
5786     return;
5787
5788   /* y1 is the Bessel function of the second kind of order 1 */
5789   START (y1);
5790
5791   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
5792   TEST_f_f (y1, 0.0, minus_infty);
5793   TEST_f_f (y1, plus_infty, 0);
5794   TEST_f_f (y1, nan_value, nan_value);
5795
5796   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
5797   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
5798   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
5799   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
5800   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
5801   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
5802   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
5803
5804   END (y1);
5805 }
5806
5807
5808 static void
5809 yn_test (void)
5810 {
5811   FLOAT s, c;
5812   errno = 0;
5813   FUNC (sincos) (0, &s, &c);
5814   if (errno == ENOSYS)
5815     /* Required function not implemented.  */
5816     return;
5817   FUNC(yn) (1, 1);
5818   if (errno == ENOSYS)
5819     /* Function not implemented.  */
5820     return;
5821
5822   /* yn is the Bessel function of the second kind of order n */
5823   START (yn);
5824
5825   /* yn (0, x) == y0 (x)  */
5826   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
5827   TEST_ff_f (yn, 0, 0.0, minus_infty);
5828   TEST_ff_f (yn, 0, nan_value, nan_value);
5829   TEST_ff_f (yn, 0, plus_infty, 0);
5830
5831   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
5832   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
5833   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
5834   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
5835   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
5836   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
5837   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
5838
5839   /* yn (1, x) == y1 (x)  */
5840   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
5841   TEST_ff_f (yn, 1, 0.0, minus_infty);
5842   TEST_ff_f (yn, 1, plus_infty, 0);
5843   TEST_ff_f (yn, 1, nan_value, nan_value);
5844
5845   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
5846   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
5847   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
5848   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
5849   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
5850   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
5851   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
5852
5853   /* yn (3, x)  */
5854   TEST_ff_f (yn, 3, plus_infty, 0);
5855   TEST_ff_f (yn, 3, nan_value, nan_value);
5856
5857   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
5858   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
5859   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
5860   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
5861   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
5862
5863   /* yn (10, x)  */
5864   TEST_ff_f (yn, 10, plus_infty, 0);
5865   TEST_ff_f (yn, 10, nan_value, nan_value);
5866
5867   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
5868   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
5869   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
5870   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
5871   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
5872
5873   END (yn);
5874
5875 }
5876
5877
5878 static void
5879 significand_test (void)
5880 {
5881   /* significand returns the mantissa of the exponential representation.  */
5882   START (significand);
5883
5884   TEST_f_f (significand, 4.0, 1.0);
5885   TEST_f_f (significand, 6.0, 1.5);
5886   TEST_f_f (significand, 8.0, 1.0);
5887
5888   END (significand);
5889 }
5890
5891
5892 static void
5893 initialize (void)
5894 {
5895   fpstack_test ("start *init*");
5896   plus_zero = 0.0;
5897   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
5898
5899   minus_zero = FUNC(copysign) (0.0, -1.0);
5900   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
5901                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
5902   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
5903                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
5904   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
5905                       LDBL_MAX, DBL_MAX, FLT_MAX);
5906   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
5907                       LDBL_MIN, DBL_MIN, FLT_MIN);
5908
5909   (void) &plus_zero;
5910   (void) &nan_value;
5911   (void) &minus_zero;
5912   (void) &plus_infty;
5913   (void) &minus_infty;
5914   (void) &max_value;
5915   (void) &min_value;
5916
5917   /* Clear all exceptions.  From now on we must not get random exceptions.  */
5918   feclearexcept (FE_ALL_EXCEPT);
5919
5920   /* Test to make sure we start correctly.  */
5921   fpstack_test ("end *init*");
5922 }
5923
5924 /* Definitions of arguments for argp functions.  */
5925 static const struct argp_option options[] =
5926 {
5927   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
5928   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
5929   { "no-max-error", 'f', NULL, 0,
5930     "Don't output maximal errors of functions"},
5931   { "no-points", 'p', NULL, 0,
5932     "Don't output results of functions invocations"},
5933   { "ignore-max-ulp", 'i', "yes/no", 0,
5934     "Ignore given maximal errors"},
5935   { NULL, 0, NULL, 0, NULL }
5936 };
5937
5938 /* Short description of program.  */
5939 static const char doc[] = "Math test suite: " TEST_MSG ;
5940
5941 /* Prototype for option handler.  */
5942 static error_t parse_opt (int key, char *arg, struct argp_state *state);
5943
5944 /* Data structure to communicate with argp functions.  */
5945 static struct argp argp =
5946 {
5947   options, parse_opt, NULL, doc,
5948 };
5949
5950
5951 /* Handle program arguments.  */
5952 static error_t
5953 parse_opt (int key, char *arg, struct argp_state *state)
5954 {
5955   switch (key)
5956     {
5957     case 'f':
5958       output_max_error = 0;
5959       break;
5960     case 'i':
5961       if (strcmp (arg, "yes") == 0)
5962         ignore_max_ulp = 1;
5963       else if (strcmp (arg, "no") == 0)
5964         ignore_max_ulp = 0;
5965       break;
5966     case 'p':
5967       output_points = 0;
5968       break;
5969     case 'u':
5970       output_ulps = 1;
5971       break;
5972     case 'v':
5973       if (optarg)
5974         verbose = (unsigned int) strtoul (optarg, NULL, 0);
5975       else
5976         verbose = 3;
5977       break;
5978     default:
5979       return ARGP_ERR_UNKNOWN;
5980     }
5981   return 0;
5982 }
5983
5984 #if 0
5985 /* function to check our ulp calculation.  */
5986 void
5987 check_ulp (void)
5988 {
5989   int i;
5990
5991   FLOAT u, diff, ulp;
5992   /* This gives one ulp.  */
5993   u = FUNC(nextafter) (10, 20);
5994   check_equal (10.0, u, 1, &diff, &ulp);
5995   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
5996
5997   /* This gives one more ulp.  */
5998   u = FUNC(nextafter) (u, 20);
5999   check_equal (10.0, u, 2, &diff, &ulp);
6000   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
6001
6002   /* And now calculate 100 ulp.  */
6003   for (i = 2; i < 100; i++)
6004     u = FUNC(nextafter) (u, 20);
6005   check_equal (10.0, u, 100, &diff, &ulp);
6006   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
6007 }
6008 #endif
6009
6010 int
6011 main (int argc, char **argv)
6012 {
6013
6014   int remaining;
6015
6016   verbose = 1;
6017   output_ulps = 0;
6018   output_max_error = 1;
6019   output_points = 1;
6020   /* XXX set to 0 for releases.  */
6021   ignore_max_ulp = 0;
6022
6023   /* Parse and process arguments.  */
6024   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
6025
6026   if (remaining != argc)
6027     {
6028       fprintf (stderr, "wrong number of arguments");
6029       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
6030       exit (EXIT_FAILURE);
6031     }
6032
6033   if (output_ulps)
6034     {
6035       ulps_file = fopen ("ULPs", "a");
6036       if (ulps_file == NULL)
6037         {
6038           perror ("can't open file `ULPs' for writing: ");
6039           exit (1);
6040         }
6041     }
6042
6043
6044   initialize ();
6045   printf (TEST_MSG);
6046
6047 #if 0
6048   check_ulp ();
6049 #endif
6050
6051   /* Keep the tests a wee bit ordered (according to ISO C99).  */
6052   /* Classification macros:  */
6053   fpclassify_test ();
6054   isfinite_test ();
6055   isnormal_test ();
6056   signbit_test ();
6057
6058   /* Trigonometric functions:  */
6059   acos_test ();
6060   asin_test ();
6061   atan_test ();
6062   atan2_test ();
6063   cos_test ();
6064   sin_test ();
6065   sincos_test ();
6066   tan_test ();
6067
6068   /* Hyperbolic functions:  */
6069   acosh_test ();
6070   asinh_test ();
6071   atanh_test ();
6072   cosh_test ();
6073   sinh_test ();
6074   tanh_test ();
6075
6076   /* Exponential and logarithmic functions:  */
6077   exp_test ();
6078   exp10_test ();
6079   exp2_test ();
6080   expm1_test ();
6081   frexp_test ();
6082   ldexp_test ();
6083   log_test ();
6084   log10_test ();
6085   log1p_test ();
6086   log2_test ();
6087   logb_test ();
6088   modf_test ();
6089   ilogb_test ();
6090   scalb_test ();
6091   scalbn_test ();
6092   scalbln_test ();
6093   significand_test ();
6094
6095   /* Power and absolute value functions:  */
6096   cbrt_test ();
6097   fabs_test ();
6098   hypot_test ();
6099   pow_test ();
6100   sqrt_test ();
6101
6102   /* Error and gamma functions:  */
6103   erf_test ();
6104   erfc_test ();
6105   gamma_test ();
6106   lgamma_test ();
6107   tgamma_test ();
6108
6109   /* Nearest integer functions:  */
6110   ceil_test ();
6111   floor_test ();
6112   nearbyint_test ();
6113   rint_test ();
6114   rint_test_tonearest ();
6115   rint_test_towardzero ();
6116   rint_test_downward ();
6117   rint_test_upward ();
6118   lrint_test ();
6119   lrint_test_tonearest ();
6120   lrint_test_towardzero ();
6121   lrint_test_downward ();
6122   lrint_test_upward ();
6123   llrint_test ();
6124   llrint_test_tonearest ();
6125   llrint_test_towardzero ();
6126   llrint_test_downward ();
6127   llrint_test_upward ();
6128   round_test ();
6129   lround_test ();
6130   llround_test ();
6131   trunc_test ();
6132
6133   /* Remainder functions:  */
6134   fmod_test ();
6135   remainder_test ();
6136   remquo_test ();
6137
6138   /* Manipulation functions:  */
6139   copysign_test ();
6140   nextafter_test ();
6141   nexttoward_test ();
6142
6143   /* maximum, minimum and positive difference functions */
6144   fdim_test ();
6145   fmax_test ();
6146   fmin_test ();
6147
6148   /* Multiply and add:  */
6149   fma_test ();
6150
6151   /* Complex functions:  */
6152   cabs_test ();
6153   cacos_test ();
6154   cacosh_test ();
6155   carg_test ();
6156   casin_test ();
6157   casinh_test ();
6158   catan_test ();
6159   catanh_test ();
6160   ccos_test ();
6161   ccosh_test ();
6162   cexp_test ();
6163   cimag_test ();
6164   clog10_test ();
6165   clog_test ();
6166   conj_test ();
6167   cpow_test ();
6168   cproj_test ();
6169   creal_test ();
6170   csin_test ();
6171   csinh_test ();
6172   csqrt_test ();
6173   ctan_test ();
6174   ctanh_test ();
6175
6176   /* Bessel functions:  */
6177   j0_test ();
6178   j1_test ();
6179   jn_test ();
6180   y0_test ();
6181   y1_test ();
6182   yn_test ();
6183
6184   if (output_ulps)
6185     fclose (ulps_file);
6186
6187   printf ("\nTest suite completed:\n");
6188   printf ("  %d test cases plus %d tests for exception flags executed.\n",
6189           noTests, noExcTests);
6190   if (noXFails)
6191     printf ("  %d expected failures occurred.\n", noXFails);
6192   if (noXPasses)
6193     printf ("  %d unexpected passes occurred.\n", noXPasses);
6194   if (noErrors)
6195     {
6196       printf ("  %d errors occurred.\n", noErrors);
6197       return 1;
6198     }
6199   printf ("  All tests passed successfully.\n");
6200
6201   return 0;
6202 }
6203
6204 /*
6205  * Local Variables:
6206  * mode:c
6207  * End:
6208  */