math/libm-test.inc

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