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