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 #if defined __DO_XSI_MATH__
3007 static void
3008 j0_test (void)
3009 {
3010   errno = 0;
3011 #if 0
3012   FLOAT s, c;
3013   FUNC (sincos) (0, &s, &c);
3014   if (errno == ENOSYS)
3015     /* Required function not implemented.  */
3016     return;
3017 #endif
3018   FUNC(j0) (0);
3019   if (errno == ENOSYS)
3020     /* Function not implemented.  */
3021     return;
3022
3023   START (j0);
3024
3025   /* j0 is the Bessel function of the first kind of order 0 */
3026   TEST_f_f (j0, nan_value, nan_value);
3027   TEST_f_f (j0, plus_infty, 0);
3028   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
3029   TEST_f_f (j0, 0.0, 1.0);
3030   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
3031   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
3032   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
3033   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
3034   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
3035   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
3036   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
3037   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3038   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3039
3040   END (j0);
3041 }
3042
3043
3044 static void
3045 j1_test (void)
3046 {
3047   errno = 0;
3048 #if 0
3049   FLOAT s, c;
3050   FUNC (sincos) (0, &s, &c);
3051   if (errno == ENOSYS)
3052     /* Required function not implemented.  */
3053     return;
3054 #endif
3055   FUNC(j1) (0);
3056   if (errno == ENOSYS)
3057     /* Function not implemented.  */
3058     return;
3059
3060   /* j1 is the Bessel function of the first kind of order 1 */
3061
3062   START (j1);
3063
3064   TEST_f_f (j1, nan_value, nan_value);
3065   TEST_f_f (j1, plus_infty, 0);
3066
3067   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
3068   TEST_f_f (j1, 0.0, 0.0);
3069   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
3070   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
3071   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
3072   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
3073   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
3074   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
3075   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
3076
3077   END (j1);
3078 }
3079
3080 static void
3081 jn_test (void)
3082 {
3083   errno = 0;
3084 #if 0
3085   FLOAT s, c;
3086   FUNC (sincos) (0, &s, &c);
3087   if (errno == ENOSYS)
3088     /* Required function not implemented.  */
3089     return;
3090 #endif
3091   FUNC(jn) (1, 1);
3092   if (errno == ENOSYS)
3093     /* Function not implemented.  */
3094     return;
3095
3096   /* jn is the Bessel function of the first kind of order n.  */
3097   START (jn);
3098
3099   /* jn (0, x) == j0 (x)  */
3100   TEST_ff_f (jn, 0, nan_value, nan_value);
3101   TEST_ff_f (jn, 0, plus_infty, 0);
3102   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
3103   TEST_ff_f (jn, 0, 0.0, 1.0);
3104   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
3105   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
3106   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
3107   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
3108   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
3109   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
3110   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
3111   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
3112   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
3113
3114   /* jn (1, x) == j1 (x)  */
3115   TEST_ff_f (jn, 1, nan_value, nan_value);
3116   TEST_ff_f (jn, 1, plus_infty, 0);
3117   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
3118   TEST_ff_f (jn, 1, 0.0, 0.0);
3119   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3120   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3121   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3122   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3123   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3124   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3125   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3126
3127   /* jn (3, x)  */
3128   TEST_ff_f (jn, 3, nan_value, nan_value);
3129   TEST_ff_f (jn, 3, plus_infty, 0);
3130
3131   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3132   TEST_ff_f (jn, 3, 0.0, 0.0);
3133   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3134   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3135   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3136   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3137   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3138
3139   /*  jn (10, x)  */
3140   TEST_ff_f (jn, 10, nan_value, nan_value);
3141   TEST_ff_f (jn, 10, plus_infty, 0);
3142
3143   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3144   TEST_ff_f (jn, 10, 0.0, 0.0);
3145   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3146   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3147   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3148   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3149   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3150
3151   END (jn);
3152 }
3153 #endif /* __DO_XSI_MATH__ */
3154
3155
3156 static void
3157 ldexp_test (void)
3158 {
3159   TEST_ff_f (ldexp, 0, 0, 0);
3160   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3161
3162   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3163   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3164   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3165
3166   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3167   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3168
3169   /* ldexp (x, 0) == x.  */
3170   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3171 }
3172
3173
3174 static void
3175 lgamma_test (void)
3176 {
3177   errno = 0;
3178   FUNC(lgamma) (0);
3179   if (errno == ENOSYS)
3180     /* Function not implemented.  */
3181     return;
3182   feclearexcept (FE_ALL_EXCEPT);
3183
3184   START (lgamma);
3185
3186   TEST_f_f (lgamma, plus_infty, plus_infty);
3187   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3188   TEST_f_f (lgamma, nan_value, nan_value);
3189
3190   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3191   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3192   TEST_f_f (lgamma, minus_infty, plus_infty);
3193
3194   TEST_f_f1 (lgamma, 1, 0, 1);
3195
3196   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3197
3198   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3199   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3200   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3201   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3202
3203   END (lgamma);
3204 }
3205
3206
3207 #if 0
3208 static void
3209 lrint_test (void)
3210 {
3211   /* XXX this test is incomplete.  We need to have a way to specifiy
3212      the rounding method and test the critical cases.  So far, only
3213      unproblematic numbers are tested.  */
3214
3215   START (lrint);
3216
3217   TEST_f_l (lrint, 0.0, 0);
3218   TEST_f_l (lrint, minus_zero, 0);
3219   TEST_f_l (lrint, 0.2L, 0);
3220   TEST_f_l (lrint, -0.2L, 0);
3221
3222   TEST_f_l (lrint, 1.4L, 1);
3223   TEST_f_l (lrint, -1.4L, -1);
3224
3225   TEST_f_l (lrint, 8388600.3L, 8388600);
3226   TEST_f_l (lrint, -8388600.3L, -8388600);
3227
3228   TEST_f_l (lrint, 1071930.0008, 1071930);
3229 #ifndef TEST_FLOAT
3230   TEST_f_l (lrint, 1073741824.01, 1073741824);
3231 # if LONG_MAX > 281474976710656
3232   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3233 # endif
3234 #endif
3235
3236   END (lrint);
3237 }
3238
3239
3240 static void
3241 llrint_test (void)
3242 {
3243   /* XXX this test is incomplete.  We need to have a way to specifiy
3244      the rounding method and test the critical cases.  So far, only
3245      unproblematic numbers are tested.  */
3246
3247   START (llrint);
3248
3249   TEST_f_L (llrint, 0.0, 0);
3250   TEST_f_L (llrint, minus_zero, 0);
3251   TEST_f_L (llrint, 0.2L, 0);
3252   TEST_f_L (llrint, -0.2L, 0);
3253
3254   TEST_f_L (llrint, 1.4L, 1);
3255   TEST_f_L (llrint, -1.4L, -1);
3256
3257   TEST_f_L (llrint, 8388600.3L, 8388600);
3258   TEST_f_L (llrint, -8388600.3L, -8388600);
3259
3260   TEST_f_l (llrint, 1071930.0008, 1071930);
3261
3262   /* Test boundary conditions.  */
3263   /* 0x1FFFFF */
3264   TEST_f_L (llrint, 2097151.0,2097151LL);
3265   /* 0x800000 */
3266   TEST_f_L (llrint, 8388608.0, 8388608LL);
3267   /* 0x1000000 */
3268   TEST_f_L (llrint, 16777216.0, 16777216LL);
3269   /* 0x20000000000 */
3270   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3271   /* 0x40000000000 */
3272   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3273   /* 0x1000000000000 */
3274   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3275   /* 0x10000000000000 */
3276   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3277   /* 0x10000080000000 */
3278   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3279   /* 0x20000000000000 */
3280   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3281   /* 0x80000000000000 */
3282   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3283   /* 0x100000000000000 */
3284   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3285 #ifdef TEST_LDOUBLE
3286   /* The input can only be represented in long double.  */
3287   TEST_f_L (llrint, 4503599627370495.5L, 4503599627370496LL);
3288   TEST_f_L (llrint, 4503599627370496.25L, 4503599627370496LL);
3289   TEST_f_L (llrint, 4503599627370496.5L, 4503599627370496LL);
3290   TEST_f_L (llrint, 4503599627370496.75L, 4503599627370497LL);
3291   TEST_f_L (llrint, 4503599627370497.5L, 4503599627370498LL);
3292
3293   TEST_f_L (llrint, -4503599627370495.5L, -4503599627370496LL);
3294   TEST_f_L (llrint, -4503599627370496.25L, -4503599627370496LL);
3295   TEST_f_L (llrint, -4503599627370496.5L, -4503599627370496LL);
3296   TEST_f_L (llrint, -4503599627370496.75L, -4503599627370497LL);
3297   TEST_f_L (llrint, -4503599627370497.5L, -4503599627370498LL);
3298
3299   TEST_f_L (llrint, 9007199254740991.5L, 9007199254740992LL);
3300   TEST_f_L (llrint, 9007199254740992.25L, 9007199254740992LL);
3301   TEST_f_L (llrint, 9007199254740992.5L, 9007199254740992LL);
3302   TEST_f_L (llrint, 9007199254740992.75L, 9007199254740993LL);
3303   TEST_f_L (llrint, 9007199254740993.5L, 9007199254740994LL);
3304
3305   TEST_f_L (llrint, -9007199254740991.5L, -9007199254740992LL);
3306   TEST_f_L (llrint, -9007199254740992.25L, -9007199254740992LL);
3307   TEST_f_L (llrint, -9007199254740992.5L, -9007199254740992LL);
3308   TEST_f_L (llrint, -9007199254740992.75L, -9007199254740993LL);
3309   TEST_f_L (llrint, -9007199254740993.5L, -9007199254740994LL);
3310
3311   TEST_f_L (llrint, 72057594037927935.5L, 72057594037927936LL);
3312   TEST_f_L (llrint, 72057594037927936.25L, 72057594037927936LL);
3313   TEST_f_L (llrint, 72057594037927936.5L, 72057594037927936LL);
3314   TEST_f_L (llrint, 72057594037927936.75L, 72057594037927937LL);
3315   TEST_f_L (llrint, 72057594037927937.5L, 72057594037927938LL);
3316
3317   TEST_f_L (llrint, -72057594037927935.5L, -72057594037927936LL);
3318   TEST_f_L (llrint, -72057594037927936.25L, -72057594037927936LL);
3319   TEST_f_L (llrint, -72057594037927936.5L, -72057594037927936LL);
3320   TEST_f_L (llrint, -72057594037927936.75L, -72057594037927937LL);
3321   TEST_f_L (llrint, -72057594037927937.5L, -72057594037927938LL);
3322 #endif
3323
3324   END (llrint);
3325 }
3326 #endif
3327
3328
3329 static void
3330 log_test (void)
3331 {
3332   errno = 0;
3333   FUNC(log) (1);
3334   if (errno == ENOSYS)
3335     /* Function not implemented.  */
3336     return;
3337   START (log);
3338
3339   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3340   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3341
3342   TEST_f_f (log, 1, 0);
3343
3344   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3345   TEST_f_f (log, plus_infty, plus_infty);
3346
3347   TEST_f_f (log, M_El, 1);
3348   TEST_f_f (log, 1.0 / M_El, -1);
3349   TEST_f_f (log, 2, M_LN2l);
3350   TEST_f_f (log, 10, M_LN10l);
3351   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
3352
3353   END (log);
3354 }
3355
3356
3357 static void
3358 log10_test (void)
3359 {
3360   errno = 0;
3361   FUNC(log10) (1);
3362   if (errno == ENOSYS)
3363     /* Function not implemented.  */
3364     return;
3365
3366   START (log10);
3367
3368   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3369   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3370
3371   TEST_f_f (log10, 1, 0);
3372
3373   /* log10 (x) == NaN plus invalid exception if x < 0.  */
3374   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3375
3376   TEST_f_f (log10, plus_infty, plus_infty);
3377   TEST_f_f (log10, nan_value, nan_value);
3378
3379   TEST_f_f (log10, 0.1L, -1);
3380   TEST_f_f (log10, 10.0, 1);
3381   TEST_f_f (log10, 100.0, 2);
3382   TEST_f_f (log10, 10000.0, 4);
3383   TEST_f_f (log10, M_El, M_LOG10El);
3384   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
3385
3386   END (log10);
3387 }
3388
3389
3390 static void
3391 log1p_test (void)
3392 {
3393   errno = 0;
3394   FUNC(log1p) (0);
3395   if (errno == ENOSYS)
3396     /* Function not implemented.  */
3397     return;
3398
3399   START (log1p);
3400
3401   TEST_f_f (log1p, 0, 0);
3402   TEST_f_f (log1p, minus_zero, minus_zero);
3403
3404   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3405   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3406
3407   TEST_f_f (log1p, plus_infty, plus_infty);
3408   TEST_f_f (log1p, nan_value, nan_value);
3409
3410   TEST_f_f (log1p, M_El - 1.0, 1);
3411
3412   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
3413   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
3414
3415   END (log1p);
3416 }
3417
3418
3419 #if 0
3420 static void
3421 log2_test (void)
3422 {
3423   errno = 0;
3424   FUNC(log2) (1);
3425   if (errno == ENOSYS)
3426     /* Function not implemented.  */
3427     return;
3428
3429   START (log2);
3430
3431   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3432   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3433
3434   TEST_f_f (log2, 1, 0);
3435
3436   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3437
3438   TEST_f_f (log2, plus_infty, plus_infty);
3439   TEST_f_f (log2, nan_value, nan_value);
3440
3441   TEST_f_f (log2, M_El, M_LOG2El);
3442   TEST_f_f (log2, 2.0, 1);
3443   TEST_f_f (log2, 16.0, 4);
3444   TEST_f_f (log2, 256.0, 8);
3445   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
3446
3447   END (log2);
3448 }
3449 #endif
3450
3451
3452 static void
3453 logb_test (void)
3454 {
3455   START (logb);
3456
3457   TEST_f_f (logb, plus_infty, plus_infty);
3458   TEST_f_f (logb, minus_infty, plus_infty);
3459
3460   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3461
3462   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3463   TEST_f_f (logb, nan_value, nan_value);
3464
3465   TEST_f_f (logb, 1, 0);
3466   TEST_f_f (logb, M_El, 1);
3467   TEST_f_f (logb, 1024, 10);
3468   TEST_f_f (logb, -2000, 10);
3469
3470   END (logb);
3471 }
3472
3473
3474 #if 0
3475 static void
3476 lround_test (void)
3477 {
3478   START (lround);
3479
3480   TEST_f_l (lround, 0, 0);
3481   TEST_f_l (lround, minus_zero, 0);
3482   TEST_f_l (lround, 0.2L, 0.0);
3483   TEST_f_l (lround, -0.2L, 0);
3484   TEST_f_l (lround, 0.5, 1);
3485   TEST_f_l (lround, -0.5, -1);
3486   TEST_f_l (lround, 0.8L, 1);
3487   TEST_f_l (lround, -0.8L, -1);
3488   TEST_f_l (lround, 1.5, 2);
3489   TEST_f_l (lround, -1.5, -2);
3490   TEST_f_l (lround, 22514.5, 22515);
3491   TEST_f_l (lround, -22514.5, -22515);
3492   TEST_f_l (lround, 1071930.0008, 1071930);
3493 #ifndef TEST_FLOAT
3494   TEST_f_l (lround, 1073741824.01, 1073741824);
3495 # if LONG_MAX > 281474976710656
3496   TEST_f_l (lround, 281474976710656.025, 281474976710656);
3497 # endif
3498   TEST_f_l (lround, 2097152.5, 2097153);
3499   TEST_f_l (lround, -2097152.5, -2097153);
3500 #endif
3501   END (lround);
3502 }
3503
3504
3505 static void
3506 llround_test (void)
3507 {
3508   START (llround);
3509
3510   TEST_f_L (llround, 0, 0);
3511   TEST_f_L (llround, minus_zero, 0);
3512   TEST_f_L (llround, 0.2L, 0.0);
3513   TEST_f_L (llround, -0.2L, 0);
3514   TEST_f_L (llround, 0.5, 1);
3515   TEST_f_L (llround, -0.5, -1);
3516   TEST_f_L (llround, 0.8L, 1);
3517   TEST_f_L (llround, -0.8L, -1);
3518   TEST_f_L (llround, 1.5, 2);
3519   TEST_f_L (llround, -1.5, -2);
3520   TEST_f_L (llround, 22514.5, 22515);
3521   TEST_f_L (llround, -22514.5, -22515);
3522   TEST_f_l (llround, 1071930.0008, 1071930);
3523 #ifndef TEST_FLOAT
3524   TEST_f_L (llround, 2097152.5, 2097153);
3525   TEST_f_L (llround, -2097152.5, -2097153);
3526   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3527   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3528 #endif
3529
3530   /* Test boundary conditions.  */
3531   /* 0x1FFFFF */
3532   TEST_f_L (llround, 2097151.0, 2097151LL);
3533   /* 0x800000 */
3534   TEST_f_L (llround, 8388608.0, 8388608LL);
3535   /* 0x1000000 */
3536   TEST_f_L (llround, 16777216.0, 16777216LL);
3537   /* 0x20000000000 */
3538   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3539   /* 0x40000000000 */
3540   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3541   /* 0x1000000000000 */
3542   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
3543   /* 0x10000000000000 */
3544   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3545   /* 0x10000080000000 */
3546   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
3547   /* 0x20000000000000 */
3548   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3549   /* 0x80000000000000 */
3550   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3551   /* 0x100000000000000 */
3552   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3553
3554 #ifndef TEST_FLOAT
3555   /* 0x100000000 */
3556   TEST_f_L (llround, 4294967295.5, 4294967296LL);
3557   /* 0x200000000 */
3558   TEST_f_L (llround, 8589934591.5, 8589934592LL);
3559 #endif
3560
3561 #ifdef TEST_LDOUBLE
3562   /* The input can only be represented in long double.  */
3563   TEST_f_L (llround, 4503599627370495.5L, 4503599627370496LL);
3564   TEST_f_L (llround, 4503599627370496.25L, 4503599627370496LL);
3565   TEST_f_L (llround, 4503599627370496.5L, 4503599627370497LL);
3566   TEST_f_L (llround, 4503599627370496.75L, 4503599627370497LL);
3567   TEST_f_L (llround, 4503599627370497.5L, 4503599627370498LL);
3568
3569   TEST_f_L (llround, -4503599627370495.5L, -4503599627370496LL);
3570   TEST_f_L (llround, -4503599627370496.25L, -4503599627370496LL);
3571   TEST_f_L (llround, -4503599627370496.5L, -4503599627370497LL);
3572   TEST_f_L (llround, -4503599627370496.75L, -4503599627370497LL);
3573   TEST_f_L (llround, -4503599627370497.5L, -4503599627370498LL);
3574
3575   TEST_f_L (llround, 9007199254740991.5L, 9007199254740992LL);
3576   TEST_f_L (llround, 9007199254740992.25L, 9007199254740992LL);
3577   TEST_f_L (llround, 9007199254740992.5L, 9007199254740993LL);
3578   TEST_f_L (llround, 9007199254740992.75L, 9007199254740993LL);
3579   TEST_f_L (llround, 9007199254740993.5L, 9007199254740994LL);
3580
3581   TEST_f_L (llround, -9007199254740991.5L, -9007199254740992LL);
3582   TEST_f_L (llround, -9007199254740992.25L, -9007199254740992LL);
3583   TEST_f_L (llround, -9007199254740992.5L, -9007199254740993LL);
3584   TEST_f_L (llround, -9007199254740992.75L, -9007199254740993LL);
3585   TEST_f_L (llround, -9007199254740993.5L, -9007199254740994LL);
3586
3587   TEST_f_L (llround, 72057594037927935.5L, 72057594037927936LL);
3588   TEST_f_L (llround, 72057594037927936.25L, 72057594037927936LL);
3589   TEST_f_L (llround, 72057594037927936.5L, 72057594037927937LL);
3590   TEST_f_L (llround, 72057594037927936.75L, 72057594037927937LL);
3591   TEST_f_L (llround, 72057594037927937.5L, 72057594037927938LL);
3592
3593   TEST_f_L (llround, -72057594037927935.5L, -72057594037927936LL);
3594   TEST_f_L (llround, -72057594037927936.25L, -72057594037927936LL);
3595   TEST_f_L (llround, -72057594037927936.5L, -72057594037927937LL);
3596   TEST_f_L (llround, -72057594037927936.75L, -72057594037927937LL);
3597   TEST_f_L (llround, -72057594037927937.5L, -72057594037927938LL);
3598
3599   TEST_f_L (llround, 9223372036854775806.25L, 9223372036854775806LL);
3600   TEST_f_L (llround, -9223372036854775806.25L, -9223372036854775806LL);
3601   TEST_f_L (llround, 9223372036854775806.5L, 9223372036854775807LL);
3602   TEST_f_L (llround, -9223372036854775806.5L, -9223372036854775807LL);
3603   TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL);
3604   TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL);
3605 #endif
3606
3607   END (llround);
3608 }
3609 #endif
3610
3611 static void
3612 modf_test (void)
3613 {
3614   FLOAT x;
3615
3616   START (modf);
3617
3618   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3619   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3620   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3621   TEST_fF_f1 (modf, 0, 0, 0);
3622   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3623   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3624   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3625   TEST_fF_f1 (modf, 20, 0, 20);
3626   TEST_fF_f1 (modf, 21, 0, 21);
3627   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3628
3629   END (modf);
3630 }
3631
3632
3633 #if 0
3634 static void
3635 nearbyint_test (void)
3636 {
3637   START (nearbyint);
3638
3639   TEST_f_f (nearbyint, 0.0, 0.0);
3640   TEST_f_f (nearbyint, minus_zero, minus_zero);
3641   TEST_f_f (nearbyint, plus_infty, plus_infty);
3642   TEST_f_f (nearbyint, minus_infty, minus_infty);
3643   TEST_f_f (nearbyint, nan_value, nan_value);
3644
3645   /* Default rounding mode is round to nearest.  */
3646   TEST_f_f (nearbyint, 0.5, 0.0);
3647   TEST_f_f (nearbyint, 1.5, 2.0);
3648   TEST_f_f (nearbyint, -0.5, minus_zero);
3649   TEST_f_f (nearbyint, -1.5, -2.0);
3650
3651   END (nearbyint);
3652 }
3653
3654 static void
3655 nextafter_test (void)
3656 {
3657
3658   START (nextafter);
3659
3660   TEST_ff_f (nextafter, 0, 0, 0);
3661   TEST_ff_f (nextafter, minus_zero, 0, 0);
3662   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3663   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3664
3665   TEST_ff_f (nextafter, 9, 9, 9);
3666   TEST_ff_f (nextafter, -9, -9, -9);
3667   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3668   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3669
3670   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
3671   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
3672   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3673
3674   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3675                          LDBL_MAX, DBL_MAX, FLT_MAX);
3676   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
3677   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
3678
3679 #ifdef TEST_LDOUBLE
3680   // XXX Enable once gcc is fixed.
3681   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
3682 #endif
3683
3684   /* XXX We need the hexadecimal FP number representation here for further
3685      tests.  */
3686
3687   END (nextafter);
3688 }
3689
3690
3691 static void
3692 nexttoward_test (void)
3693 {
3694   START (nexttoward);
3695   TEST_ff_f (nexttoward, 0, 0, 0);
3696   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3697   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3698   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3699
3700   TEST_ff_f (nexttoward, 9, 9, 9);
3701   TEST_ff_f (nexttoward, -9, -9, -9);
3702   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3703   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3704
3705   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
3706   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
3707   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3708
3709   /* XXX We need the hexadecimal FP number representation here for further
3710      tests.  */
3711
3712   END (nexttoward);
3713 }
3714 #endif
3715
3716
3717 static void
3718 pow_test (void)
3719 {
3720
3721   errno = 0;
3722   FUNC(pow) (0, 0);
3723   if (errno == ENOSYS)
3724     /* Function not implemented.  */
3725     return;
3726
3727   START (pow);
3728
3729   TEST_ff_f (pow, 0, 0, 1);
3730   TEST_ff_f (pow, 0, minus_zero, 1);
3731   TEST_ff_f (pow, minus_zero, 0, 1);
3732   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3733
3734   TEST_ff_f (pow, 10, 0, 1);
3735   TEST_ff_f (pow, 10, minus_zero, 1);
3736   TEST_ff_f (pow, -10, 0, 1);
3737   TEST_ff_f (pow, -10, minus_zero, 1);
3738
3739   TEST_ff_f (pow, nan_value, 0, 1);
3740   TEST_ff_f (pow, nan_value, minus_zero, 1);
3741
3742
3743 #ifndef TEST_INLINE
3744   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
3745   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3746   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
3747   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3748
3749   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3750   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3751   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3752   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3753
3754   TEST_ff_f (pow, 1.1L, minus_infty, 0);
3755   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3756   TEST_ff_f (pow, -1.1L, minus_infty, 0);
3757   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3758
3759   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3760   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3761   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3762   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3763
3764   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3765   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3766   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3767
3768   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3769   TEST_ff_f (pow, plus_infty, -1, 0);
3770   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3771
3772   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3773   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3774   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3775
3776   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3777   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3778   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3779   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
3780   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
3781   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
3782   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
3783
3784   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3785   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3786   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3787
3788   TEST_ff_f (pow, minus_infty, -2, 0);
3789   TEST_ff_f (pow, minus_infty, -12, 0);
3790   TEST_ff_f (pow, minus_infty, -1002, 0);
3791   TEST_ff_f (pow, minus_infty, -0.1L, 0);
3792   TEST_ff_f (pow, minus_infty, -1.1L, 0);
3793   TEST_ff_f (pow, minus_infty, -11.1L, 0);
3794   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
3795 #endif
3796
3797   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3798   TEST_ff_f (pow, 0, nan_value, nan_value);
3799   TEST_ff_f (pow, 1, nan_value, 1);
3800   TEST_ff_f (pow, -1, nan_value, nan_value);
3801   TEST_ff_f (pow, nan_value, 1, nan_value);
3802   TEST_ff_f (pow, nan_value, -1, nan_value);
3803
3804   /* pow (x, NaN) == NaN.  */
3805   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3806
3807   TEST_ff_f (pow, 1, plus_infty, 1);
3808   TEST_ff_f (pow, -1, plus_infty, 1);
3809   TEST_ff_f (pow, 1, minus_infty, 1);
3810   TEST_ff_f (pow, -1, minus_infty, 1);
3811   TEST_ff_f (pow, 1, 1, 1);
3812   TEST_ff_f (pow, 1, -1, 1);
3813   TEST_ff_f (pow, 1, 1.25, 1);
3814   TEST_ff_f (pow, 1, -1.25, 1);
3815   TEST_ff_f (pow, 1, 0x1p62L, 1);
3816   TEST_ff_f (pow, 1, 0x1p63L, 1);
3817   TEST_ff_f (pow, 1, 0x1p64L, 1);
3818   TEST_ff_f (pow, 1, 0x1p72L, 1);
3819
3820   /* pow (x, +-0) == 1.  */
3821   TEST_ff_f (pow, plus_infty, 0, 1);
3822   TEST_ff_f (pow, plus_infty, minus_zero, 1);
3823   TEST_ff_f (pow, minus_infty, 0, 1);
3824   TEST_ff_f (pow, minus_infty, 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, -32.75L, 0, 1);
3828   TEST_ff_f (pow, -32.75L, minus_zero, 1);
3829   TEST_ff_f (pow, 0x1p72L, 0, 1);
3830   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
3831   TEST_ff_f (pow, 0x1p-72L, 0, 1);
3832   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
3833
3834   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3835   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3836   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3837   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3838
3839   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3840   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3841   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3842   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3843
3844   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3845   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3846   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3847   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3848
3849   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty);
3850   TEST_ff_f (pow, 10, -0x1p72L, 0);
3851   TEST_ff_f (pow, max_value, max_value, plus_infty);
3852   TEST_ff_f (pow, 10, -max_value, 0);
3853
3854   TEST_ff_f (pow, 0, 1, 0);
3855   TEST_ff_f (pow, 0, 11, 0);
3856
3857   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3858   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3859
3860
3861   TEST_ff_f (pow, 0, 2, 0);
3862   TEST_ff_f (pow, 0, 11.1L, 0);
3863
3864
3865   TEST_ff_f (pow, minus_zero, 2, 0);
3866   TEST_ff_f (pow, minus_zero, 11.1L, 0);
3867   TEST_ff_f (pow, 0, plus_infty, 0);
3868   TEST_ff_f (pow, minus_zero, plus_infty, 0);
3869
3870 #ifndef TEST_INLINE
3871   /* pow (x, +inf) == +inf for |x| > 1.  */
3872   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3873
3874   /* pow (x, +inf) == +0 for |x| < 1.  */
3875   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3876
3877   /* pow (x, -inf) == +0 for |x| > 1.  */
3878   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3879
3880   /* pow (x, -inf) == +inf for |x| < 1.  */
3881   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3882 #endif
3883
3884   /* pow (+inf, y) == +inf for y > 0.  */
3885   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3886
3887   /* pow (+inf, y) == +0 for y < 0.  */
3888   TEST_ff_f (pow, plus_infty, -1, 0.0);
3889
3890   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3891   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3892
3893   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3894   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3895
3896   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3897   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3898   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3899   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3900
3901   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3902   TEST_ff_f (pow, 0.0, 27, 0.0);
3903
3904   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3905   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3906
3907   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3908   TEST_ff_f (pow, 0.0, 4, 0.0);
3909
3910   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3911   TEST_ff_f (pow, minus_zero, 4, 0.0);
3912
3913   TEST_ff_f (pow, 16, 0.25L, 2);
3914   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
3915   TEST_ff_f (pow, 2, 4, 16);
3916   TEST_ff_f (pow, 256, 8, 0x1p64L);
3917
3918   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
3919
3920 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
3921   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3922 #endif
3923
3924   END (pow);
3925 }
3926
3927 static void
3928 remainder_test (void)
3929 {
3930   errno = 0;
3931   FUNC(remainder) (1.625, 1.0);
3932   if (errno == ENOSYS)
3933     /* Function not implemented.  */
3934     return;
3935
3936   START (remainder);
3937
3938   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3939   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3940   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3941   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3942   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3943
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, 1.625, -1.0, -0.375);
3947   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3948   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3949   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3950
3951   END (remainder);
3952 }
3953
3954 #if 0
3955 static void
3956 remquo_test (void)
3957 {
3958   /* x is needed.  */
3959   int x;
3960
3961   errno = 0;
3962   FUNC(remquo) (1.625, 1.0, &x);
3963   if (errno == ENOSYS)
3964     /* Function not implemented.  */
3965     return;
3966
3967   START (remquo);
3968
3969   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3970   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3971   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3972   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3973   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3974
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   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3978   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3979
3980   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3981   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3982
3983   END (remquo);
3984 }
3985 #endif
3986
3987 static void
3988 rint_test (void)
3989 {
3990   START (rint);
3991
3992   TEST_f_f (rint, 0.0, 0.0);
3993   TEST_f_f (rint, minus_zero, minus_zero);
3994   TEST_f_f (rint, plus_infty, plus_infty);
3995   TEST_f_f (rint, minus_infty, minus_infty);
3996
3997   /* Default rounding mode is round to even.  */
3998   TEST_f_f (rint, 0.5, 0.0);
3999   TEST_f_f (rint, 1.5, 2.0);
4000   TEST_f_f (rint, 2.5, 2.0);
4001   TEST_f_f (rint, 3.5, 4.0);
4002   TEST_f_f (rint, 4.5, 4.0);
4003   TEST_f_f (rint, -0.5, -0.0);
4004   TEST_f_f (rint, -1.5, -2.0);
4005   TEST_f_f (rint, -2.5, -2.0);
4006   TEST_f_f (rint, -3.5, -4.0);
4007   TEST_f_f (rint, -4.5, -4.0);
4008 #ifdef TEST_LDOUBLE
4009   /* The result can only be represented in long double.  */
4010   TEST_f_f (rint, 4503599627370495.5L, 4503599627370496.0L);
4011   TEST_f_f (rint, 4503599627370496.25L, 4503599627370496.0L);
4012   TEST_f_f (rint, 4503599627370496.5L, 4503599627370496.0L);
4013   TEST_f_f (rint, 4503599627370496.75L, 4503599627370497.0L);
4014   TEST_f_f (rint, 4503599627370497.5L, 4503599627370498.0L);
4015
4016   TEST_f_f (rint, -4503599627370495.5L, -4503599627370496.0L);
4017   TEST_f_f (rint, -4503599627370496.25L, -4503599627370496.0L);
4018   TEST_f_f (rint, -4503599627370496.5L, -4503599627370496.0L);
4019   TEST_f_f (rint, -4503599627370496.75L, -4503599627370497.0L);
4020   TEST_f_f (rint, -4503599627370497.5L, -4503599627370498.0L);
4021
4022   TEST_f_f (rint, 9007199254740991.5L, 9007199254740992.0L);
4023   TEST_f_f (rint, 9007199254740992.25L, 9007199254740992.0L);
4024   TEST_f_f (rint, 9007199254740992.5L, 9007199254740992.0L);
4025   TEST_f_f (rint, 9007199254740992.75L, 9007199254740993.0L);
4026   TEST_f_f (rint, 9007199254740993.5L, 9007199254740994.0L);
4027
4028   TEST_f_f (rint, -9007199254740991.5L, -9007199254740992.0L);
4029   TEST_f_f (rint, -9007199254740992.25L, -9007199254740992.0L);
4030   TEST_f_f (rint, -9007199254740992.5L, -9007199254740992.0L);
4031   TEST_f_f (rint, -9007199254740992.75L, -9007199254740993.0L);
4032   TEST_f_f (rint, -9007199254740993.5L, -9007199254740994.0L);
4033
4034   TEST_f_f (rint, 72057594037927935.5L, 72057594037927936.0L);
4035   TEST_f_f (rint, 72057594037927936.25L, 72057594037927936.0L);
4036   TEST_f_f (rint, 72057594037927936.5L, 72057594037927936.0L);
4037   TEST_f_f (rint, 72057594037927936.75L, 72057594037927937.0L);
4038   TEST_f_f (rint, 72057594037927937.5L, 72057594037927938.0L);
4039
4040   TEST_f_f (rint, -72057594037927935.5L, -72057594037927936.0L);
4041   TEST_f_f (rint, -72057594037927936.25L, -72057594037927936.0L);
4042   TEST_f_f (rint, -72057594037927936.5L, -72057594037927936.0L);
4043   TEST_f_f (rint, -72057594037927936.75L, -72057594037927937.0L);
4044   TEST_f_f (rint, -72057594037927937.5L, -72057594037927938.0L);
4045
4046   TEST_f_f (rint, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
4047   TEST_f_f (rint, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4048   TEST_f_f (rint, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4049   TEST_f_f (rint, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
4050   TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
4051 #endif
4052
4053   END (rint);
4054 }
4055
4056 #if 0
4057 static void
4058 rint_test_tonearest (void)
4059 {
4060   int save_round_mode;
4061   START (rint_tonearest);
4062
4063   save_round_mode = fegetround();
4064
4065   if (!fesetround (FE_TONEAREST))
4066   {
4067     TEST_f_f (rint, 2.0, 2.0);
4068     TEST_f_f (rint, 1.5, 2.0);
4069     TEST_f_f (rint, 1.0, 1.0);
4070     TEST_f_f (rint, 0.5, 0.0);
4071     TEST_f_f (rint, 0.0, 0.0);
4072     TEST_f_f (rint, minus_zero, minus_zero);
4073     TEST_f_f (rint, -0.5, -0.0);
4074     TEST_f_f (rint, -1.0, -1.0);
4075     TEST_f_f (rint, -1.5, -2.0);
4076     TEST_f_f (rint, -2.0, -2.0);
4077   }
4078
4079   fesetround(save_round_mode);
4080
4081   END (rint_tonearest);
4082 }
4083
4084 static void
4085 rint_test_towardzero (void)
4086 {
4087   int save_round_mode;
4088   START (rint_towardzero);
4089
4090   save_round_mode = fegetround();
4091
4092   if (!fesetround (FE_TOWARDZERO))
4093   {
4094     TEST_f_f (rint, 2.0, 2.0);
4095     TEST_f_f (rint, 1.5, 1.0);
4096     TEST_f_f (rint, 1.0, 1.0);
4097     TEST_f_f (rint, 0.5, 0.0);
4098     TEST_f_f (rint, 0.0, 0.0);
4099     TEST_f_f (rint, minus_zero, minus_zero);
4100     TEST_f_f (rint, -0.5, -0.0);
4101     TEST_f_f (rint, -1.0, -1.0);
4102     TEST_f_f (rint, -1.5, -1.0);
4103     TEST_f_f (rint, -2.0, -2.0);
4104   }
4105
4106   fesetround(save_round_mode);
4107
4108   END (rint_towardzero);
4109 }
4110
4111 static void
4112 rint_test_downward (void)
4113 {
4114   int save_round_mode;
4115   START (rint_downward);
4116
4117   save_round_mode = fegetround();
4118
4119   if (!fesetround (FE_DOWNWARD))
4120   {
4121     TEST_f_f (rint, 2.0, 2.0);
4122     TEST_f_f (rint, 1.5, 1.0);
4123     TEST_f_f (rint, 1.0, 1.0);
4124     TEST_f_f (rint, 0.5, 0.0);
4125     TEST_f_f (rint, 0.0, 0.0);
4126     TEST_f_f (rint, minus_zero, minus_zero);
4127     TEST_f_f (rint, -0.5, -1.0);
4128     TEST_f_f (rint, -1.0, -1.0);
4129     TEST_f_f (rint, -1.5, -2.0);
4130     TEST_f_f (rint, -2.0, -2.0);
4131   }
4132
4133   fesetround(save_round_mode);
4134
4135   END (rint_downward);
4136 }
4137
4138 static void
4139 rint_test_upward (void)
4140 {
4141   int save_round_mode;
4142   START (rint_upward);
4143
4144   save_round_mode = fegetround();
4145
4146   if (!fesetround (FE_UPWARD))
4147   {
4148     TEST_f_f (rint, 2.0, 2.0);
4149     TEST_f_f (rint, 1.5, 2.0);
4150     TEST_f_f (rint, 1.0, 1.0);
4151     TEST_f_f (rint, 0.5, 1.0);
4152     TEST_f_f (rint, 0.0, 0.0);
4153     TEST_f_f (rint, minus_zero, minus_zero);
4154     TEST_f_f (rint, -0.5, -0.0);
4155     TEST_f_f (rint, -1.0, -1.0);
4156     TEST_f_f (rint, -1.5, -1.0);
4157     TEST_f_f (rint, -2.0, -2.0);
4158   }
4159
4160   fesetround(save_round_mode);
4161
4162   END (rint_upward);
4163 }
4164
4165 static void
4166 round_test (void)
4167 {
4168   START (round);
4169
4170   TEST_f_f (round, 0, 0);
4171   TEST_f_f (round, minus_zero, minus_zero);
4172   TEST_f_f (round, 0.2L, 0.0);
4173   TEST_f_f (round, -0.2L, minus_zero);
4174   TEST_f_f (round, 0.5, 1.0);
4175   TEST_f_f (round, -0.5, -1.0);
4176   TEST_f_f (round, 0.8L, 1.0);
4177   TEST_f_f (round, -0.8L, -1.0);
4178   TEST_f_f (round, 1.5, 2.0);
4179   TEST_f_f (round, -1.5, -2.0);
4180   TEST_f_f (round, 2097152.5, 2097153);
4181   TEST_f_f (round, -2097152.5, -2097153);
4182
4183 #ifdef TEST_LDOUBLE
4184   /* The result can only be represented in long double.  */
4185   TEST_f_f (round, 4503599627370495.5L, 4503599627370496.0L);
4186   TEST_f_f (round, 4503599627370496.25L, 4503599627370496.0L);
4187   TEST_f_f (round, 4503599627370496.5L, 4503599627370497.0L);
4188   TEST_f_f (round, 4503599627370496.75L, 4503599627370497.0L);
4189   TEST_f_f (round, 4503599627370497.5L, 4503599627370498.0L);
4190
4191   TEST_f_f (round, -4503599627370495.5L, -4503599627370496.0L);
4192   TEST_f_f (round, -4503599627370496.25L, -4503599627370496.0L);
4193   TEST_f_f (round, -4503599627370496.5L, -4503599627370497.0L);
4194   TEST_f_f (round, -4503599627370496.75L, -4503599627370497.0L);
4195   TEST_f_f (round, -4503599627370497.5L, -4503599627370498.0L);
4196
4197   TEST_f_f (round, 9007199254740991.5L, 9007199254740992.0L);
4198   TEST_f_f (round, 9007199254740992.25L, 9007199254740992.0L);
4199   TEST_f_f (round, 9007199254740992.5L, 9007199254740993.0L);
4200   TEST_f_f (round, 9007199254740992.75L, 9007199254740993.0L);
4201   TEST_f_f (round, 9007199254740993.5L, 9007199254740994.0L);
4202
4203   TEST_f_f (round, -9007199254740991.5L, -9007199254740992.0L);
4204   TEST_f_f (round, -9007199254740992.25L, -9007199254740992.0L);
4205   TEST_f_f (round, -9007199254740992.5L, -9007199254740993.0L);
4206   TEST_f_f (round, -9007199254740992.75L, -9007199254740993.0L);
4207   TEST_f_f (round, -9007199254740993.5L, -9007199254740994.0L);
4208
4209   TEST_f_f (round, 72057594037927935.5L, 72057594037927936.0L);
4210   TEST_f_f (round, 72057594037927936.25L, 72057594037927936.0L);
4211   TEST_f_f (round, 72057594037927936.5L, 72057594037927937.0L);
4212   TEST_f_f (round, 72057594037927936.75L, 72057594037927937.0L);
4213   TEST_f_f (round, 72057594037927937.5L, 72057594037927938.0L);
4214
4215   TEST_f_f (round, -72057594037927935.5L, -72057594037927936.0L);
4216   TEST_f_f (round, -72057594037927936.25L, -72057594037927936.0L);
4217   TEST_f_f (round, -72057594037927936.5L, -72057594037927937.0L);
4218   TEST_f_f (round, -72057594037927936.75L, -72057594037927937.0L);
4219   TEST_f_f (round, -72057594037927937.5L, -72057594037927938.0L);
4220
4221   TEST_f_f (round, 10141204801825835211973625643007.5L, 10141204801825835211973625643008.0L);
4222   TEST_f_f (round, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4223   TEST_f_f (round, 10141204801825835211973625643008.5L, 10141204801825835211973625643009.0L);
4224   TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L);
4225   TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L);
4226 #endif
4227
4228   END (round);
4229 }
4230 #endif
4231
4232
4233 static void
4234 scalb_test (void)
4235 {
4236   START (scalb);
4237 #ifndef TEST_LDOUBLE /* uclibc doesn't have scalbl */
4238 #ifdef __UCLIBC_SUSV3_LEGACY__ /* scalbf is susv3 legacy */
4239
4240   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
4241   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
4242
4243   TEST_ff_f (scalb, 0, nan_value, nan_value);
4244   TEST_ff_f (scalb, 1, nan_value, nan_value);
4245
4246   TEST_ff_f (scalb, 1, 0, 1);
4247   TEST_ff_f (scalb, -1, 0, -1);
4248
4249   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
4250   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
4251
4252   TEST_ff_f (scalb, 0, 2, 0);
4253   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
4254   TEST_ff_f (scalb, 0, 0, 0);
4255   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
4256   TEST_ff_f (scalb, 0, -1, 0);
4257   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
4258   TEST_ff_f (scalb, 0, minus_infty, 0);
4259   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
4260
4261   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
4262   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
4263   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
4264   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
4265   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
4266   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
4267
4268   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
4269   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
4270
4271   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
4272   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
4273   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
4274   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
4275
4276   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4277   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
4278
4279   TEST_ff_f (scalb, nan_value, 1, nan_value);
4280   TEST_ff_f (scalb, 1, nan_value, nan_value);
4281   TEST_ff_f (scalb, nan_value, 0, nan_value);
4282   TEST_ff_f (scalb, 0, nan_value, nan_value);
4283   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
4284   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
4285   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
4286
4287   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
4288   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
4289 #endif /* __UCLIBC_SUSV3_LEGACY__ */
4290 #endif /* TEST_LDOUBLE */
4291   END (scalb);
4292 }
4293
4294
4295 static void
4296 scalbn_test (void)
4297 {
4298
4299   START (scalbn);
4300
4301   TEST_fi_f (scalbn, 0, 0, 0);
4302   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
4303
4304   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
4305   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
4306   TEST_fi_f (scalbn, nan_value, 1, nan_value);
4307
4308   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
4309   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
4310
4311   TEST_fi_f (scalbn, 1, 0L, 1);
4312
4313   END (scalbn);
4314 }
4315
4316
4317 #if 0
4318 static void
4319 scalbln_test (void)
4320 {
4321
4322   START (scalbln);
4323
4324   TEST_fl_f (scalbln, 0, 0, 0);
4325   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
4326
4327   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
4328   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
4329   TEST_fl_f (scalbln, nan_value, 1, nan_value);
4330
4331   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
4332   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
4333
4334   TEST_fl_f (scalbln, 1, 0L, 1);
4335
4336   END (scalbn);
4337 }
4338 #endif
4339
4340
4341 static void
4342 signbit_test (void)
4343 {
4344
4345   START (signbit);
4346
4347   TEST_f_b (signbit, 0, 0);
4348   TEST_f_b (signbit, minus_zero, 1);
4349   TEST_f_b (signbit, plus_infty, 0);
4350   TEST_f_b (signbit, minus_infty, 1);
4351
4352   /* signbit (x) != 0 for x < 0.  */
4353   TEST_f_b (signbit, -1, 1);
4354   /* signbit (x) == 0 for x >= 0.  */
4355   TEST_f_b (signbit, 1, 0);
4356
4357   END (signbit);
4358 }
4359
4360
4361 static void
4362 sin_test (void)
4363 {
4364   errno = 0;
4365   FUNC(sin) (0);
4366   if (errno == ENOSYS)
4367     /* Function not implemented.  */
4368     return;
4369
4370   START (sin);
4371
4372   TEST_f_f (sin, 0, 0);
4373   TEST_f_f (sin, minus_zero, minus_zero);
4374   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
4375   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
4376   TEST_f_f (sin, nan_value, nan_value);
4377
4378   TEST_f_f (sin, M_PI_6l, 0.5);
4379   TEST_f_f (sin, -M_PI_6l, -0.5);
4380   TEST_f_f (sin, M_PI_2l, 1);
4381   TEST_f_f (sin, -M_PI_2l, -1);
4382   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
4383
4384 #ifdef TEST_DOUBLE
4385   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
4386 #endif
4387
4388   END (sin);
4389
4390 }
4391
4392
4393 #if 0
4394 static void
4395 sincos_test (void)
4396 {
4397   FLOAT sin_res, cos_res;
4398
4399   errno = 0;
4400   FUNC(sincos) (0, &sin_res, &cos_res);
4401   if (errno == ENOSYS)
4402     /* Function not implemented.  */
4403     return;
4404
4405   START (sincos);
4406
4407   /* sincos is treated differently because it returns void.  */
4408   TEST_extra (sincos, 0, 0, 1);
4409
4410   TEST_extra (sincos, minus_zero, minus_zero, 1);
4411   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4412   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4413   TEST_extra (sincos, nan_value, nan_value, nan_value);
4414
4415   TEST_extra (sincos, M_PI_2l, 1, 0);
4416   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
4417   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
4418   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
4419
4420 #ifdef TEST_DOUBLE
4421   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
4422 #endif
4423
4424   END (sincos);
4425 }
4426 #endif
4427
4428 static void
4429 sinh_test (void)
4430 {
4431   errno = 0;
4432   FUNC(sinh) (0.7L);
4433   if (errno == ENOSYS)
4434     /* Function not implemented.  */
4435     return;
4436
4437   START (sinh);
4438   TEST_f_f (sinh, 0, 0);
4439   TEST_f_f (sinh, minus_zero, minus_zero);
4440
4441 #ifndef TEST_INLINE
4442   TEST_f_f (sinh, plus_infty, plus_infty);
4443   TEST_f_f (sinh, minus_infty, minus_infty);
4444 #endif
4445   TEST_f_f (sinh, nan_value, nan_value);
4446
4447   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
4448   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
4449
4450   END (sinh);
4451 }
4452
4453 static void
4454 sqrt_test (void)
4455 {
4456   errno = 0;
4457   FUNC(sqrt) (1);
4458   if (errno == ENOSYS)
4459     /* Function not implemented.  */
4460     return;
4461
4462   START (sqrt);
4463
4464   TEST_f_f (sqrt, 0, 0);
4465   TEST_f_f (sqrt, nan_value, nan_value);
4466   TEST_f_f (sqrt, plus_infty, plus_infty);
4467
4468   TEST_f_f (sqrt, minus_zero, minus_zero);
4469
4470   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
4471   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
4472   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
4473   TEST_f_f (sqrt, nan_value, nan_value);
4474
4475   TEST_f_f (sqrt, 2209, 47);
4476   TEST_f_f (sqrt, 4, 2);
4477   TEST_f_f (sqrt, 2, M_SQRT2l);
4478   TEST_f_f (sqrt, 0.25, 0.5);
4479   TEST_f_f (sqrt, 6642.25, 81.5);
4480   TEST_f_f (sqrt, 15190.5625L, 123.25L);
4481   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
4482
4483   END (sqrt);
4484 }
4485
4486
4487 static void
4488 tan_test (void)
4489 {
4490   errno = 0;
4491   FUNC(tan) (0);
4492   if (errno == ENOSYS)
4493     /* Function not implemented.  */
4494     return;
4495
4496   START (tan);
4497
4498   TEST_f_f (tan, 0, 0);
4499   TEST_f_f (tan, minus_zero, minus_zero);
4500   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
4501   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
4502   TEST_f_f (tan, nan_value, nan_value);
4503
4504   TEST_f_f (tan, M_PI_4l, 1);
4505   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
4506
4507   END (tan);
4508 }
4509
4510 static void
4511 tanh_test (void)
4512 {
4513   errno = 0;
4514   FUNC(tanh) (0.7L);
4515   if (errno == ENOSYS)
4516     /* Function not implemented.  */
4517     return;
4518
4519   START (tanh);
4520
4521   TEST_f_f (tanh, 0, 0);
4522   /* vda: uclibc: added IGNORE_ZERO_INF_SIGN to treat -0 as ok */
4523   TEST_f_f (tanh, minus_zero, minus_zero, IGNORE_ZERO_INF_SIGN);
4524
4525 #ifndef TEST_INLINE
4526   TEST_f_f (tanh, plus_infty, 1);
4527   TEST_f_f (tanh, minus_infty, -1);
4528 #endif
4529   TEST_f_f (tanh, nan_value, nan_value);
4530
4531   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
4532   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
4533
4534   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
4535   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
4536
4537   /* 2^-57  */
4538   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
4539
4540   END (tanh);
4541 }
4542
4543 #if 0
4544 static void
4545 tgamma_test (void)
4546 {
4547   errno = 0;
4548   FUNC(tgamma) (1);
4549   if (errno == ENOSYS)
4550     /* Function not implemented.  */
4551     return;
4552   feclearexcept (FE_ALL_EXCEPT);
4553
4554   START (tgamma);
4555
4556   TEST_f_f (tgamma, plus_infty, plus_infty);
4557   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4558   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4559   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
4560   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
4561   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
4562   TEST_f_f (tgamma, nan_value, nan_value);
4563
4564   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
4565   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
4566
4567   TEST_f_f (tgamma, 1, 1);
4568   TEST_f_f (tgamma, 4, 6);
4569
4570   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
4571   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
4572
4573   END (tgamma);
4574 }
4575 #endif
4576
4577
4578 #if 0
4579 static void
4580 trunc_test (void)
4581 {
4582   START (trunc);
4583
4584   TEST_f_f (trunc, plus_infty, plus_infty);
4585   TEST_f_f (trunc, minus_infty, minus_infty);
4586   TEST_f_f (trunc, nan_value, nan_value);
4587
4588   TEST_f_f (trunc, 0, 0);
4589   TEST_f_f (trunc, minus_zero, minus_zero);
4590   TEST_f_f (trunc, 0.625, 0);
4591   TEST_f_f (trunc, -0.625, minus_zero);
4592   TEST_f_f (trunc, 1, 1);
4593   TEST_f_f (trunc, -1, -1);
4594   TEST_f_f (trunc, 1.625, 1);
4595   TEST_f_f (trunc, -1.625, -1);
4596
4597   TEST_f_f (trunc, 1048580.625L, 1048580L);
4598   TEST_f_f (trunc, -1048580.625L, -1048580L);
4599
4600   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
4601   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
4602
4603   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
4604   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
4605
4606 #ifdef TEST_LDOUBLE
4607   /* The result can only be represented in long double.  */
4608   TEST_f_f (trunc, 4503599627370495.5L, 4503599627370495.0L);
4609   TEST_f_f (trunc, 4503599627370496.25L, 4503599627370496.0L);
4610   TEST_f_f (trunc, 4503599627370496.5L, 4503599627370496.0L);
4611   TEST_f_f (trunc, 4503599627370496.75L, 4503599627370496.0L);
4612   TEST_f_f (trunc, 4503599627370497.5L, 4503599627370497.0L);
4613
4614   TEST_f_f (trunc, -4503599627370495.5L, -4503599627370495.0L);
4615   TEST_f_f (trunc, -4503599627370496.25L, -4503599627370496.0L);
4616   TEST_f_f (trunc, -4503599627370496.5L, -4503599627370496.0L);
4617   TEST_f_f (trunc, -4503599627370496.75L, -4503599627370496.0L);
4618   TEST_f_f (trunc, -4503599627370497.5L, -4503599627370497.0L);
4619
4620   TEST_f_f (trunc, 9007199254740991.5L, 9007199254740991.0L);
4621   TEST_f_f (trunc, 9007199254740992.25L, 9007199254740992.0L);
4622   TEST_f_f (trunc, 9007199254740992.5L, 9007199254740992.0L);
4623   TEST_f_f (trunc, 9007199254740992.75L, 9007199254740992.0L);
4624   TEST_f_f (trunc, 9007199254740993.5L, 9007199254740993.0L);
4625
4626   TEST_f_f (trunc, -9007199254740991.5L, -9007199254740991.0L);
4627   TEST_f_f (trunc, -9007199254740992.25L, -9007199254740992.0L);
4628   TEST_f_f (trunc, -9007199254740992.5L, -9007199254740992.0L);
4629   TEST_f_f (trunc, -9007199254740992.75L, -9007199254740992.0L);
4630   TEST_f_f (trunc, -9007199254740993.5L, -9007199254740993.0L);
4631
4632   TEST_f_f (trunc, 72057594037927935.5L, 72057594037927935.0L);
4633   TEST_f_f (trunc, 72057594037927936.25L, 72057594037927936.0L);
4634   TEST_f_f (trunc, 72057594037927936.5L, 72057594037927936.0L);
4635   TEST_f_f (trunc, 72057594037927936.75L, 72057594037927936.0L);
4636   TEST_f_f (trunc, 72057594037927937.5L, 72057594037927937.0L);
4637
4638   TEST_f_f (trunc, -72057594037927935.5L, -72057594037927935.0L);
4639   TEST_f_f (trunc, -72057594037927936.25L, -72057594037927936.0L);
4640   TEST_f_f (trunc, -72057594037927936.5L, -72057594037927936.0L);
4641   TEST_f_f (trunc, -72057594037927936.75L, -72057594037927936.0L);
4642   TEST_f_f (trunc, -72057594037927937.5L, -72057594037927937.0L);
4643
4644   TEST_f_f (trunc, 10141204801825835211973625643007.5L, 10141204801825835211973625643007.0L);
4645   TEST_f_f (trunc, 10141204801825835211973625643008.25L, 10141204801825835211973625643008.0L);
4646   TEST_f_f (trunc, 10141204801825835211973625643008.5L, 10141204801825835211973625643008.0L);
4647   TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L);
4648   TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L);
4649 #endif
4650
4651   END (trunc);
4652 }
4653 #endif
4654
4655 #if defined __DO_XSI_MATH__
4656 static void
4657 y0_test (void)
4658 {
4659   errno = 0;
4660 #if 0
4661   FLOAT s, c;
4662   FUNC (sincos) (0, &s, &c);
4663   if (errno == ENOSYS)
4664     /* Required function not implemented.  */
4665     return;
4666 #endif
4667   FUNC(y0) (1);
4668   if (errno == ENOSYS)
4669     /* Function not implemented.  */
4670     return;
4671
4672   /* y0 is the Bessel function of the second kind of order 0 */
4673   START (y0);
4674
4675   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
4676   TEST_f_f (y0, 0.0, minus_infty);
4677   TEST_f_f (y0, nan_value, nan_value);
4678   TEST_f_f (y0, plus_infty, 0);
4679
4680   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
4681   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
4682   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
4683   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
4684   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
4685   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
4686   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
4687
4688   END (y0);
4689 }
4690
4691
4692 static void
4693 y1_test (void)
4694 {
4695   errno = 0;
4696 #if 0
4697   FLOAT s, c;
4698   FUNC (sincos) (0, &s, &c);
4699   if (errno == ENOSYS)
4700     /* Required function not implemented.  */
4701     return;
4702 #endif
4703   FUNC(y1) (1);
4704   if (errno == ENOSYS)
4705     /* Function not implemented.  */
4706     return;
4707
4708   /* y1 is the Bessel function of the second kind of order 1 */
4709   START (y1);
4710
4711   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
4712   TEST_f_f (y1, 0.0, minus_infty);
4713   TEST_f_f (y1, plus_infty, 0);
4714   TEST_f_f (y1, nan_value, nan_value);
4715
4716   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
4717   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
4718   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
4719   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
4720   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
4721   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
4722   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
4723
4724   END (y1);
4725 }
4726
4727
4728 static void
4729 yn_test (void)
4730 {
4731   errno = 0;
4732 #if 0
4733   FLOAT s, c;
4734   FUNC (sincos) (0, &s, &c);
4735   if (errno == ENOSYS)
4736     /* Required function not implemented.  */
4737     return;
4738 #endif
4739   FUNC(yn) (1, 1);
4740   if (errno == ENOSYS)
4741     /* Function not implemented.  */
4742     return;
4743
4744   /* yn is the Bessel function of the second kind of order n */
4745   START (yn);
4746
4747   /* yn (0, x) == y0 (x)  */
4748   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
4749   TEST_ff_f (yn, 0, 0.0, minus_infty);
4750   TEST_ff_f (yn, 0, nan_value, nan_value);
4751   TEST_ff_f (yn, 0, plus_infty, 0);
4752
4753   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
4754   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
4755   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
4756   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
4757   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
4758   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
4759   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
4760
4761   /* yn (1, x) == y1 (x)  */
4762   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
4763   TEST_ff_f (yn, 1, 0.0, minus_infty);
4764   TEST_ff_f (yn, 1, plus_infty, 0);
4765   TEST_ff_f (yn, 1, nan_value, nan_value);
4766
4767   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
4768   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
4769   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
4770   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
4771   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
4772   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
4773   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
4774
4775   /* yn (3, x)  */
4776   TEST_ff_f (yn, 3, plus_infty, 0);
4777   TEST_ff_f (yn, 3, nan_value, nan_value);
4778
4779   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
4780   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
4781   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
4782   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
4783   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
4784
4785   /* yn (10, x)  */
4786   TEST_ff_f (yn, 10, plus_infty, 0);
4787   TEST_ff_f (yn, 10, nan_value, nan_value);
4788
4789   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
4790   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
4791   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
4792   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
4793   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
4794
4795   END (yn);
4796
4797 }
4798 #endif /* __DO_XSI_MATH__ */
4799
4800
4801 static void
4802 significand_test (void)
4803 {
4804   /* significand returns the mantissa of the exponential representation.  */
4805   START (significand);
4806
4807   TEST_f_f (significand, 4.0, 1.0);
4808   TEST_f_f (significand, 6.0, 1.5);
4809   TEST_f_f (significand, 8.0, 1.0);
4810
4811   END (significand);
4812 }
4813
4814
4815 static void
4816 initialize (void)
4817 {
4818   fpstack_test ("start *init*");
4819   plus_zero = 0.0;
4820   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
4821
4822   minus_zero = FUNC(copysign) (0.0, -1.0);
4823   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
4824                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
4825   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
4826                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
4827   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4828                       LDBL_MAX, DBL_MAX, FLT_MAX);
4829   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
4830                       LDBL_MIN, DBL_MIN, FLT_MIN);
4831
4832   (void) &plus_zero;
4833   (void) &nan_value;
4834   (void) &minus_zero;
4835   (void) &plus_infty;
4836   (void) &minus_infty;
4837   (void) &max_value;
4838   (void) &min_value;
4839
4840   /* Clear all exceptions.  From now on we must not get random exceptions.  */
4841   feclearexcept (FE_ALL_EXCEPT);
4842
4843   /* Test to make sure we start correctly.  */
4844   fpstack_test ("end *init*");
4845 }
4846
4847 #if 0
4848 /* function to check our ulp calculation.  */
4849 void
4850 check_ulp (void)
4851 {
4852   int i;
4853
4854   FLOAT u, diff, ulp;
4855   /* This gives one ulp.  */
4856   u = FUNC(nextafter) (10, 20);
4857   check_equal (10.0, u, 1, &diff, &ulp);
4858   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
4859
4860   /* This gives one more ulp.  */
4861   u = FUNC(nextafter) (u, 20);
4862   check_equal (10.0, u, 2, &diff, &ulp);
4863   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
4864
4865   /* And now calculate 100 ulp.  */
4866   for (i = 2; i < 100; i++)
4867     u = FUNC(nextafter) (u, 20);
4868   check_equal (10.0, u, 100, &diff, &ulp);
4869   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
4870 }
4871 #endif
4872
4873 int
4874 main (int argc, char **argv)
4875 {
4876
4877   int key;
4878
4879   verbose = 1;
4880   output_ulps = 0;
4881   output_max_error = 1;
4882   output_points = 1;
4883   /* XXX set to 0 for releases.  */
4884   ignore_max_ulp = 0;
4885
4886   /* Parse and process arguments.  */
4887   while ((key = getopt(argc, argv, "fi:puv")) > 0) {
4888       switch (key)
4889       {
4890           case 'f':
4891               output_max_error = 0;
4892               break;
4893           case 'i':
4894               if (strcmp (optarg, "yes") == 0)
4895                   ignore_max_ulp = 1;
4896               else if (strcmp (optarg, "no") == 0)
4897                   ignore_max_ulp = 0;
4898               break;
4899           case 'p':
4900               output_points = 0;
4901               break;
4902           case 'u':
4903               output_ulps = 1;
4904               break;
4905           case 'v':
4906               verbose = 3;
4907               break;
4908           default:
4909               fprintf (stderr, "Unknown argument: %c", key);
4910               exit (EXIT_FAILURE);
4911       }
4912   }
4913
4914   if (optind != argc)
4915     {
4916       fprintf (stderr, "wrong number of arguments");
4917       exit (EXIT_FAILURE);
4918     }
4919
4920   if (output_ulps)
4921     {
4922       ulps_file = fopen ("ULPs", "a");
4923       if (ulps_file == NULL)
4924         {
4925           perror ("can't open file `ULPs' for writing: ");
4926           exit (1);
4927         }
4928     }
4929
4930
4931   initialize ();
4932   printf (TEST_MSG);
4933
4934 #if 0
4935   check_ulp ();
4936 #endif
4937
4938   /* Keep the tests a wee bit ordered (according to ISO C99).  */
4939   /* Classification macros:  */
4940   fpclassify_test ();
4941   isfinite_test ();
4942   isnormal_test ();
4943   signbit_test ();
4944
4945   /* Trigonometric functions:  */
4946   acos_test ();
4947   asin_test ();
4948   atan_test ();
4949   atan2_test ();
4950   cos_test ();
4951   sin_test ();
4952 #if 0
4953   sincos_test ();
4954 #endif
4955   tan_test ();
4956
4957   /* Hyperbolic functions:  */
4958   acosh_test ();
4959   asinh_test ();
4960   atanh_test ();
4961   cosh_test ();
4962   sinh_test ();
4963   tanh_test ();
4964
4965   /* Exponential and logarithmic functions:  */
4966   exp_test ();
4967 #if 0
4968   exp10_test ();
4969   exp2_test ();
4970 #endif
4971   expm1_test ();
4972   frexp_test ();
4973   ldexp_test ();
4974   log_test ();
4975   log10_test ();
4976   log1p_test ();
4977 #if 0
4978   log2_test ();
4979 #endif
4980   logb_test ();
4981   modf_test ();
4982   ilogb_test ();
4983   scalb_test ();
4984   scalbn_test ();
4985 #if 0
4986   scalbln_test ();
4987 #endif
4988   significand_test ();
4989
4990   /* Power and absolute value functions:  */
4991   cbrt_test ();
4992   fabs_test ();
4993   hypot_test ();
4994   pow_test ();
4995   sqrt_test ();
4996
4997   /* Error and gamma functions:  */
4998   erf_test ();
4999   erfc_test ();
5000   gamma_test ();
5001   lgamma_test ();
5002 #if 0
5003   tgamma_test ();
5004 #endif
5005
5006   /* Nearest integer functions:  */
5007   ceil_test ();
5008   floor_test ();
5009 #if 0
5010   nearbyint_test ();
5011 #endif
5012   rint_test ();
5013 #if 0
5014   rint_test_tonearest ();
5015   rint_test_towardzero ();
5016   rint_test_downward ();
5017   rint_test_upward ();
5018   lrint_test ();
5019   llrint_test ();
5020   round_test ();
5021   lround_test ();
5022   llround_test ();
5023   trunc_test ();
5024 #endif
5025
5026   /* Remainder functions:  */
5027   fmod_test ();
5028   remainder_test ();
5029 #if 0
5030   remquo_test ();
5031 #endif
5032
5033   /* Manipulation functions:  */
5034   copysign_test ();
5035 #if 0
5036   nextafter_test ();
5037   nexttoward_test ();
5038
5039   /* maximum, minimum and positive difference functions */
5040   fdim_test ();
5041   fmax_test ();
5042   fmin_test ();
5043
5044   /* Multiply and add:  */
5045   fma_test ();
5046
5047   /* Complex functions:  */
5048   cabs_test ();
5049   cacos_test ();
5050   cacosh_test ();
5051   carg_test ();
5052   casin_test ();
5053   casinh_test ();
5054   catan_test ();
5055   catanh_test ();
5056   ccos_test ();
5057   ccosh_test ();
5058   cexp_test ();
5059   cimag_test ();
5060   clog10_test ();
5061   clog_test ();
5062 #if 0
5063   conj_test ();
5064 #endif
5065   cpow_test ();
5066   cproj_test ();
5067   creal_test ();
5068   csin_test ();
5069   csinh_test ();
5070   csqrt_test ();
5071   ctan_test ();
5072   ctanh_test ();
5073 #endif
5074
5075   /* Bessel functions:  */
5076 #if defined __DO_XSI_MATH__
5077   j0_test ();
5078   j1_test ();
5079   jn_test ();
5080   y0_test ();
5081   y1_test ();
5082   yn_test ();
5083 #endif /* __DO_XSI_MATH__ */
5084
5085   if (output_ulps)
5086     fclose (ulps_file);
5087
5088   printf ("\nTest suite completed:\n");
5089   printf ("  %d test cases plus %d tests for exception flags executed.\n",
5090           noTests, noExcTests);
5091   if (noXFails)
5092     printf ("  %d expected failures occurred.\n", noXFails);
5093   if (noXPasses)
5094     printf ("  %d unexpected passes occurred.\n", noXPasses);
5095   if (noErrors)
5096     {
5097       printf ("  %d errors occurred.\n", noErrors);
5098       return 1;
5099     }
5100   printf ("  All tests passed successfully.\n");
5101
5102   return 0;
5103 }
5104
5105 /*
5106  * Local Variables:
5107  * mode:c
5108  * End:
5109  */