math/libm-test.inc

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