math/libm-test.inc

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