test/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 <getopt.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 #if 0
1000 static void
1001 cacos_test (void)
1002 {
1003   errno = 0;
1004   FUNC(cacos) (BUILD_COMPLEX (0.7L, 1.2L));
1005   if (errno == ENOSYS)
1006     /* Function not implemented.  */
1007     return;
1008
1009   START (cacos);
1010
1011
1012   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
1013   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
1014   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
1015   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
1016
1017   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
1018   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
1019
1020   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
1021   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
1022
1023   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
1024   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
1025   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
1026   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
1027   TEST_c_c (cacos, 0.1L, plus_infty, M_PI_2l, minus_infty);
1028   TEST_c_c (cacos, 0.1L, minus_infty, M_PI_2l, plus_infty);
1029
1030   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
1031   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
1032   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
1033   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
1034
1035   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
1036   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
1037   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
1038   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
1039
1040   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1041   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1042
1043   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
1044   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
1045
1046   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
1047   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
1048
1049   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1050   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1051
1052   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1053   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1054
1055   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
1056
1057   TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L);
1058   TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L);
1059
1060   END (cacos, complex);
1061 }
1062
1063 static void
1064 cacosh_test (void)
1065 {
1066   errno = 0;
1067   FUNC(cacosh) (BUILD_COMPLEX (0.7L, 1.2L));
1068   if (errno == ENOSYS)
1069     /* Function not implemented.  */
1070     return;
1071
1072   START (cacosh);
1073
1074
1075   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
1076   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
1077   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
1078   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
1079   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
1080   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1081
1082   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1083   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1084
1085   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1086   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1087   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1088   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1089   TEST_c_c (cacosh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1090   TEST_c_c (cacosh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1091
1092   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1093   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1094   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1095   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1096
1097   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1098   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1099   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1100   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1101
1102   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1103   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1104
1105   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1106   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1107
1108   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1109   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1110
1111   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1112   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1113
1114   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1115   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1116
1117   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1118
1119   TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L);
1120   TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L);
1121
1122   END (cacosh, complex);
1123 }
1124
1125
1126 static void
1127 carg_test (void)
1128 {
1129   START (carg);
1130
1131   /* carg (x + iy) is specified as atan2 (y, x) */
1132
1133   /* carg (x + i 0) == 0 for x > 0.  */
1134   TEST_c_f (carg, 2.0, 0, 0);
1135   /* carg (x - i 0) == -0 for x > 0.  */
1136   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1137
1138   TEST_c_f (carg, 0, 0, 0);
1139   TEST_c_f (carg, 0, minus_zero, minus_zero);
1140
1141   /* carg (x + i 0) == +pi for x < 0.  */
1142   TEST_c_f (carg, -2.0, 0, M_PIl);
1143
1144   /* carg (x - i 0) == -pi for x < 0.  */
1145   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1146
1147   TEST_c_f (carg, minus_zero, 0, M_PIl);
1148   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1149
1150   /* carg (+0 + i y) == pi/2 for y > 0.  */
1151   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1152
1153   /* carg (-0 + i y) == pi/2 for y > 0.  */
1154   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1155
1156   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1157   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1158
1159   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1160   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1161
1162   /* carg (inf + i y) == +0 for finite y > 0.  */
1163   TEST_c_f (carg, plus_infty, 2.0, 0);
1164
1165   /* carg (inf + i y) == -0 for finite y < 0.  */
1166   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1167
1168   /* carg(x + i inf) == pi/2 for finite x.  */
1169   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1170
1171   /* carg(x - i inf) == -pi/2 for finite x.  */
1172   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1173
1174   /* carg (-inf + i y) == +pi for finite y > 0.  */
1175   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1176
1177   /* carg (-inf + i y) == -pi for finite y < 0.  */
1178   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1179
1180   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1181
1182   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1183
1184   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1185
1186   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1187
1188   TEST_c_f (carg, nan_value, nan_value, nan_value);
1189
1190   END (carg);
1191 }
1192
1193 static void
1194 casin_test (void)
1195 {
1196   errno = 0;
1197   FUNC(casin) (BUILD_COMPLEX (0.7L, 1.2L));
1198   if (errno == ENOSYS)
1199     /* Function not implemented.  */
1200     return;
1201
1202   START (casin);
1203
1204   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1205   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1206   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1207   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1208
1209   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1210   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1211   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1212   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1213
1214   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1215   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1216   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1217   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1218   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1219   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1220   TEST_c_c (casin, 0.1L, plus_infty, 0.0, plus_infty);
1221   TEST_c_c (casin, 0.1L, minus_infty, 0.0, minus_infty);
1222
1223   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1224   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1225   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1226   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1227
1228   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1229   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1230   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1231   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1232
1233   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1234   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1235
1236   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1237   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1238
1239   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1240   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1241
1242   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1243   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1244
1245   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1246   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1247
1248   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1249
1250   TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L);
1251   TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L);
1252
1253   END (casin, complex);
1254 }
1255
1256
1257 static void
1258 casinh_test (void)
1259 {
1260   errno = 0;
1261   FUNC(casinh) (BUILD_COMPLEX (0.7L, 1.2L));
1262   if (errno == ENOSYS)
1263     /* Function not implemented.  */
1264     return;
1265
1266   START (casinh);
1267
1268   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1269   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1270   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1271   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1272
1273   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1274   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1275   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1276   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1277
1278   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1279   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1280   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1281   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1282   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1283   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1284   TEST_c_c (casinh, 0.1L, plus_infty, plus_infty, M_PI_2l);
1285   TEST_c_c (casinh, 0.1L, minus_infty, plus_infty, -M_PI_2l);
1286
1287   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1288   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1289   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1290   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1291
1292   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1293   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1294   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1295   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1296
1297   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1298   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1299
1300   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1301   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1302
1303   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1304   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1305
1306   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1307   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1308
1309   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1310   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1311
1312   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1313
1314   TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L);
1315   TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L);
1316
1317   END (casinh, complex);
1318 }
1319
1320
1321 static void
1322 catan_test (void)
1323 {
1324   errno = 0;
1325   FUNC(catan) (BUILD_COMPLEX (0.7L, 1.2L));
1326   if (errno == ENOSYS)
1327     /* Function not implemented.  */
1328     return;
1329
1330   START (catan);
1331
1332   TEST_c_c (catan, 0, 0, 0, 0);
1333   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1334   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1335   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1336
1337   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1338   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1339   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1340   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1341
1342
1343   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1344   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1345   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1346   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1347   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1348   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1349   TEST_c_c (catan, plus_infty, 0.1L, M_PI_2l, 0);
1350   TEST_c_c (catan, minus_infty, 0.1L, -M_PI_2l, 0);
1351
1352   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1353   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1354   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1355   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1356
1357   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1358   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1359   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1360   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1361
1362   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1363   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1364
1365   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1366   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1367
1368   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1369   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1370
1371   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1372   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1373
1374   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1375   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1376
1377   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1378   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1379
1380   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1381
1382   TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L);
1383   TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L);
1384
1385   END (catan, complex);
1386 }
1387
1388 static void
1389 catanh_test (void)
1390 {
1391   errno = 0;
1392   FUNC(catanh) (BUILD_COMPLEX (0.7L, 1.2L));
1393   if (errno == ENOSYS)
1394     /* Function not implemented.  */
1395     return;
1396
1397   START (catanh);
1398
1399   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1400   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1401   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1402   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1403
1404   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1405   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1406   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1407   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1408
1409   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1410   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1411   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1412   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1413   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1414   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1415   TEST_c_c (catanh, 0.1L, plus_infty, 0.0, M_PI_2l);
1416   TEST_c_c (catanh, 0.1L, minus_infty, 0.0, -M_PI_2l);
1417
1418   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1419   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1420   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1421   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1422
1423   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1424   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1425   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1426   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1427
1428   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1429   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1430
1431   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1432   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1433
1434   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1435   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1436
1437   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1438   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1439
1440   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1441   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1442
1443   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1444   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1445
1446   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1447
1448   TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L);
1449   TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L);
1450
1451   END (catanh, complex);
1452 }
1453 #endif
1454
1455 static void
1456 cbrt_test (void)
1457 {
1458   errno = 0;
1459   FUNC(cbrt) (8);
1460   if (errno == ENOSYS)
1461     /* Function not implemented.  */
1462     return;
1463
1464   START (cbrt);
1465
1466   TEST_f_f (cbrt, 0.0, 0.0);
1467   TEST_f_f (cbrt, minus_zero, minus_zero);
1468
1469   TEST_f_f (cbrt, plus_infty, plus_infty);
1470   TEST_f_f (cbrt, minus_infty, minus_infty);
1471   TEST_f_f (cbrt, nan_value, nan_value);
1472
1473   TEST_f_f (cbrt, -0.001L, -0.1L);
1474   TEST_f_f (cbrt, 8, 2);
1475   TEST_f_f (cbrt, -27.0, -3.0);
1476   TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L);
1477   TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L);
1478
1479   END (cbrt);
1480 }
1481
1482
1483 #if 0
1484 static void
1485 ccos_test (void)
1486 {
1487   errno = 0;
1488   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1489   if (errno == ENOSYS)
1490     /* Function not implemented.  */
1491     return;
1492
1493   START (ccos);
1494
1495   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1496   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1497   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1498   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1499
1500   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1501   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1502   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1503   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1504
1505   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1506   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1507   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1508   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1509
1510   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1511   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1512   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1513   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1514
1515   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1516   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1517   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1518   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1519
1520   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1521   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1522   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1523   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1524
1525   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1526   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1527
1528   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1529   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1530
1531   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1532   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1533
1534   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1535   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1536
1537   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1538   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1539
1540   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1541   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1542
1543   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1544
1545   TEST_c_c (ccos, 0.75L, 1.25L, 1.38173873063425888530729933139078645L, -1.09193013555397466170919531722024128L);
1546   TEST_c_c (ccos, -2, -3, -4.18962569096880723013255501961597373L, -9.10922789375533659797919726277886212L);
1547
1548   END (ccos, complex);
1549 }
1550
1551
1552 static void
1553 ccosh_test (void)
1554 {
1555   errno = 0;
1556   FUNC(ccosh) (BUILD_COMPLEX (0.7L, 1.2L));
1557   if (errno == ENOSYS)
1558     /* Function not implemented.  */
1559     return;
1560
1561   START (ccosh);
1562
1563   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1564   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1565   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1566   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1567
1568   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1569   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1570   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1571   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1572
1573   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1574   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1575   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1576   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1577
1578   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1579   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1580   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1581   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1582
1583   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1584   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1585   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1586   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1587
1588   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1589   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1590   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1591   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1592
1593   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1594   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1595
1596   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1597   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1598
1599   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1600   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1601
1602   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1603   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1604
1605   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1606   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1607
1608   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1609   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1610
1611   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1612
1613   TEST_c_c (ccosh, 0.75L, 1.25L, 0.408242591877968807788852146397499084L, 0.780365930845853240391326216300863152L);
1614
1615   TEST_c_c (ccosh, -2, -3, -3.72454550491532256547397070325597253L, 0.511822569987384608834463849801875634L);
1616
1617   END (ccosh, complex);
1618 }
1619 #endif
1620
1621
1622 static void
1623 ceil_test (void)
1624 {
1625   START (ceil);
1626
1627   TEST_f_f (ceil, 0.0, 0.0);
1628   TEST_f_f (ceil, minus_zero, minus_zero);
1629   TEST_f_f (ceil, plus_infty, plus_infty);
1630   TEST_f_f (ceil, minus_infty, minus_infty);
1631   TEST_f_f (ceil, nan_value, nan_value);
1632
1633   TEST_f_f (ceil, M_PIl, 4.0);
1634   TEST_f_f (ceil, -M_PIl, -3.0);
1635   TEST_f_f (ceil, 0.25, 1.0);
1636   TEST_f_f (ceil, -0.25, minus_zero);
1637
1638 #ifdef TEST_LDOUBLE
1639   /* The result can only be represented in long double.  */
1640   TEST_f_f (ceil, 4503599627370495.5L, 4503599627370496.0L);
1641   TEST_f_f (ceil, 4503599627370496.25L, 4503599627370497.0L);
1642   TEST_f_f (ceil, 4503599627370496.5L, 4503599627370497.0L);
1643   TEST_f_f (ceil, 4503599627370496.75L, 4503599627370497.0L);
1644   TEST_f_f (ceil, 4503599627370497.5L, 4503599627370498.0L);
1645
1646   TEST_f_f (ceil, -4503599627370495.5L, -4503599627370495.0L);
1647   TEST_f_f (ceil, -4503599627370496.25L, -4503599627370496.0L);
1648   TEST_f_f (ceil, -4503599627370496.5L, -4503599627370496.0L);
1649   TEST_f_f (ceil, -4503599627370496.75L, -4503599627370496.0L);
1650   TEST_f_f (ceil, -4503599627370497.5L, -4503599627370497.0L);
1651
1652   TEST_f_f (ceil, 9007199254740991.5L, 9007199254740992.0L);
1653   TEST_f_f (ceil, 9007199254740992.25L, 9007199254740993.0L);
1654   TEST_f_f (ceil, 9007199254740992.5L, 9007199254740993.0L);
1655   TEST_f_f (ceil, 9007199254740992.75L, 9007199254740993.0L);
1656   TEST_f_f (ceil, 9007199254740993.5L, 9007199254740994.0L);
1657
1658   TEST_f_f (ceil, -9007199254740991.5L, -9007199254740991.0L);
1659   TEST_f_f (ceil, -9007199254740992.25L, -9007199254740992.0L);
1660   TEST_f_f (ceil, -9007199254740992.5L, -9007199254740992.0L);
1661   TEST_f_f (ceil, -9007199254740992.75L, -9007199254740992.0L);
1662   TEST_f_f (ceil, -9007199254740993.5L, -9007199254740993.0L);
1663
1664   TEST_f_f (ceil, 72057594037927935.5L, 72057594037927936.0L);
1665   TEST_f_f (ceil, 72057594037927936.25L, 72057594037927937.0L);
1666   TEST_f_f (ceil, 72057594037927936.5L, 72057594037927937.0L);
1667   TEST_f_f (ceil, 72057594037927936.75L, 72057594037927937.0L);
1668   TEST_f_f (ceil, 72057594037927937.5L, 72057594037927938.0L);
1669
1670   TEST_f_f (ceil, -72057594037927935.5L, -72057594037927935.0L);
1671   TEST_f_f (ceil, -72057594037927936.25L, -72057594037927936.0L);
1672   TEST_f_f (ceil, -72057594037927936.5L, -72057594037927936.0L);
1673   TEST_f_f (ceil, -72057594037927936.75L, -72057594037927936.0L);
1674   TEST_f_f (ceil, -72057594037927937.5L, -72057594037927937.0L);
1675
1676   TEST_f_f (ceil, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
1677   TEST_f_f (ceil, 10141204801825835211973625643008.25L, 10141204801825835211973625643009.0L);
1678   TEST_f_f (ceil, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
1679   TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
1680   TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
1681 #endif
1682
1683   END (ceil);
1684 }
1685
1686
1687 #if 0
1688 static void
1689 cexp_test (void)
1690 {
1691   errno = 0;
1692   FUNC(cexp) (BUILD_COMPLEX (0, 0));
1693   if (errno == ENOSYS)
1694     /* Function not implemented.  */
1695     return;
1696
1697   START (cexp);
1698
1699   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1700   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1701   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1702   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1703
1704   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1705   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1706
1707   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1708   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1709
1710   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1711   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1712
1713   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1714   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1715
1716   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1717   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1718
1719   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1720   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1721
1722   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1723   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1724   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1725   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1726
1727   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1728   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1729
1730   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1731   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1732
1733   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1734
1735   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1736
1737   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1738   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1739
1740   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1741   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1742   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1743   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1744
1745   TEST_c_c (cexp, 0.75L, 1.25L, 0.667537446429131586942201977015932112L, 2.00900045494094876258347228145863909L);
1746   TEST_c_c (cexp, -2.0, -3.0, -0.13398091492954261346140525546115575L, -0.019098516261135196432576240858800925L);
1747
1748   END (cexp, complex);
1749 }
1750
1751
1752 static void
1753 cimag_test (void)
1754 {
1755   START (cimag);
1756   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1757   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1758   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1759   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1760   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1761   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1762   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1763
1764   END (cimag);
1765 }
1766
1767 static void
1768 clog_test (void)
1769 {
1770   errno = 0;
1771   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1772   if (errno == ENOSYS)
1773     /* Function not implemented.  */
1774     return;
1775
1776   START (clog);
1777
1778   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1779   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1780
1781   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1782   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1783
1784   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1785   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1786
1787   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1788   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1789
1790   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1791   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1792   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1793   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1794   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1795   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1796   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1797   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1798
1799   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1800   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1801   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1802   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1803
1804   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1805   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1806   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1807   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1808
1809   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1810   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1811
1812   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1813   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1814
1815   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1816   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1817   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1818   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1819
1820   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1821   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1822   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1823   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1824
1825   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1826
1827   TEST_c_c (clog, 0.75L, 1.25L, 0.376885901188190075998919126749298416L, 1.03037682652431246378774332703115153L);
1828   TEST_c_c (clog, -2, -3, 1.2824746787307683680267437207826593L, -2.1587989303424641704769327722648368L);
1829
1830   END (clog, complex);
1831 }
1832
1833
1834 static void
1835 clog10_test (void)
1836 {
1837   errno = 0;
1838   FUNC(clog10) (BUILD_COMPLEX (0.7L, 1.2L));
1839   if (errno == ENOSYS)
1840     /* Function not implemented.  */
1841     return;
1842
1843   START (clog10);
1844
1845   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1846   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1847
1848   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1849   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1850
1851   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1852
1853   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1854   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1855
1856   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1857   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1858   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1859   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1860   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1861   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1862   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1863   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1864
1865   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1866   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1867   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1868   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1869
1870   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1871   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1872   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1873   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1874
1875   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1876   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1877
1878   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1879   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1880
1881   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1882   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1883   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1884   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1885
1886   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1887   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1888   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1889   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1890
1891   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1892
1893   TEST_c_c (clog10, 0.75L, 1.25L, 0.163679467193165171449476605077428975L, 0.447486970040493067069984724340855636L);
1894   TEST_c_c (clog10, -2, -3, 0.556971676153418384603252578971164214L, -0.937554462986374708541507952140189646L);
1895
1896   END (clog10, complex);
1897 }
1898 #endif
1899
1900
1901 #if 0
1902 static void
1903 conj_test (void)
1904 {
1905   START (conj);
1906   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1907   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1908   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1909   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1910   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1911   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1912   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1913
1914   END (conj, complex);
1915 }
1916 #endif
1917
1918
1919 static void
1920 copysign_test (void)
1921 {
1922   START (copysign);
1923
1924   TEST_ff_f (copysign, 0, 4, 0);
1925   TEST_ff_f (copysign, 0, -4, minus_zero);
1926   TEST_ff_f (copysign, minus_zero, 4, 0);
1927   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1928
1929   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1930   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1931   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1932   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1933
1934   TEST_ff_f (copysign, 0, plus_infty, 0);
1935   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1936   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1937   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1938
1939   /* XXX More correctly we would have to check the sign of the NaN.  */
1940   TEST_ff_f (copysign, nan_value, 0, nan_value);
1941   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1942   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1943   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1944
1945   END (copysign);
1946 }
1947
1948
1949 static void
1950 cos_test (void)
1951 {
1952   errno = 0;
1953   FUNC(cos) (0);
1954   if (errno == ENOSYS)
1955     /* Function not implemented.  */
1956     return;
1957
1958   START (cos);
1959
1960   TEST_f_f (cos, 0, 1);
1961   TEST_f_f (cos, minus_zero, 1);
1962   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1963   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1964   TEST_f_f (cos, nan_value, nan_value);
1965
1966   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1967   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1968   TEST_f_f (cos, M_PI_2l, 0);
1969
1970   TEST_f_f (cos, 0.75L, 0.731688868873820886311838753000084544L);
1971
1972 #ifdef TEST_DOUBLE
1973   TEST_f_f (cos, 0.80190127184058835, 0.69534156199418473);
1974 #endif
1975
1976   END (cos);
1977 }
1978
1979
1980 static void
1981 cosh_test (void)
1982 {
1983   errno = 0;
1984   FUNC(cosh) (0.7L);
1985   if (errno == ENOSYS)
1986     /* Function not implemented.  */
1987     return;
1988
1989   START (cosh);
1990   TEST_f_f (cosh, 0, 1);
1991   TEST_f_f (cosh, minus_zero, 1);
1992
1993 #ifndef TEST_INLINE
1994   TEST_f_f (cosh, plus_infty, plus_infty);
1995   TEST_f_f (cosh, minus_infty, plus_infty);
1996 #endif
1997   TEST_f_f (cosh, nan_value, nan_value);
1998
1999   TEST_f_f (cosh, 0.75L, 1.29468328467684468784170818539018176L);
2000
2001   END (cosh);
2002 }
2003
2004
2005 #if 0
2006 static void
2007 cpow_test (void)
2008 {
2009   errno = 0;
2010   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
2011   if (errno == ENOSYS)
2012     /* Function not implemented.  */
2013     return;
2014
2015   START (cpow);
2016
2017   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
2018   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
2019
2020   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
2021   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
2022
2023   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
2024
2025   TEST_cc_c (cpow, 0.75L, 1.25L, 0.75L, 1.25L, 0.117506293914473555420279832210420483L, 0.346552747708338676483025352060418001L);
2026   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L);
2027   TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L);
2028   TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L);
2029
2030   END (cpow, complex);
2031 }
2032
2033
2034 static void
2035 cproj_test (void)
2036 {
2037   START (cproj);
2038   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
2039   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
2040   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
2041   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
2042
2043   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
2044
2045   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
2046   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
2047   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
2048   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
2049
2050   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
2051   TEST_c_c (cproj, 2.0, 3.0, 0.2857142857142857142857142857142857L, 0.42857142857142857142857142857142855L);
2052
2053   END (cproj, complex);
2054 }
2055
2056
2057 static void
2058 creal_test (void)
2059 {
2060   START (creal);
2061   TEST_c_f (creal, 0.0, 1.0, 0.0);
2062   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
2063   TEST_c_f (creal, nan_value, 1.0, nan_value);
2064   TEST_c_f (creal, nan_value, nan_value, nan_value);
2065   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
2066   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
2067   TEST_c_f (creal, 2.0, 3.0, 2.0);
2068
2069   END (creal);
2070 }
2071
2072 static void
2073 csin_test (void)
2074 {
2075   errno = 0;
2076   FUNC(csin) (BUILD_COMPLEX (0.7L, 1.2L));
2077   if (errno == ENOSYS)
2078     /* Function not implemented.  */
2079     return;
2080
2081   START (csin);
2082
2083   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
2084   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
2085   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
2086   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
2087
2088   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
2089   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
2090   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
2091   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
2092
2093   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2094   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2095   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2096   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2097
2098   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2099   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2100   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2101   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2102
2103   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2104   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2105   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2106   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2107
2108   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2109   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2110   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2111   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2112
2113   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2114   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2115
2116   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2117   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2118
2119   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2120   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2121
2122   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2123   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2124
2125   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2126   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2127
2128   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2129   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2130
2131   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2132
2133   TEST_c_c (csin, 0.75L, 1.25L, 1.28722291002649188575873510790565441L, 1.17210635989270256101081285116138863L);
2134   TEST_c_c (csin, -2, -3, -9.15449914691142957346729954460983256L, 4.16890695996656435075481305885375484L);
2135
2136   END (csin, complex);
2137 }
2138
2139
2140 static void
2141 csinh_test (void)
2142 {
2143   errno = 0;
2144   FUNC(csinh) (BUILD_COMPLEX (0.7L, 1.2L));
2145   if (errno == ENOSYS)
2146     /* Function not implemented.  */
2147     return;
2148
2149   START (csinh);
2150
2151   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2152   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2153   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2154   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2155
2156   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2157   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2158   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2159   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2160
2161   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2162   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2163   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2164   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2165
2166   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2167   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2168   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2169   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2170
2171   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2172   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2173   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2174   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2175
2176   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2177   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2178   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2179   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2180
2181   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2182   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2183
2184   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2185   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2186
2187   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2188   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2189
2190   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2191   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2192
2193   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2194   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2195
2196   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2197   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2198
2199   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2200
2201   TEST_c_c (csinh, 0.75L, 1.25L, 0.259294854551162779153349830618433028L, 1.22863452409509552219214606515777594L);
2202   TEST_c_c (csinh, -2, -3, 3.59056458998577995201256544779481679L, -0.530921086248519805267040090660676560L);
2203
2204   END (csinh, complex);
2205 }
2206
2207
2208 static void
2209 csqrt_test (void)
2210 {
2211   errno = 0;
2212   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2213   if (errno == ENOSYS)
2214     /* Function not implemented.  */
2215     return;
2216
2217   START (csqrt);
2218
2219   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2220   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2221   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2222   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2223
2224   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2225   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2226   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2227   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2228
2229   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2230   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2231   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2232   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2233
2234   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2235   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2236   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2237   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2238   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2239   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2240   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2241   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2242   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2243   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2244   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2245   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2246
2247   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2248
2249   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2250
2251   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2252   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2253   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2254   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2255
2256   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2257   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2258   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2259   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2260
2261   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2262
2263   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2264   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2265   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2266   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2267   TEST_c_c (csqrt, 0.75L, 1.25L, 1.05065169626078392338656675760808326L, 0.594868882070379067881984030639932657L);
2268   TEST_c_c (csqrt, -2, -3, 0.89597747612983812471573375529004348L, -1.6741492280355400404480393008490519L);
2269   TEST_c_c (csqrt, -2, 3, 0.89597747612983812471573375529004348L, 1.6741492280355400404480393008490519L);
2270   /* Principal square root should be returned (i.e., non-negative real
2271      part).  */
2272   TEST_c_c (csqrt, 0, -1, M_SQRT_2_2, -M_SQRT_2_2);
2273
2274   END (csqrt, complex);
2275 }
2276
2277 static void
2278 ctan_test (void)
2279 {
2280   errno = 0;
2281   FUNC(ctan) (BUILD_COMPLEX (0.7L, 1.2L));
2282   if (errno == ENOSYS)
2283     /* Function not implemented.  */
2284     return;
2285
2286   START (ctan);
2287
2288   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2289   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2290   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2291   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2292
2293   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2294   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2295   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2296   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2297
2298   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2299   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2300   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2301   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2302
2303   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2304   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2305   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2306   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2307   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2308   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2309   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2310   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2311
2312   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2313   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2314
2315   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2316   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2317
2318   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2319   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2320
2321   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2322   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2323   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2324   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2325
2326   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2327
2328   TEST_c_c (ctan, 0.75L, 1.25L, 0.160807785916206426725166058173438663L, 0.975363285031235646193581759755216379L);
2329   TEST_c_c (ctan, -2, -3, 0.376402564150424829275122113032269084e-2L, -1.00323862735360980144635859782192726L);
2330
2331   END (ctan, complex);
2332 }
2333
2334
2335 static void
2336 ctanh_test (void)
2337 {
2338   errno = 0;
2339   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2340   if (errno == ENOSYS)
2341     /* Function not implemented.  */
2342     return;
2343
2344   START (ctanh);
2345
2346   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2347   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2348   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2349   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2350
2351   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2352   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2353   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2354   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2355   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2356   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2357   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2358   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2359
2360   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2361   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2362   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2363   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2364   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2365   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2366   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2367   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2368
2369   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2370   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2371
2372   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2373   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2374
2375   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2376   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2377
2378   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2379   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2380   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2381   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2382
2383   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2384
2385   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2386
2387   TEST_c_c (ctanh, 0.75L, 1.25L, 1.37260757053378320258048606571226857L, 0.385795952609750664177596760720790220L);
2388   TEST_c_c (ctanh, -2, -3, -0.965385879022133124278480269394560686L, 0.988437503832249372031403430350121098e-2L);
2389
2390   END (ctanh, complex);
2391 }
2392 #endif
2393
2394
2395 static void
2396 erf_test (void)
2397 {
2398   errno = 0;
2399   FUNC(erf) (0);
2400   if (errno == ENOSYS)
2401     /* Function not implemented.  */
2402     return;
2403
2404   START (erf);
2405
2406   TEST_f_f (erf, 0, 0);
2407   TEST_f_f (erf, minus_zero, minus_zero);
2408   TEST_f_f (erf, plus_infty, 1);
2409   TEST_f_f (erf, minus_infty, -1);
2410   TEST_f_f (erf, nan_value, nan_value);
2411
2412   TEST_f_f (erf, 0.125L, 0.140316204801333817393029446521623398L);
2413   TEST_f_f (erf, 0.75L, 0.711155633653515131598937834591410777L);
2414   TEST_f_f (erf, 1.25L, 0.922900128256458230136523481197281140L);
2415   TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L);
2416   TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L);
2417   TEST_f_f (erf, 27.0L, 1.0L);
2418
2419   END (erf);
2420 }
2421
2422
2423 static void
2424 erfc_test (void)
2425 {
2426   errno = 0;
2427   FUNC(erfc) (0);
2428   if (errno == ENOSYS)
2429     /* Function not implemented.  */
2430     return;
2431
2432   START (erfc);
2433
2434   TEST_f_f (erfc, plus_infty, 0.0);
2435   TEST_f_f (erfc, minus_infty, 2.0);
2436   TEST_f_f (erfc, 0.0, 1.0);
2437   TEST_f_f (erfc, minus_zero, 1.0);
2438   TEST_f_f (erfc, nan_value, nan_value);
2439
2440   TEST_f_f (erfc, 0.125L, 0.859683795198666182606970553478376602L);
2441   TEST_f_f (erfc, 0.75L, 0.288844366346484868401062165408589223L);
2442   TEST_f_f (erfc, 1.25L, 0.0770998717435417698634765188027188596L);
2443   TEST_f_f (erfc, 2.0L, 0.00467773498104726583793074363274707139L);
2444   TEST_f_f (erfc, 4.125L, 0.542340079956506600531223408575531062e-8L);
2445 #ifdef TEST_LDOUBLE
2446   /* The result can only be represented in long double.  */
2447 # if LDBL_MIN_10_EXP < -319
2448   TEST_f_f (erfc, 27.0L, 0.523704892378925568501606768284954709e-318L);
2449 # endif
2450 #endif
2451
2452   END (erfc);
2453 }
2454
2455
2456 static void
2457 exp_test (void)
2458 {
2459   errno = 0;
2460   FUNC(exp) (0);
2461   if (errno == ENOSYS)
2462     /* Function not implemented.  */
2463     return;
2464
2465   START (exp);
2466
2467   TEST_f_f (exp, 0, 1);
2468   TEST_f_f (exp, minus_zero, 1);
2469
2470 #ifndef TEST_INLINE
2471   TEST_f_f (exp, plus_infty, plus_infty);
2472   TEST_f_f (exp, minus_infty, 0);
2473 #endif
2474   TEST_f_f (exp, nan_value, nan_value);
2475   TEST_f_f (exp, 1, M_El);
2476
2477   TEST_f_f (exp, 2, M_E2l);
2478   TEST_f_f (exp, 3, M_E3l);
2479   TEST_f_f (exp, 0.75L, 2.11700001661267466854536981983709561L);
2480   TEST_f_f (exp, 50.0L, 5184705528587072464087.45332293348538L);
2481 #ifdef TEST_LDOUBLE
2482   /* The result can only be represented in long double.  */
2483   TEST_f_f (exp, 1000.0L, 0.197007111401704699388887935224332313e435L);
2484 #endif
2485
2486   END (exp);
2487 }
2488
2489
2490 #if 0
2491 static void
2492 exp10_test (void)
2493 {
2494   errno = 0;
2495   FUNC(exp10) (0);
2496   if (errno == ENOSYS)
2497     /* Function not implemented.  */
2498     return;
2499
2500   START (exp10);
2501
2502   TEST_f_f (exp10, 0, 1);
2503   TEST_f_f (exp10, minus_zero, 1);
2504
2505   TEST_f_f (exp10, plus_infty, plus_infty);
2506   TEST_f_f (exp10, minus_infty, 0);
2507   TEST_f_f (exp10, nan_value, nan_value);
2508   TEST_f_f (exp10, 3, 1000);
2509   TEST_f_f (exp10, -1, 0.1L);
2510   TEST_f_f (exp10, 1e6, plus_infty);
2511   TEST_f_f (exp10, -1e6, 0);
2512   TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L);
2513
2514   END (exp10);
2515 }
2516
2517
2518 static void
2519 exp2_test (void)
2520 {
2521   errno = 0;
2522   FUNC(exp2) (0);
2523   if (errno == ENOSYS)
2524     /* Function not implemented.  */
2525     return;
2526
2527   START (exp2);
2528
2529   TEST_f_f (exp2, 0, 1);
2530   TEST_f_f (exp2, minus_zero, 1);
2531   TEST_f_f (exp2, plus_infty, plus_infty);
2532   TEST_f_f (exp2, minus_infty, 0);
2533   TEST_f_f (exp2, nan_value, nan_value);
2534
2535   TEST_f_f (exp2, 10, 1024);
2536   TEST_f_f (exp2, -1, 0.5);
2537   TEST_f_f (exp2, 1e6, plus_infty);
2538   TEST_f_f (exp2, -1e6, 0);
2539   TEST_f_f (exp2, 0.75L, 1.68179283050742908606225095246642979L);
2540
2541   END (exp2);
2542 }
2543 #endif
2544
2545
2546 static void
2547 expm1_test (void)
2548 {
2549   errno = 0;
2550   FUNC(expm1) (0);
2551   if (errno == ENOSYS)
2552     /* Function not implemented.  */
2553     return;
2554
2555   START (expm1);
2556
2557   TEST_f_f (expm1, 0, 0);
2558   TEST_f_f (expm1, minus_zero, minus_zero);
2559
2560 #ifndef TEST_INLINE
2561   TEST_f_f (expm1, plus_infty, plus_infty);
2562   TEST_f_f (expm1, minus_infty, -1);
2563 #endif
2564   TEST_f_f (expm1, nan_value, nan_value);
2565
2566   TEST_f_f (expm1, 1, M_El - 1.0);
2567   TEST_f_f (expm1, 0.75L, 1.11700001661267466854536981983709561L);
2568
2569   END (expm1);
2570 }
2571
2572
2573 static void
2574 fabs_test (void)
2575 {
2576   START (fabs);
2577
2578   TEST_f_f (fabs, 0, 0);
2579   TEST_f_f (fabs, minus_zero, 0);
2580
2581   TEST_f_f (fabs, plus_infty, plus_infty);
2582   TEST_f_f (fabs, minus_infty, plus_infty);
2583   TEST_f_f (fabs, nan_value, nan_value);
2584
2585   TEST_f_f (fabs, 38.0, 38.0);
2586   TEST_f_f (fabs, -M_El, M_El);
2587
2588   END (fabs);
2589 }
2590
2591
2592 #if 0
2593 static void
2594 fdim_test (void)
2595 {
2596   START (fdim);
2597
2598   TEST_ff_f (fdim, 0, 0, 0);
2599   TEST_ff_f (fdim, 9, 0, 9);
2600   TEST_ff_f (fdim, 0, 9, 0);
2601   TEST_ff_f (fdim, -9, 0, 0);
2602   TEST_ff_f (fdim, 0, -9, 9);
2603
2604   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2605   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2606   TEST_ff_f (fdim, minus_infty, 9, 0);
2607   TEST_ff_f (fdim, minus_infty, -9, 0);
2608   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2609   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2610   TEST_ff_f (fdim, 9, plus_infty, 0);
2611   TEST_ff_f (fdim, -9, plus_infty, 0);
2612
2613   TEST_ff_f (fdim, 0, nan_value, nan_value);
2614   TEST_ff_f (fdim, 9, nan_value, nan_value);
2615   TEST_ff_f (fdim, -9, nan_value, nan_value);
2616   TEST_ff_f (fdim, nan_value, 9, nan_value);
2617   TEST_ff_f (fdim, nan_value, -9, nan_value);
2618   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2619   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2620   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2621   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2622   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2623
2624   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
2625
2626   END (fdim);
2627 }
2628 #endif
2629
2630
2631 static void
2632 floor_test (void)
2633 {
2634   START (floor);
2635
2636   TEST_f_f (floor, 0.0, 0.0);
2637   TEST_f_f (floor, minus_zero, minus_zero);
2638   TEST_f_f (floor, plus_infty, plus_infty);
2639   TEST_f_f (floor, minus_infty, minus_infty);
2640   TEST_f_f (floor, nan_value, nan_value);
2641
2642   TEST_f_f (floor, M_PIl, 3.0);
2643   TEST_f_f (floor, -M_PIl, -4.0);
2644
2645   TEST_f_f (floor, 0.25, 0.0);
2646   TEST_f_f (floor, -0.25, -1.0);
2647
2648
2649 #ifdef TEST_LDOUBLE
2650   /* The result can only be represented in long double.  */
2651   TEST_f_f (floor, 4503599627370495.5L, 4503599627370495.0L);
2652   TEST_f_f (floor, 4503599627370496.25L, 4503599627370496.0L);
2653   TEST_f_f (floor, 4503599627370496.5L, 4503599627370496.0L);
2654   TEST_f_f (floor, 4503599627370496.75L, 4503599627370496.0L);
2655   TEST_f_f (floor, 4503599627370497.5L, 4503599627370497.0L);
2656
2657   TEST_f_f (floor, -4503599627370495.5L, -4503599627370496.0L);
2658   TEST_f_f (floor, -4503599627370496.25L, -4503599627370497.0L);
2659   TEST_f_f (floor, -4503599627370496.5L, -4503599627370497.0L);
2660   TEST_f_f (floor, -4503599627370496.75L, -4503599627370497.0L);
2661   TEST_f_f (floor, -4503599627370497.5L, -4503599627370498.0L);
2662
2663   TEST_f_f (floor, 9007199254740991.5L, 9007199254740991.0L);
2664   TEST_f_f (floor, 9007199254740992.25L, 9007199254740992.0L);
2665   TEST_f_f (floor, 9007199254740992.5L, 9007199254740992.0L);
2666   TEST_f_f (floor, 9007199254740992.75L, 9007199254740992.0L);
2667   TEST_f_f (floor, 9007199254740993.5L, 9007199254740993.0L);
2668
2669   TEST_f_f (floor, -9007199254740991.5L, -9007199254740992.0L);
2670   TEST_f_f (floor, -9007199254740992.25L, -9007199254740993.0L);
2671   TEST_f_f (floor, -9007199254740992.5L, -9007199254740993.0L);
2672   TEST_f_f (floor, -9007199254740992.75L, -9007199254740993.0L);
2673   TEST_f_f (floor, -9007199254740993.5L, -9007199254740994.0L);
2674
2675   TEST_f_f (floor, 72057594037927935.5L, 72057594037927935.0L);
2676   TEST_f_f (floor, 72057594037927936.25L, 72057594037927936.0L);
2677   TEST_f_f (floor, 72057594037927936.5L, 72057594037927936.0L);
2678   TEST_f_f (floor, 72057594037927936.75L, 72057594037927936.0L);
2679   TEST_f_f (floor, 72057594037927937.5L, 72057594037927937.0L);
2680
2681   TEST_f_f (floor, -72057594037927935.5L, -72057594037927936.0L);
2682   TEST_f_f (floor, -72057594037927936.25L, -72057594037927937.0L);
2683   TEST_f_f (floor, -72057594037927936.5L, -72057594037927937.0L);
2684   TEST_f_f (floor, -72057594037927936.75L, -72057594037927937.0L);
2685   TEST_f_f (floor, -72057594037927937.5L, -72057594037927938.0L);
2686
2687   TEST_f_f (floor, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
2688   TEST_f_f (floor, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
2689   TEST_f_f (floor, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
2690   TEST_f_f (floor, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
2691   TEST_f_f (floor, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
2692 #endif
2693
2694   END (floor);
2695 }
2696
2697
2698 #if 0
2699 static void
2700 fma_test (void)
2701 {
2702   START (fma);
2703
2704   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2705   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2706   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2707   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2708   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2709   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2710   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2711   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2712   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2713   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2714   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2715   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2716
2717   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2718   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2719   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2720   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2721
2722   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
2723
2724   END (fma);
2725 }
2726
2727
2728 static void
2729 fmax_test (void)
2730 {
2731   START (fmax);
2732
2733   TEST_ff_f (fmax, 0, 0, 0);
2734   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2735   TEST_ff_f (fmax, 9, 0, 9);
2736   TEST_ff_f (fmax, 0, 9, 9);
2737   TEST_ff_f (fmax, -9, 0, 0);
2738   TEST_ff_f (fmax, 0, -9, 0);
2739
2740   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2741   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2742   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2743   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2744
2745   TEST_ff_f (fmax, minus_infty, 9, 9);
2746   TEST_ff_f (fmax, minus_infty, -9, -9);
2747   TEST_ff_f (fmax, 9, minus_infty, 9);
2748   TEST_ff_f (fmax, -9, minus_infty, -9);
2749
2750   TEST_ff_f (fmax, 0, nan_value, 0);
2751   TEST_ff_f (fmax, 9, nan_value, 9);
2752   TEST_ff_f (fmax, -9, nan_value, -9);
2753   TEST_ff_f (fmax, nan_value, 0, 0);
2754   TEST_ff_f (fmax, nan_value, 9, 9);
2755   TEST_ff_f (fmax, nan_value, -9, -9);
2756   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2757   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2758   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2759   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2760   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2761
2762   END (fmax);
2763 }
2764
2765
2766 static void
2767 fmin_test (void)
2768 {
2769   START (fmin);
2770
2771   TEST_ff_f (fmin, 0, 0, 0);
2772   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2773   TEST_ff_f (fmin, 9, 0, 0);
2774   TEST_ff_f (fmin, 0, 9, 0);
2775   TEST_ff_f (fmin, -9, 0, -9);
2776   TEST_ff_f (fmin, 0, -9, -9);
2777
2778   TEST_ff_f (fmin, plus_infty, 9, 9);
2779   TEST_ff_f (fmin, 9, plus_infty, 9);
2780   TEST_ff_f (fmin, plus_infty, -9, -9);
2781   TEST_ff_f (fmin, -9, plus_infty, -9);
2782   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2783   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2784   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2785   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2786
2787   TEST_ff_f (fmin, 0, nan_value, 0);
2788   TEST_ff_f (fmin, 9, nan_value, 9);
2789   TEST_ff_f (fmin, -9, nan_value, -9);
2790   TEST_ff_f (fmin, nan_value, 0, 0);
2791   TEST_ff_f (fmin, nan_value, 9, 9);
2792   TEST_ff_f (fmin, nan_value, -9, -9);
2793   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2794   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2795   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2796   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2797   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2798
2799   END (fmin);
2800 }
2801 #endif
2802
2803
2804 static void
2805 fmod_test (void)
2806 {
2807   errno = 0;
2808   FUNC(fmod) (6.5, 2.3L);
2809   if (errno == ENOSYS)
2810     /* Function not implemented.  */
2811     return;
2812
2813   START (fmod);
2814
2815   /* fmod (+0, y) == +0 for y != 0.  */
2816   TEST_ff_f (fmod, 0, 3, 0);
2817
2818   /* fmod (-0, y) == -0 for y != 0.  */
2819   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2820
2821   /* fmod (+inf, y) == NaN plus invalid exception.  */
2822   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2823   /* fmod (-inf, y) == NaN plus invalid exception.  */
2824   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2825   /* fmod (x, +0) == NaN plus invalid exception.  */
2826   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2827   /* fmod (x, -0) == NaN plus invalid exception.  */
2828   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2829
2830   /* fmod (x, +inf) == x for x not infinite.  */
2831   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2832   /* fmod (x, -inf) == x for x not infinite.  */
2833   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2834
2835   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2836
2837   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
2838   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
2839   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
2840   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
2841
2842   END (fmod);
2843 }
2844
2845
2846 static void
2847 fpclassify_test (void)
2848 {
2849   START (fpclassify);
2850
2851   TEST_f_i (fpclassify, nan_value, FP_NAN);
2852   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2853   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2854   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2855   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2856   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2857
2858   END (fpclassify);
2859 }
2860
2861
2862 static void
2863 frexp_test (void)
2864 {
2865   int x;
2866
2867   START (frexp);
2868
2869   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2870   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2871   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2872
2873   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2874   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2875
2876   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
2877   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
2878
2879   END (frexp);
2880 }
2881
2882
2883 static void
2884 gamma_test (void)
2885 {
2886   errno = 0;
2887   FUNC(gamma) (1);
2888
2889   if (errno == ENOSYS)
2890     /* Function not implemented.  */
2891     return;
2892   feclearexcept (FE_ALL_EXCEPT);
2893
2894   START (gamma);
2895
2896   TEST_f_f (gamma, plus_infty, plus_infty);
2897   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2898   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2899   TEST_f_f (gamma, minus_infty, plus_infty);
2900   TEST_f_f (gamma, nan_value, nan_value);
2901
2902   TEST_f_f1 (gamma, 1, 0, 1);
2903   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2904
2905   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2906   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2907
2908   END (gamma);
2909 }
2910
2911 static void
2912 hypot_test (void)
2913 {
2914   errno = 0;
2915   FUNC(hypot) (0.7L, 12.4L);
2916   if (errno == ENOSYS)
2917     /* Function not implemented.  */
2918     return;
2919
2920   START (hypot);
2921
2922   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2923   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2924
2925 #ifndef TEST_INLINE
2926   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2927   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2928   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2929   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2930 #endif
2931
2932   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2933
2934   /* hypot (x,y) == hypot (+-x, +-y)  */
2935   TEST_ff_f (hypot, 0.7L, 12.4L, 12.419742348374220601176836866763271L);
2936   TEST_ff_f (hypot, -0.7L, 12.4L, 12.419742348374220601176836866763271L);
2937   TEST_ff_f (hypot, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
2938   TEST_ff_f (hypot, -0.7L, -12.4L, 12.419742348374220601176836866763271L);
2939   TEST_ff_f (hypot, 12.4L, 0.7L, 12.419742348374220601176836866763271L);
2940   TEST_ff_f (hypot, -12.4L, 0.7L, 12.419742348374220601176836866763271L);
2941   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
2942   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
2943
2944   /*  hypot (x,0) == fabs (x)  */
2945   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
2946   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
2947   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
2948
2949   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
2950
2951   END (hypot);
2952 }
2953
2954
2955 static void
2956 ilogb_test (void)
2957 {
2958   START (ilogb);
2959
2960   TEST_f_i (ilogb, 1, 0);
2961   TEST_f_i (ilogb, M_El, 1);
2962   TEST_f_i (ilogb, 1024, 10);
2963   TEST_f_i (ilogb, -2000, 10);
2964
2965   /* XXX We have a problem here: the standard does not tell us whether
2966      exceptions are allowed/required.  ignore them for now.  */
2967
2968   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2969   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2970   TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
2971   TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
2972
2973   END (ilogb);
2974 }
2975
2976 static void
2977 isfinite_test (void)
2978 {
2979   START (isfinite);
2980
2981   TEST_f_b (isfinite, 0, 1);
2982   TEST_f_b (isfinite, minus_zero, 1);
2983   TEST_f_b (isfinite, 10, 1);
2984   TEST_f_b (isfinite, plus_infty, 0);
2985   TEST_f_b (isfinite, minus_infty, 0);
2986   TEST_f_b (isfinite, nan_value, 0);
2987
2988   END (isfinite);
2989 }
2990
2991 static void
2992 isnormal_test (void)
2993 {
2994   START (isnormal);
2995
2996   TEST_f_b (isnormal, 0, 0);
2997   TEST_f_b (isnormal, minus_zero, 0);
2998   TEST_f_b (isnormal, 10, 1);
2999   TEST_f_b (isnormal, plus_infty, 0);
3000   TEST_f_b (isnormal, minus_infty, 0);
3001   TEST_f_b (isnormal, nan_value, 0);
3002
3003   END (isnormal);
3004 }
3005
3006 static void
3007 j0_test (void)
3008 {
3009   errno = 0;
3010 #if 0
3011   FLOAT s, c;
3012   FUNC (sincos) (0, &s, &c);
3013   if (errno == ENOSYS)
3014     /* Required function not implemented.  */
3015     return;
3016 #endif
3017   FUNC(j0) (0);
3018   if (errno == ENOSYS)
3019     /* Function not implemented.  */
3020     return;
3021
3022   START (j0);
3023
3024   /* j0 is the Bessel function of the first kind of order 0 */
3025   TEST_f_f (j0, nan_value, nan_value);
3026   TEST_f_f (j0, plus_infty, 0);
3027   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3028   TEST_f_f (j0, 0.0, 1.0);
3029   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3030   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3031   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3032   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3033   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3034   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3035   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3036   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3037   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3038
3039   END (j0);
3040 }
3041
3042
3043 static void
3044 j1_test (void)
3045 {
3046   errno = 0;
3047 #if 0
3048   FLOAT s, c;
3049   FUNC (sincos) (0, &s, &c);
3050   if (errno == ENOSYS)
3051     /* Required function not implemented.  */
3052     return;
3053 #endif
3054   FUNC(j1) (0);
3055   if (errno == ENOSYS)
3056     /* Function not implemented.  */
3057     return;
3058
3059   /* j1 is the Bessel function of the first kind of order 1 */
3060
3061   START (j1);
3062
3063   TEST_f_f (j1, nan_value, nan_value);
3064   TEST_f_f (j1, plus_infty, 0);
3065
3066   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3067   TEST_f_f (j1, 0.0, 0.0);
3068   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3069   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3070   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3071   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3072   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3073   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3074   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3075
3076   END (j1);
3077 }
3078
3079 static void
3080 jn_test (void)
3081 {
3082   errno = 0;
3083 #if 0
3084   FLOAT s, c;
3085   FUNC (sincos) (0, &s, &c);
3086   if (errno == ENOSYS)
3087     /* Required function not implemented.  */
3088     return;
3089 #endif
3090   FUNC(jn) (1, 1);
3091   if (errno == ENOSYS)
3092     /* Function not implemented.  */
3093     return;
3094
3095   /* jn is the Bessel function of the first kind of order n.  */
3096   START (jn);
3097
3098   /* jn (0, x) == j0 (x)  */
3099   TEST_ff_f (jn, 0, nan_value, nan_value);
3100   TEST_ff_f (jn, 0, plus_infty, 0);
3101   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3102   TEST_ff_f (jn, 0, 0.0, 1.0);
3103   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3104   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3105   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3106   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3107   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3108   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3109   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3110   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3111   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3112
3113   /* jn (1, x) == j1 (x)  */
3114   TEST_ff_f (jn, 1, nan_value, nan_value);
3115   TEST_ff_f (jn, 1, plus_infty, 0);
3116   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3117   TEST_ff_f (jn, 1, 0.0, 0.0);
3118   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3119   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3120   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3121   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3122   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3123   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3124   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3125
3126   /* jn (3, x)  */
3127   TEST_ff_f (jn, 3, nan_value, nan_value);
3128   TEST_ff_f (jn, 3, plus_infty, 0);
3129
3130   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3131   TEST_ff_f (jn, 3, 0.0, 0.0);
3132   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3133   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3134   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3135   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3136   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3137
3138   /*  jn (10, x)  */
3139   TEST_ff_f (jn, 10, nan_value, nan_value);
3140   TEST_ff_f (jn, 10, plus_infty, 0);
3141
3142   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3143   TEST_ff_f (jn, 10, 0.0, 0.0);
3144   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3145   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3146   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3147   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3148   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3149
3150   END (jn);
3151 }
3152
3153
3154 static void
3155 ldexp_test (void)
3156 {
3157   TEST_ff_f (ldexp, 0, 0, 0);
3158   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3159
3160   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3161   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3162   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3163
3164   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3165   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3166
3167   /* ldexp (x, 0) == x.  */
3168   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3169 }
3170
3171
3172 static void
3173 lgamma_test (void)
3174 {
3175   errno = 0;
3176   FUNC(lgamma) (0);
3177   if (errno == ENOSYS)
3178     /* Function not implemented.  */
3179     return;
3180   feclearexcept (FE_ALL_EXCEPT);
3181
3182   START (lgamma);
3183
3184   TEST_f_f (lgamma, plus_infty, plus_infty);
3185   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3186   TEST_f_f (lgamma, nan_value, nan_value);
3187
3188   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3189   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3190   TEST_f_f (lgamma, minus_infty, plus_infty);
3191
3192   TEST_f_f1 (lgamma, 1, 0, 1);
3193
3194   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3195
3196   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3197   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3198   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3199   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3200
3201   END (lgamma);
3202 }
3203
3204
3205 #if 0
3206 static void
3207 lrint_test (void)
3208 {
3209   /* XXX this test is incomplete.  We need to have a way to specifiy
3210      the rounding method and test the critical cases.  So far, only
3211      unproblematic numbers are tested.  */
3212
3213   START (lrint);
3214
3215   TEST_f_l (lrint, 0.0, 0);
3216   TEST_f_l (lrint, minus_zero, 0);
3217   TEST_f_l (lrint, 0.2L, 0);
3218   TEST_f_l (lrint, -0.2L, 0);
3219
3220   TEST_f_l (lrint, 1.4L, 1);
3221   TEST_f_l (lrint, -1.4L, -1);
3222
3223   TEST_f_l (lrint, 8388600.3L, 8388600);
3224   TEST_f_l (lrint, -8388600.3L, -8388600);
3225
3226   TEST_f_l (lrint, 1071930.0008, 1071930);
3227 #ifndef TEST_FLOAT
3228   TEST_f_l (lrint, 1073741824.01, 1073741824);
3229 # if LONG_MAX > 281474976710656
3230   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3231 # endif
3232 #endif
3233
3234   END (lrint);
3235 }
3236
3237
3238 static void
3239 llrint_test (void)
3240 {
3241   /* XXX this test is incomplete.  We need to have a way to specifiy
3242      the rounding method and test the critical cases.  So far, only
3243      unproblematic numbers are tested.  */
3244
3245   START (llrint);
3246
3247   TEST_f_L (llrint, 0.0, 0);
3248   TEST_f_L (llrint, minus_zero, 0);
3249   TEST_f_L (llrint, 0.2L, 0);
3250   TEST_f_L (llrint, -0.2L, 0);
3251
3252   TEST_f_L (llrint, 1.4L, 1);
3253   TEST_f_L (llrint, -1.4L, -1);
3254
3255   TEST_f_L (llrint, 8388600.3L, 8388600);
3256   TEST_f_L (llrint, -8388600.3L, -8388600);
3257
3258   TEST_f_l (llrint, 1071930.0008, 1071930);
3259
3260   /* Test boundary conditions.  */
3261   /* 0x1FFFFF */
3262   TEST_f_L (llrint, 2097151.0,2097151LL);
3263   /* 0x800000 */
3264   TEST_f_L (llrint, 8388608.0, 8388608LL);
3265   /* 0x1000000 */
3266   TEST_f_L (llrint, 16777216.0, 16777216LL);
3267   /* 0x20000000000 */
3268   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3269   /* 0x40000000000 */
3270   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3271   /* 0x1000000000000 */
3272   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3273   /* 0x10000000000000 */
3274   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3275   /* 0x10000080000000 */
3276   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3277   /* 0x20000000000000 */
3278   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3279   /* 0x80000000000000 */
3280   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3281   /* 0x100000000000000 */
3282   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3283 #ifdef TEST_LDOUBLE
3284   /* The input can only be represented in long double.  */
3285   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3286   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3287   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3288   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3289   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3290
3291   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3292   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3293   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3294   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3295   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3296
3297   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3298   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3299   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3300   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3301   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3302
3303   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3304   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3305   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3306   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3307   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3308
3309   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3310   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3311   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3312   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3313   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3314
3315   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3316   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3317   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3318   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3319   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3320 #endif
3321
3322   END (llrint);
3323 }
3324 #endif
3325
3326
3327 static void
3328 log_test (void)
3329 {
3330   errno = 0;
3331   FUNC(log) (1);
3332   if (errno == ENOSYS)
3333     /* Function not implemented.  */
3334     return;
3335   START (log);
3336
3337   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3338   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3339
3340   TEST_f_f (log, 1, 0);
3341
3342   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3343   TEST_f_f (log, plus_infty, plus_infty);
3344
3345   TEST_f_f (log, M_El, 1);
3346   TEST_f_f (log, 1.0 / M_El, -1);
3347   TEST_f_f (log, 2, M_LN2l);
3348   TEST_f_f (log, 10, M_LN10l);
3349   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
3350
3351   END (log);
3352 }
3353
3354
3355 static void
3356 log10_test (void)
3357 {
3358   errno = 0;
3359   FUNC(log10) (1);
3360   if (errno == ENOSYS)
3361     /* Function not implemented.  */
3362     return;
3363
3364   START (log10);
3365
3366   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3367   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3368
3369   TEST_f_f (log10, 1, 0);
3370
3371   /* log10 (x) == NaN plus invalid exception if x < 0.  */
3372   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3373
3374   TEST_f_f (log10, plus_infty, plus_infty);
3375   TEST_f_f (log10, nan_value, nan_value);
3376
3377   TEST_f_f (log10, 0.1L, -1);
3378   TEST_f_f (log10, 10.0, 1);
3379   TEST_f_f (log10, 100.0, 2);
3380   TEST_f_f (log10, 10000.0, 4);
3381   TEST_f_f (log10, M_El, M_LOG10El);
3382   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
3383
3384   END (log10);
3385 }
3386
3387
3388 static void
3389 log1p_test (void)
3390 {
3391   errno = 0;
3392   FUNC(log1p) (0);
3393   if (errno == ENOSYS)
3394     /* Function not implemented.  */
3395     return;
3396
3397   START (log1p);
3398
3399   TEST_f_f (log1p, 0, 0);
3400   TEST_f_f (log1p, minus_zero, minus_zero);
3401
3402   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3403   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3404
3405   TEST_f_f (log1p, plus_infty, plus_infty);
3406   TEST_f_f (log1p, nan_value, nan_value);
3407
3408   TEST_f_f (log1p, M_El - 1.0, 1);
3409
3410   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
3411   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
3412
3413   END (log1p);
3414 }
3415
3416
3417 #if 0
3418 static void
3419 log2_test (void)
3420 {
3421   errno = 0;
3422   FUNC(log2) (1);
3423   if (errno == ENOSYS)
3424     /* Function not implemented.  */
3425     return;
3426
3427   START (log2);
3428
3429   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3430   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3431
3432   TEST_f_f (log2, 1, 0);
3433
3434   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3435
3436   TEST_f_f (log2, plus_infty, plus_infty);
3437   TEST_f_f (log2, nan_value, nan_value);
3438
3439   TEST_f_f (log2, M_El, M_LOG2El);
3440   TEST_f_f (log2, 2.0, 1);
3441   TEST_f_f (log2, 16.0, 4);
3442   TEST_f_f (log2, 256.0, 8);
3443   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
3444
3445   END (log2);
3446 }
3447 #endif
3448
3449
3450 static void
3451 logb_test (void)
3452 {
3453   START (logb);
3454
3455   TEST_f_f (logb, plus_infty, plus_infty);
3456   TEST_f_f (logb, minus_infty, plus_infty);
3457
3458   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3459
3460   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3461   TEST_f_f (logb, nan_value, nan_value);
3462
3463   TEST_f_f (logb, 1, 0);
3464   TEST_f_f (logb, M_El, 1);
3465   TEST_f_f (logb, 1024, 10);
3466   TEST_f_f (logb, -2000, 10);
3467
3468   END (logb);
3469 }
3470
3471
3472 #if 0
3473 static void
3474 lround_test (void)
3475 {
3476   START (lround);
3477
3478   TEST_f_l (lround, 0, 0);
3479   TEST_f_l (lround, minus_zero, 0);
3480   TEST_f_l (lround, 0.2L, 0.0);
3481   TEST_f_l (lround, -0.2L, 0);
3482   TEST_f_l (lround, 0.5, 1);
3483   TEST_f_l (lround, -0.5, -1);
3484   TEST_f_l (lround, 0.8L, 1);
3485   TEST_f_l (lround, -0.8L, -1);
3486   TEST_f_l (lround, 1.5, 2);
3487   TEST_f_l (lround, -1.5, -2);
3488   TEST_f_l (lround, 22514.5, 22515);
3489   TEST_f_l (lround, -22514.5, -22515);
3490   TEST_f_l (lround, 1071930.0008, 1071930);
3491 #ifndef TEST_FLOAT
3492   TEST_f_l (lround, 1073741824.01, 1073741824);
3493 # if LONG_MAX > 281474976710656
3494   TEST_f_l (lround, 281474976710656.025, 281474976710656);
3495 # endif
3496   TEST_f_l (lround, 2097152.5, 2097153);
3497   TEST_f_l (lround, -2097152.5, -2097153);
3498 #endif
3499   END (lround);
3500 }
3501
3502
3503 static void
3504 llround_test (void)
3505 {
3506   START (llround);
3507
3508   TEST_f_L (llround, 0, 0);
3509   TEST_f_L (llround, minus_zero, 0);
3510   TEST_f_L (llround, 0.2L, 0.0);
3511   TEST_f_L (llround, -0.2L, 0);
3512   TEST_f_L (llround, 0.5, 1);
3513   TEST_f_L (llround, -0.5, -1);
3514   TEST_f_L (llround, 0.8L, 1);
3515   TEST_f_L (llround, -0.8L, -1);
3516   TEST_f_L (llround, 1.5, 2);
3517   TEST_f_L (llround, -1.5, -2);
3518   TEST_f_L (llround, 22514.5, 22515);
3519   TEST_f_L (llround, -22514.5, -22515);
3520   TEST_f_l (llround, 1071930.0008, 1071930);
3521 #ifndef TEST_FLOAT
3522   TEST_f_L (llround, 2097152.5, 2097153);
3523   TEST_f_L (llround, -2097152.5, -2097153);
3524   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3525   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3526 #endif
3527
3528   /* Test boundary conditions.  */
3529   /* 0x1FFFFF */
3530   TEST_f_L (llround, 2097151.0, 2097151LL);
3531   /* 0x800000 */
3532   TEST_f_L (llround, 8388608.0, 8388608LL);
3533   /* 0x1000000 */
3534   TEST_f_L (llround, 16777216.0, 16777216LL);
3535   /* 0x20000000000 */
3536   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3537   /* 0x40000000000 */
3538   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3539   /* 0x1000000000000 */
3540   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
3541   /* 0x10000000000000 */
3542   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3543   /* 0x10000080000000 */
3544   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
3545   /* 0x20000000000000 */
3546   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3547   /* 0x80000000000000 */
3548   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3549   /* 0x100000000000000 */
3550   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3551
3552 #ifndef TEST_FLOAT
3553   /* 0x100000000 */
3554   TEST_f_L (llround, 4294967295.5, 4294967296LL);
3555   /* 0x200000000 */
3556   TEST_f_L (llround, 8589934591.5, 8589934592LL);
3557 #endif
3558
3559 #ifdef TEST_LDOUBLE
3560   /* The input can only be represented in long double.  */
3561   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
3562   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
3563   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
3564   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
3565   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
3566
3567   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
3568   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
3569   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
3570   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
3571   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
3572
3573   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
3574   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
3575   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
3576   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
3577   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
3578
3579   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
3580   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
3581   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
3582   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
3583   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
3584
3585   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
3586   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
3587   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
3588   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
3589   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
3590
3591   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
3592   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
3593   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
3594   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
3595   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
3596
3597   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
3598   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
3599   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
3600   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
3601   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
3602   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
3603 #endif
3604
3605   END (llround);
3606 }
3607 #endif
3608
3609 static void
3610 modf_test (void)
3611 {
3612   FLOAT x;
3613
3614   START (modf);
3615
3616   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3617   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3618   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3619   TEST_fF_f1 (modf, 0, 0, 0);
3620   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3621   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3622   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3623   TEST_fF_f1 (modf, 20, 0, 20);
3624   TEST_fF_f1 (modf, 21, 0, 21);
3625   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3626
3627   END (modf);
3628 }
3629
3630
3631 #if 0
3632 static void
3633 nearbyint_test (void)
3634 {
3635   START (nearbyint);
3636
3637   TEST_f_f (nearbyint, 0.0, 0.0);
3638   TEST_f_f (nearbyint, minus_zero, minus_zero);
3639   TEST_f_f (nearbyint, plus_infty, plus_infty);
3640   TEST_f_f (nearbyint, minus_infty, minus_infty);
3641   TEST_f_f (nearbyint, nan_value, nan_value);
3642
3643   /* Default rounding mode is round to nearest.  */
3644   TEST_f_f (nearbyint, 0.5, 0.0);
3645   TEST_f_f (nearbyint, 1.5, 2.0);
3646   TEST_f_f (nearbyint, -0.5, minus_zero);
3647   TEST_f_f (nearbyint, -1.5, -2.0);
3648
3649   END (nearbyint);
3650 }
3651
3652 static void
3653 nextafter_test (void)
3654 {
3655
3656   START (nextafter);
3657
3658   TEST_ff_f (nextafter, 0, 0, 0);
3659   TEST_ff_f (nextafter, minus_zero, 0, 0);
3660   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3661   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3662
3663   TEST_ff_f (nextafter, 9, 9, 9);
3664   TEST_ff_f (nextafter, -9, -9, -9);
3665   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3666   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3667
3668   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
3669   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
3670   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3671
3672   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3673                          LDBL_MAX, DBL_MAX, FLT_MAX);
3674   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
3675   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
3676
3677 #ifdef TEST_LDOUBLE
3678   // XXX Enable once gcc is fixed.
3679   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
3680 #endif
3681
3682   /* XXX We need the hexadecimal FP number representation here for further
3683      tests.  */
3684
3685   END (nextafter);
3686 }
3687
3688
3689 static void
3690 nexttoward_test (void)
3691 {
3692   START (nexttoward);
3693   TEST_ff_f (nexttoward, 0, 0, 0);
3694   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3695   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3696   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3697
3698   TEST_ff_f (nexttoward, 9, 9, 9);
3699   TEST_ff_f (nexttoward, -9, -9, -9);
3700   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3701   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3702
3703   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
3704   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
3705   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3706
3707   /* XXX We need the hexadecimal FP number representation here for further
3708      tests.  */
3709
3710   END (nexttoward);
3711 }
3712 #endif
3713
3714
3715 static void
3716 pow_test (void)
3717 {
3718
3719   errno = 0;
3720   FUNC(pow) (0, 0);
3721   if (errno == ENOSYS)
3722     /* Function not implemented.  */
3723     return;
3724
3725   START (pow);
3726
3727   TEST_ff_f (pow, 0, 0, 1);
3728   TEST_ff_f (pow, 0, minus_zero, 1);
3729   TEST_ff_f (pow, minus_zero, 0, 1);
3730   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3731
3732   TEST_ff_f (pow, 10, 0, 1);
3733   TEST_ff_f (pow, 10, minus_zero, 1);
3734   TEST_ff_f (pow, -10, 0, 1);
3735   TEST_ff_f (pow, -10, minus_zero, 1);
3736
3737   TEST_ff_f (pow, nan_value, 0, 1);
3738   TEST_ff_f (pow, nan_value, minus_zero, 1);
3739
3740
3741 #ifndef TEST_INLINE
3742   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
3743   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3744   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
3745   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3746
3747   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3748   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3749   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3750   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3751
3752   TEST_ff_f (pow, 1.1L, minus_infty, 0);
3753   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3754   TEST_ff_f (pow, -1.1L, minus_infty, 0);
3755   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3756
3757   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3758   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3759   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3760   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3761
3762   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3763   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3764   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3765
3766   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3767   TEST_ff_f (pow, plus_infty, -1, 0);
3768   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3769
3770   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3771   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3772   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3773
3774   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3775   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3776   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3777   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
3778   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
3779   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
3780   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
3781
3782   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3783   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3784   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3785
3786   TEST_ff_f (pow, minus_infty, -2, 0);
3787   TEST_ff_f (pow, minus_infty, -12, 0);
3788   TEST_ff_f (pow, minus_infty, -1002, 0);
3789   TEST_ff_f (pow, minus_infty, -0.1L, 0);
3790   TEST_ff_f (pow, minus_infty, -1.1L, 0);
3791   TEST_ff_f (pow, minus_infty, -11.1L, 0);
3792   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
3793 #endif
3794
3795   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3796   TEST_ff_f (pow, 0, nan_value, nan_value);
3797   TEST_ff_f (pow, 1, nan_value, 1);
3798   TEST_ff_f (pow, -1, nan_value, nan_value);
3799   TEST_ff_f (pow, nan_value, 1, nan_value);
3800   TEST_ff_f (pow, nan_value, -1, nan_value);
3801
3802   /* pow (x, NaN) == NaN.  */
3803   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3804
3805   TEST_ff_f (pow, 1, plus_infty, 1);
3806   TEST_ff_f (pow, -1, plus_infty, 1);
3807   TEST_ff_f (pow, 1, minus_infty, 1);
3808   TEST_ff_f (pow, -1, minus_infty, 1);
3809   TEST_ff_f (pow, 1, 1, 1);
3810   TEST_ff_f (pow, 1, -1, 1);
3811   TEST_ff_f (pow, 1, 1.25, 1);
3812   TEST_ff_f (pow, 1, -1.25, 1);
3813   TEST_ff_f (pow, 1, 0x1p62L, 1);
3814   TEST_ff_f (pow, 1, 0x1p63L, 1);
3815   TEST_ff_f (pow, 1, 0x1p64L, 1);
3816   TEST_ff_f (pow, 1, 0x1p72L, 1);
3817
3818   /* pow (x, +-0) == 1.  */
3819   TEST_ff_f (pow, plus_infty, 0, 1);
3820   TEST_ff_f (pow, plus_infty, minus_zero, 1);
3821   TEST_ff_f (pow, minus_infty, 0, 1);
3822   TEST_ff_f (pow, minus_infty, minus_zero, 1);
3823   TEST_ff_f (pow, 32.75L, 0, 1);
3824   TEST_ff_f (pow, 32.75L, minus_zero, 1);
3825   TEST_ff_f (pow, -32.75L, 0, 1);
3826   TEST_ff_f (pow, -32.75L, minus_zero, 1);
3827   TEST_ff_f (pow, 0x1p72L, 0, 1);
3828   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
3829   TEST_ff_f (pow, 0x1p-72L, 0, 1);
3830   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
3831
3832   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3833   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3834   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3835   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3836
3837   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3838   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3839   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3840   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3841
3842   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3843   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3844   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3845   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3846
3847   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty);
3848   TEST_ff_f (pow, 10, -0x1p72L, 0);
3849   TEST_ff_f (pow, max_value, max_value, plus_infty);
3850   TEST_ff_f (pow, 10, -max_value, 0);
3851
3852   TEST_ff_f (pow, 0, 1, 0);
3853   TEST_ff_f (pow, 0, 11, 0);
3854
3855   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3856   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3857
3858
3859   TEST_ff_f (pow, 0, 2, 0);
3860   TEST_ff_f (pow, 0, 11.1L, 0);
3861
3862
3863   TEST_ff_f (pow, minus_zero, 2, 0);
3864   TEST_ff_f (pow, minus_zero, 11.1L, 0);
3865   TEST_ff_f (pow, 0, plus_infty, 0);
3866   TEST_ff_f (pow, minus_zero, plus_infty, 0);
3867
3868 #ifndef TEST_INLINE
3869   /* pow (x, +inf) == +inf for |x| > 1.  */
3870   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3871
3872   /* pow (x, +inf) == +0 for |x| < 1.  */
3873   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3874
3875   /* pow (x, -inf) == +0 for |x| > 1.  */
3876   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3877
3878   /* pow (x, -inf) == +inf for |x| < 1.  */
3879   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3880 #endif
3881
3882   /* pow (+inf, y) == +inf for y > 0.  */
3883   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3884
3885   /* pow (+inf, y) == +0 for y < 0.  */
3886   TEST_ff_f (pow, plus_infty, -1, 0.0);
3887
3888   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3889   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3890
3891   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3892   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3893
3894   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3895   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3896   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3897   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3898
3899   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3900   TEST_ff_f (pow, 0.0, 27, 0.0);
3901
3902   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3903   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3904
3905   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3906   TEST_ff_f (pow, 0.0, 4, 0.0);
3907
3908   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3909   TEST_ff_f (pow, minus_zero, 4, 0.0);
3910
3911   TEST_ff_f (pow, 16, 0.25L, 2);
3912   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
3913   TEST_ff_f (pow, 2, 4, 16);
3914   TEST_ff_f (pow, 256, 8, 0x1p64L);
3915
3916   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
3917
3918 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
3919   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3920 #endif
3921
3922   END (pow);
3923 }
3924
3925 static void
3926 remainder_test (void)
3927 {
3928   errno = 0;
3929   FUNC(remainder) (1.625, 1.0);
3930   if (errno == ENOSYS)
3931     /* Function not implemented.  */
3932     return;
3933
3934   START (remainder);
3935
3936   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3937   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3938   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3939   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3940   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3941
3942   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3943   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3944   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3945   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3946   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3947   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3948
3949   END (remainder);
3950 }
3951
3952 #if 0
3953 static void
3954 remquo_test (void)
3955 {
3956   /* x is needed.  */
3957   int x;
3958
3959   errno = 0;
3960   FUNC(remquo) (1.625, 1.0, &x);
3961   if (errno == ENOSYS)
3962     /* Function not implemented.  */
3963     return;
3964
3965   START (remquo);
3966
3967   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3968   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3969   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3970   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3971   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3972
3973   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3974   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3975   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3976   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3977
3978   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3979   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3980
3981   END (remquo);
3982 }
3983 #endif
3984
3985 static void
3986 rint_test (void)
3987 {
3988   START (rint);
3989
3990   TEST_f_f (rint, 0.0, 0.0);
3991   TEST_f_f (rint, minus_zero, minus_zero);
3992   TEST_f_f (rint, plus_infty, plus_infty);
3993   TEST_f_f (rint, minus_infty, minus_infty);
3994
3995   /* Default rounding mode is round to even.  */
3996   TEST_f_f (rint, 0.5, 0.0);
3997   TEST_f_f (rint, 1.5, 2.0);
3998   TEST_f_f (rint, 2.5, 2.0);
3999   TEST_f_f (rint, 3.5, 4.0);
4000   TEST_f_f (rint, 4.5, 4.0);
4001   TEST_f_f (rint, -0.5, -0.0);
4002   TEST_f_f (rint, -1.5, -2.0);
4003   TEST_f_f (rint, -2.5, -2.0);
4004   TEST_f_f (rint, -3.5, -4.0);
4005   TEST_f_f (rint, -4.5, -4.0);
4006 #ifdef TEST_LDOUBLE
4007   /* The result can only be represented in long double.  */
4008   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
4009   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
4010   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
4011   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
4012   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
4013
4014   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
4015   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
4016   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
4017   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
4018   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
4019
4020   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
4021   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
4022   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
4023   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
4024   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
4025
4026   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
4027   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
4028   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
4029   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
4030   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
4031
4032   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
4033   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
4034   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
4035   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
4036   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
4037
4038   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
4039   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
4040   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
4041   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
4042   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
4043
4044   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
4045   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4046   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4047   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
4048   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
4049 #endif
4050
4051   END (rint);
4052 }
4053
4054 #if 0
4055 static void
4056 rint_test_tonearest (void)
4057 {
4058   int save_round_mode;
4059   START (rint_tonearest);
4060
4061   save_round_mode = fegetround();
4062
4063   if (!fesetround (FE_TONEAREST))
4064   {
4065     TEST_f_f (rint, 2.0, 2.0);
4066     TEST_f_f (rint, 1.5, 2.0);
4067     TEST_f_f (rint, 1.0, 1.0);
4068     TEST_f_f (rint, 0.5, 0.0);
4069     TEST_f_f (rint, 0.0, 0.0);
4070     TEST_f_f (rint, minus_zero, minus_zero);
4071     TEST_f_f (rint, -0.5, -0.0);
4072     TEST_f_f (rint, -1.0, -1.0);
4073     TEST_f_f (rint, -1.5, -2.0);
4074     TEST_f_f (rint, -2.0, -2.0);
4075   }
4076
4077   fesetround(save_round_mode);
4078
4079   END (rint_tonearest);
4080 }
4081
4082 static void
4083 rint_test_towardzero (void)
4084 {
4085   int save_round_mode;
4086   START (rint_towardzero);
4087
4088   save_round_mode = fegetround();
4089
4090   if (!fesetround (FE_TOWARDZERO))
4091   {
4092     TEST_f_f (rint, 2.0, 2.0);
4093     TEST_f_f (rint, 1.5, 1.0);
4094     TEST_f_f (rint, 1.0, 1.0);
4095     TEST_f_f (rint, 0.5, 0.0);
4096     TEST_f_f (rint, 0.0, 0.0);
4097     TEST_f_f (rint, minus_zero, minus_zero);
4098     TEST_f_f (rint, -0.5, -0.0);
4099     TEST_f_f (rint, -1.0, -1.0);
4100     TEST_f_f (rint, -1.5, -1.0);
4101     TEST_f_f (rint, -2.0, -2.0);
4102   }
4103
4104   fesetround(save_round_mode);
4105
4106   END (rint_towardzero);
4107 }
4108
4109 static void
4110 rint_test_downward (void)
4111 {
4112   int save_round_mode;
4113   START (rint_downward);
4114
4115   save_round_mode = fegetround();
4116
4117   if (!fesetround (FE_DOWNWARD))
4118   {
4119     TEST_f_f (rint, 2.0, 2.0);
4120     TEST_f_f (rint, 1.5, 1.0);
4121     TEST_f_f (rint, 1.0, 1.0);
4122     TEST_f_f (rint, 0.5, 0.0);
4123     TEST_f_f (rint, 0.0, 0.0);
4124     TEST_f_f (rint, minus_zero, minus_zero);
4125     TEST_f_f (rint, -0.5, -1.0);
4126     TEST_f_f (rint, -1.0, -1.0);
4127     TEST_f_f (rint, -1.5, -2.0);
4128     TEST_f_f (rint, -2.0, -2.0);
4129   }
4130
4131   fesetround(save_round_mode);
4132
4133   END (rint_downward);
4134 }
4135
4136 static void
4137 rint_test_upward (void)
4138 {
4139   int save_round_mode;
4140   START (rint_upward);
4141
4142   save_round_mode = fegetround();
4143
4144   if (!fesetround (FE_UPWARD))
4145   {
4146     TEST_f_f (rint, 2.0, 2.0);
4147     TEST_f_f (rint, 1.5, 2.0);
4148     TEST_f_f (rint, 1.0, 1.0);
4149     TEST_f_f (rint, 0.5, 1.0);
4150     TEST_f_f (rint, 0.0, 0.0);
4151     TEST_f_f (rint, minus_zero, minus_zero);
4152     TEST_f_f (rint, -0.5, -0.0);
4153     TEST_f_f (rint, -1.0, -1.0);
4154     TEST_f_f (rint, -1.5, -1.0);
4155     TEST_f_f (rint, -2.0, -2.0);
4156   }
4157
4158   fesetround(save_round_mode);
4159
4160   END (rint_upward);
4161 }
4162
4163 static void
4164 round_test (void)
4165 {
4166   START (round);
4167
4168   TEST_f_f (round, 0, 0);
4169   TEST_f_f (round, minus_zero, minus_zero);
4170   TEST_f_f (round, 0.2L, 0.0);
4171   TEST_f_f (round, -0.2L, minus_zero);
4172   TEST_f_f (round, 0.5, 1.0);
4173   TEST_f_f (round, -0.5, -1.0);
4174   TEST_f_f (round, 0.8L, 1.0);
4175   TEST_f_f (round, -0.8L, -1.0);
4176   TEST_f_f (round, 1.5, 2.0);
4177   TEST_f_f (round, -1.5, -2.0);
4178   TEST_f_f (round, 2097152.5, 2097153);
4179   TEST_f_f (round, -2097152.5, -2097153);
4180
4181 #ifdef TEST_LDOUBLE
4182   /* The result can only be represented in long double.  */
4183   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
4184   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
4185   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
4186   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
4187   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
4188
4189   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
4190   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
4191   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
4192   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
4193   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
4194
4195   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
4196   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
4197   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
4198   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
4199   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
4200
4201   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
4202   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
4203   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
4204   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
4205   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
4206
4207   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
4208   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
4209   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
4210   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
4211   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
4212
4213   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
4214   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
4215   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
4216   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
4217   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
4218
4219   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
4220   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4221   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
4222   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
4223   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
4224 #endif
4225
4226   END (round);
4227 }
4228 #endif
4229
4230
4231 static void
4232 scalb_test (void)
4233 {
4234   START (scalb);
4235 #ifndef TEST_LDOUBLE /* uclibc doesn't have scalbl */
4236
4237   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
4238   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
4239
4240   TEST_ff_f (scalb, 0, nan_value, nan_value);
4241   TEST_ff_f (scalb, 1, nan_value, nan_value);
4242
4243   TEST_ff_f (scalb, 1, 0, 1);
4244   TEST_ff_f (scalb, -1, 0, -1);
4245
4246   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
4247   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
4248
4249   TEST_ff_f (scalb, 0, 2, 0);
4250   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
4251   TEST_ff_f (scalb, 0, 0, 0);
4252   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
4253   TEST_ff_f (scalb, 0, -1, 0);
4254   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
4255   TEST_ff_f (scalb, 0, minus_infty, 0);
4256   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
4257
4258   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
4259   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
4260   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
4261   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
4262   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
4263   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
4264
4265   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
4266   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
4267
4268   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
4269   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
4270   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
4271   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
4272
4273   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4274   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4275
4276   TEST_ff_f (scalb, nan_value, 1, nan_value);
4277   TEST_ff_f (scalb, 1, nan_value, nan_value);
4278   TEST_ff_f (scalb, nan_value, 0, nan_value);
4279   TEST_ff_f (scalb, 0, nan_value, nan_value);
4280   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
4281   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
4282   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
4283
4284   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
4285   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
4286 #endif
4287   END (scalb);
4288 }
4289
4290
4291 static void
4292 scalbn_test (void)
4293 {
4294
4295   START (scalbn);
4296
4297   TEST_fi_f (scalbn, 0, 0, 0);
4298   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
4299
4300   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
4301   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
4302   TEST_fi_f (scalbn, nan_value, 1, nan_value);
4303
4304   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
4305   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
4306
4307   TEST_fi_f (scalbn, 1, 0L, 1);
4308
4309   END (scalbn);
4310 }
4311
4312
4313 #if 0
4314 static void
4315 scalbln_test (void)
4316 {
4317
4318   START (scalbln);
4319
4320   TEST_fl_f (scalbln, 0, 0, 0);
4321   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
4322
4323   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
4324   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
4325   TEST_fl_f (scalbln, nan_value, 1, nan_value);
4326
4327   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
4328   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
4329
4330   TEST_fl_f (scalbln, 1, 0L, 1);
4331
4332   END (scalbn);
4333 }
4334 #endif
4335
4336
4337 static void
4338 signbit_test (void)
4339 {
4340
4341   START (signbit);
4342
4343   TEST_f_b (signbit, 0, 0);
4344   TEST_f_b (signbit, minus_zero, 1);
4345   TEST_f_b (signbit, plus_infty, 0);
4346   TEST_f_b (signbit, minus_infty, 1);
4347
4348   /* signbit (x) != 0 for x < 0.  */
4349   TEST_f_b (signbit, -1, 1);
4350   /* signbit (x) == 0 for x >= 0.  */
4351   TEST_f_b (signbit, 1, 0);
4352
4353   END (signbit);
4354 }
4355
4356
4357 static void
4358 sin_test (void)
4359 {
4360   errno = 0;
4361   FUNC(sin) (0);
4362   if (errno == ENOSYS)
4363     /* Function not implemented.  */
4364     return;
4365
4366   START (sin);
4367
4368   TEST_f_f (sin, 0, 0);
4369   TEST_f_f (sin, minus_zero, minus_zero);
4370   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
4371   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
4372   TEST_f_f (sin, nan_value, nan_value);
4373
4374   TEST_f_f (sin, M_PI_6l, 0.5);
4375   TEST_f_f (sin, -M_PI_6l, -0.5);
4376   TEST_f_f (sin, M_PI_2l, 1);
4377   TEST_f_f (sin, -M_PI_2l, -1);
4378   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
4379
4380 #ifdef TEST_DOUBLE
4381   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
4382 #endif
4383
4384   END (sin);
4385
4386 }
4387
4388
4389 #if 0
4390 static void
4391 sincos_test (void)
4392 {
4393   FLOAT sin_res, cos_res;
4394
4395   errno = 0;
4396   FUNC(sincos) (0, &sin_res, &cos_res);
4397   if (errno == ENOSYS)
4398     /* Function not implemented.  */
4399     return;
4400
4401   START (sincos);
4402
4403   /* sincos is treated differently because it returns void.  */
4404   TEST_extra (sincos, 0, 0, 1);
4405
4406   TEST_extra (sincos, minus_zero, minus_zero, 1);
4407   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4408   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4409   TEST_extra (sincos, nan_value, nan_value, nan_value);
4410
4411   TEST_extra (sincos, M_PI_2l, 1, 0);
4412   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
4413   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
4414   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
4415
4416 #ifdef TEST_DOUBLE
4417   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
4418 #endif
4419
4420   END (sincos);
4421 }
4422 #endif
4423
4424 static void
4425 sinh_test (void)
4426 {
4427   errno = 0;
4428   FUNC(sinh) (0.7L);
4429   if (errno == ENOSYS)
4430     /* Function not implemented.  */
4431     return;
4432
4433   START (sinh);
4434   TEST_f_f (sinh, 0, 0);
4435   TEST_f_f (sinh, minus_zero, minus_zero);
4436
4437 #ifndef TEST_INLINE
4438   TEST_f_f (sinh, plus_infty, plus_infty);
4439   TEST_f_f (sinh, minus_infty, minus_infty);
4440 #endif
4441   TEST_f_f (sinh, nan_value, nan_value);
4442
4443   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
4444   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
4445
4446   END (sinh);
4447 }
4448
4449 static void
4450 sqrt_test (void)
4451 {
4452   errno = 0;
4453   FUNC(sqrt) (1);
4454   if (errno == ENOSYS)
4455     /* Function not implemented.  */
4456     return;
4457
4458   START (sqrt);
4459
4460   TEST_f_f (sqrt, 0, 0);
4461   TEST_f_f (sqrt, nan_value, nan_value);
4462   TEST_f_f (sqrt, plus_infty, plus_infty);
4463
4464   TEST_f_f (sqrt, minus_zero, minus_zero);
4465
4466   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
4467   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
4468   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
4469   TEST_f_f (sqrt, nan_value, nan_value);
4470
4471   TEST_f_f (sqrt, 2209, 47);
4472   TEST_f_f (sqrt, 4, 2);
4473   TEST_f_f (sqrt, 2, M_SQRT2l);
4474   TEST_f_f (sqrt, 0.25, 0.5);
4475   TEST_f_f (sqrt, 6642.25, 81.5);
4476   TEST_f_f (sqrt, 15190.5625L, 123.25L);
4477   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
4478
4479   END (sqrt);
4480 }
4481
4482
4483 static void
4484 tan_test (void)
4485 {
4486   errno = 0;
4487   FUNC(tan) (0);
4488   if (errno == ENOSYS)
4489     /* Function not implemented.  */
4490     return;
4491
4492   START (tan);
4493
4494   TEST_f_f (tan, 0, 0);
4495   TEST_f_f (tan, minus_zero, minus_zero);
4496   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
4497   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
4498   TEST_f_f (tan, nan_value, nan_value);
4499
4500   TEST_f_f (tan, M_PI_4l, 1);
4501   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
4502
4503   END (tan);
4504 }
4505
4506 static void
4507 tanh_test (void)
4508 {
4509   errno = 0;
4510   FUNC(tanh) (0.7L);
4511   if (errno == ENOSYS)
4512     /* Function not implemented.  */
4513     return;
4514
4515   START (tanh);
4516
4517   TEST_f_f (tanh, 0, 0);
4518   TEST_f_f (tanh, minus_zero, minus_zero);
4519
4520 #ifndef TEST_INLINE
4521   TEST_f_f (tanh, plus_infty, 1);
4522   TEST_f_f (tanh, minus_infty, -1);
4523 #endif
4524   TEST_f_f (tanh, nan_value, nan_value);
4525
4526   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
4527   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
4528
4529   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
4530   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
4531
4532   /* 2^-57  */
4533   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
4534
4535   END (tanh);
4536 }
4537
4538 #if 0
4539 static void
4540 tgamma_test (void)
4541 {
4542   errno = 0;
4543   FUNC(tgamma) (1);
4544   if (errno == ENOSYS)
4545     /* Function not implemented.  */
4546     return;
4547   feclearexcept (FE_ALL_EXCEPT);
4548
4549   START (tgamma);
4550
4551   TEST_f_f (tgamma, plus_infty, plus_infty);
4552   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4553   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4554   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
4555   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
4556   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
4557   TEST_f_f (tgamma, nan_value, nan_value);
4558
4559   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
4560   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
4561
4562   TEST_f_f (tgamma, 1, 1);
4563   TEST_f_f (tgamma, 4, 6);
4564
4565   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
4566   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
4567
4568   END (tgamma);
4569 }
4570 #endif
4571
4572
4573 #if 0
4574 static void
4575 trunc_test (void)
4576 {
4577   START (trunc);
4578
4579   TEST_f_f (trunc, plus_infty, plus_infty);
4580   TEST_f_f (trunc, minus_infty, minus_infty);
4581   TEST_f_f (trunc, nan_value, nan_value);
4582
4583   TEST_f_f (trunc, 0, 0);
4584   TEST_f_f (trunc, minus_zero, minus_zero);
4585   TEST_f_f (trunc, 0.625, 0);
4586   TEST_f_f (trunc, -0.625, minus_zero);
4587   TEST_f_f (trunc, 1, 1);
4588   TEST_f_f (trunc, -1, -1);
4589   TEST_f_f (trunc, 1.625, 1);
4590   TEST_f_f (trunc, -1.625, -1);
4591
4592   TEST_f_f (trunc, 1048580.625L, 1048580L);
4593   TEST_f_f (trunc, -1048580.625L, -1048580L);
4594
4595   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
4596   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
4597
4598   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
4599   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
4600
4601 #ifdef TEST_LDOUBLE
4602   /* The result can only be represented in long double.  */
4603   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
4604   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
4605   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
4606   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
4607   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
4608
4609   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
4610   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
4611   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
4612   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
4613   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
4614
4615   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
4616   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
4617   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
4618   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
4619   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
4620
4621   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
4622   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
4623   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
4624   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
4625   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
4626
4627   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
4628   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
4629   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
4630   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
4631   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
4632
4633   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
4634   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
4635   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
4636   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
4637   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
4638
4639   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4640   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4641   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4642   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4643   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4644 #endif
4645
4646   END (trunc);
4647 }
4648 #endif
4649
4650 static void
4651 y0_test (void)
4652 {
4653   errno = 0;
4654 #if 0
4655   FLOAT s, c;
4656   FUNC (sincos) (0, &s, &c);
4657   if (errno == ENOSYS)
4658     /* Required function not implemented.  */
4659     return;
4660 #endif
4661   FUNC(y0) (1);
4662   if (errno == ENOSYS)
4663     /* Function not implemented.  */
4664     return;
4665
4666   /* y0 is the Bessel function of the second kind of order 0 */
4667   START (y0);
4668
4669   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
4670   TEST_f_f (y0, 0.0, minus_infty);
4671   TEST_f_f (y0, nan_value, nan_value);
4672   TEST_f_f (y0, plus_infty, 0);
4673
4674   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
4675   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
4676   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
4677   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
4678   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
4679   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
4680   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
4681
4682   END (y0);
4683 }
4684
4685
4686 static void
4687 y1_test (void)
4688 {
4689   errno = 0;
4690 #if 0
4691   FLOAT s, c;
4692   FUNC (sincos) (0, &s, &c);
4693   if (errno == ENOSYS)
4694     /* Required function not implemented.  */
4695     return;
4696 #endif
4697   FUNC(y1) (1);
4698   if (errno == ENOSYS)
4699     /* Function not implemented.  */
4700     return;
4701
4702   /* y1 is the Bessel function of the second kind of order 1 */
4703   START (y1);
4704
4705   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
4706   TEST_f_f (y1, 0.0, minus_infty);
4707   TEST_f_f (y1, plus_infty, 0);
4708   TEST_f_f (y1, nan_value, nan_value);
4709
4710   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
4711   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
4712   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
4713   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
4714   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
4715   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
4716   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
4717
4718   END (y1);
4719 }
4720
4721
4722 static void
4723 yn_test (void)
4724 {
4725   errno = 0;
4726 #if 0
4727   FLOAT s, c;
4728   FUNC (sincos) (0, &s, &c);
4729   if (errno == ENOSYS)
4730     /* Required function not implemented.  */
4731     return;
4732 #endif
4733   FUNC(yn) (1, 1);
4734   if (errno == ENOSYS)
4735     /* Function not implemented.  */
4736     return;
4737
4738   /* yn is the Bessel function of the second kind of order n */
4739   START (yn);
4740
4741   /* yn (0, x) == y0 (x)  */
4742   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
4743   TEST_ff_f (yn, 0, 0.0, minus_infty);
4744   TEST_ff_f (yn, 0, nan_value, nan_value);
4745   TEST_ff_f (yn, 0, plus_infty, 0);
4746
4747   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
4748   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
4749   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
4750   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
4751   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
4752   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
4753   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
4754
4755   /* yn (1, x) == y1 (x)  */
4756   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
4757   TEST_ff_f (yn, 1, 0.0, minus_infty);
4758   TEST_ff_f (yn, 1, plus_infty, 0);
4759   TEST_ff_f (yn, 1, nan_value, nan_value);
4760
4761   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
4762   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
4763   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
4764   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
4765   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
4766   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
4767   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
4768
4769   /* yn (3, x)  */
4770   TEST_ff_f (yn, 3, plus_infty, 0);
4771   TEST_ff_f (yn, 3, nan_value, nan_value);
4772
4773   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
4774   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
4775   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
4776   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
4777   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
4778
4779   /* yn (10, x)  */
4780   TEST_ff_f (yn, 10, plus_infty, 0);
4781   TEST_ff_f (yn, 10, nan_value, nan_value);
4782
4783   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
4784   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
4785   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
4786   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
4787   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
4788
4789   END (yn);
4790
4791 }
4792
4793
4794 static void
4795 significand_test (void)
4796 {
4797   /* significand returns the mantissa of the exponential representation.  */
4798   START (significand);
4799
4800   TEST_f_f (significand, 4.0, 1.0);
4801   TEST_f_f (significand, 6.0, 1.5);
4802   TEST_f_f (significand, 8.0, 1.0);
4803
4804   END (significand);
4805 }
4806
4807
4808 static void
4809 initialize (void)
4810 {
4811   fpstack_test ("start *init*");
4812   plus_zero = 0.0;
4813   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
4814
4815   minus_zero = FUNC(copysign) (0.0, -1.0);
4816   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
4817                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
4818   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
4819                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
4820   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4821                       LDBL_MAX, DBL_MAX, FLT_MAX);
4822   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
4823                       LDBL_MIN, DBL_MIN, FLT_MIN);
4824
4825   (void) &plus_zero;
4826   (void) &nan_value;
4827   (void) &minus_zero;
4828   (void) &plus_infty;
4829   (void) &minus_infty;
4830   (void) &max_value;
4831   (void) &min_value;
4832
4833   /* Clear all exceptions.  From now on we must not get random exceptions.  */
4834   feclearexcept (FE_ALL_EXCEPT);
4835
4836   /* Test to make sure we start correctly.  */
4837   fpstack_test ("end *init*");
4838 }
4839
4840 #if 0
4841 /* function to check our ulp calculation.  */
4842 void
4843 check_ulp (void)
4844 {
4845   int i;
4846
4847   FLOAT u, diff, ulp;
4848   /* This gives one ulp.  */
4849   u = FUNC(nextafter) (10, 20);
4850   check_equal (10.0, u, 1, &diff, &ulp);
4851   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
4852
4853   /* This gives one more ulp.  */
4854   u = FUNC(nextafter) (u, 20);
4855   check_equal (10.0, u, 2, &diff, &ulp);
4856   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
4857
4858   /* And now calculate 100 ulp.  */
4859   for (i = 2; i < 100; i++)
4860     u = FUNC(nextafter) (u, 20);
4861   check_equal (10.0, u, 100, &diff, &ulp);
4862   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
4863 }
4864 #endif
4865
4866 int
4867 main (int argc, char **argv)
4868 {
4869
4870   int key;
4871
4872   verbose = 1;
4873   output_ulps = 0;
4874   output_max_error = 1;
4875   output_points = 1;
4876   /* XXX set to 0 for releases.  */
4877   ignore_max_ulp = 0;
4878
4879   /* Parse and process arguments.  */
4880   while ((key = getopt(argc, argv, "fi:puv")) > 0) {
4881       switch (key)
4882       {
4883           case 'f':
4884               output_max_error = 0;
4885               break;
4886           case 'i':
4887               if (strcmp (optarg, "yes") == 0)
4888                   ignore_max_ulp = 1;
4889               else if (strcmp (optarg, "no") == 0)
4890                   ignore_max_ulp = 0;
4891               break;
4892           case 'p':
4893               output_points = 0;
4894               break;
4895           case 'u':
4896               output_ulps = 1;
4897               break;
4898           case 'v':
4899               verbose = 3;
4900               break;
4901           default:
4902               fprintf (stderr, "Unknown argument: %c", key);
4903               exit (EXIT_FAILURE);
4904       }
4905   }
4906
4907   if (optind != argc)
4908     {
4909       fprintf (stderr, "wrong number of arguments");
4910       exit (EXIT_FAILURE);
4911     }
4912
4913   if (output_ulps)
4914     {
4915       ulps_file = fopen ("ULPs", "a");
4916       if (ulps_file == NULL)
4917         {
4918           perror ("can't open file `ULPs' for writing: ");
4919           exit (1);
4920         }
4921     }
4922
4923
4924   initialize ();
4925   printf (TEST_MSG);
4926
4927 #if 0
4928   check_ulp ();
4929 #endif
4930
4931   /* Keep the tests a wee bit ordered (according to ISO C99).  */
4932   /* Classification macros:  */
4933   fpclassify_test ();
4934   isfinite_test ();
4935   isnormal_test ();
4936   signbit_test ();
4937
4938   /* Trigonometric functions:  */
4939   acos_test ();
4940   asin_test ();
4941   atan_test ();
4942   atan2_test ();
4943   cos_test ();
4944   sin_test ();
4945 #if 0
4946   sincos_test ();
4947 #endif
4948   tan_test ();
4949
4950   /* Hyperbolic functions:  */
4951   acosh_test ();
4952   asinh_test ();
4953   atanh_test ();
4954   cosh_test ();
4955   sinh_test ();
4956   tanh_test ();
4957
4958   /* Exponential and logarithmic functions:  */
4959   exp_test ();
4960 #if 0
4961   exp10_test ();
4962   exp2_test ();
4963 #endif
4964   expm1_test ();
4965   frexp_test ();
4966   ldexp_test ();
4967   log_test ();
4968   log10_test ();
4969   log1p_test ();
4970 #if 0
4971   log2_test ();
4972 #endif
4973   logb_test ();
4974   modf_test ();
4975   ilogb_test ();
4976   scalb_test ();
4977   scalbn_test ();
4978 #if 0
4979   scalbln_test ();
4980 #endif
4981   significand_test ();
4982
4983   /* Power and absolute value functions:  */
4984   cbrt_test ();
4985   fabs_test ();
4986   hypot_test ();
4987   pow_test ();
4988   sqrt_test ();
4989
4990   /* Error and gamma functions:  */
4991   erf_test ();
4992   erfc_test ();
4993   gamma_test ();
4994   lgamma_test ();
4995 #if 0
4996   tgamma_test ();
4997 #endif
4998
4999   /* Nearest integer functions:  */
5000   ceil_test ();
5001   floor_test ();
5002 #if 0
5003   nearbyint_test ();
5004 #endif
5005   rint_test ();
5006 #if 0
5007   rint_test_tonearest ();
5008   rint_test_towardzero ();
5009   rint_test_downward ();
5010   rint_test_upward ();
5011   lrint_test ();
5012   llrint_test ();
5013   round_test ();
5014   lround_test ();
5015   llround_test ();
5016   trunc_test ();
5017 #endif
5018
5019   /* Remainder functions:  */
5020   fmod_test ();
5021   remainder_test ();
5022 #if 0
5023   remquo_test ();
5024 #endif
5025
5026   /* Manipulation functions:  */
5027   copysign_test ();
5028 #if 0
5029   nextafter_test ();
5030   nexttoward_test ();
5031
5032   /* maximum, minimum and positive difference functions */
5033   fdim_test ();
5034   fmax_test ();
5035   fmin_test ();
5036
5037   /* Multiply and add:  */
5038   fma_test ();
5039
5040   /* Complex functions:  */
5041   cabs_test ();
5042   cacos_test ();
5043   cacosh_test ();
5044   carg_test ();
5045   casin_test ();
5046   casinh_test ();
5047   catan_test ();
5048   catanh_test ();
5049   ccos_test ();
5050   ccosh_test ();
5051   cexp_test ();
5052   cimag_test ();
5053   clog10_test ();
5054   clog_test ();
5055 #if 0
5056   conj_test ();
5057 #endif
5058   cpow_test ();
5059   cproj_test ();
5060   creal_test ();
5061   csin_test ();
5062   csinh_test ();
5063   csqrt_test ();
5064   ctan_test ();
5065   ctanh_test ();
5066 #endif
5067
5068   /* Bessel functions:  */
5069 #if 0
5070   j0_test ();
5071   j1_test ();
5072   jn_test ();
5073   y0_test ();
5074   y1_test ();
5075   yn_test ();
5076 #endif
5077
5078   if (output_ulps)
5079     fclose (ulps_file);
5080
5081   printf ("\nTest suite completed:\n");
5082   printf ("  %d test cases plus %d tests for exception flags executed.\n",
5083           noTests, noExcTests);
5084   if (noXFails)
5085     printf ("  %d expected failures occurred.\n", noXFails);
5086   if (noXPasses)
5087     printf ("  %d unexpected passes occurred.\n", noXPasses);
5088   if (noErrors)
5089     {
5090       printf ("  %d errors occurred.\n", noErrors);
5091       return 1;
5092     }
5093   printf ("  All tests passed successfully.\n");
5094
5095   return 0;
5096 }
5097
5098 /*
5099  * Local Variables:
5100  * mode:c
5101  * End:
5102  */