math/libm-test.inc

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