math/libm-test.inc

   1 /* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@arthur.rhein-neckar.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 Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    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    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 /* Part of testsuite for libm.
  21
  22    This file is processed by a perl script.  The resulting file has to
  23    be included by a master file that defines:
  24
  25    Makros:
  26    FUNC(function): converts general function name (like cos) to
  27    name with correct suffix (e.g. cosl or cosf)
  28    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
  29    FLOAT:          floating point type to test
  30    - TEST_MSG:     informal message to be displayed
  31    CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):
  32    chooses one of the parameters as delta for testing
  33    equality
  34    PRINTF_EXPR     Floating point conversion specification to print a variable
  35    of type FLOAT with printf.  PRINTF_EXPR just contains
  36    the specifier, not the percent and width arguments,
  37    e.g. "f".
  38    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
  39    PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */
  40
  41 /* This testsuite has currently tests for:
  42    acos, acosh, asin, asinh, atan, atan2, atanh,
  43    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
  44    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
  45    frexp, gamma, hypot,
  46    ilogb, isfinite, isinf, isnan, isnormal,
  47    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
  48    j0, j1, jn,
  49    ldexp, lgamma, log, log10, log1p, log2, logb,
  50    modf, nearbyint, nextafter,
  51    pow, remainder, remquo, rint, lrint, llrint,
  52    round, lround, llround,
  53    scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,
  54    y0, y1, yn
  55
  56    and for the following complex math functions:
  57    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
  58    ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.
  59
  60    At the moment the following functions aren't tested:
  61    drem, significand, nan
  62
  63    Parameter handling is primitive in the moment:
  64    --verbose=[0..3] for different levels of output:
  65    0: only error count
  66    1: basic report on failed tests (default)
  67    2: full report on all tests
  68    -v for full output (equals --verbose=3)
  69    -u for generation of an ULPs file
  70  */
  71
  72 /* "Philosophy":
  73
  74    This suite tests some aspects of the correct implementation of
  75    mathematical functions in libm.  Some simple, specific parameters
  76    are tested for correctness but there's no exhaustive
  77    testing.  Handling of specific inputs (e.g. infinity, not-a-number)
  78    is also tested.  Correct handling of exceptions is checked
  79    against.  These implemented tests should check all cases that are
  80    specified in ISO C99.
  81
  82    Exception testing: At the moment only divide-by-zero and invalid
  83    exceptions are tested.  Overflow/underflow and inexact exceptions
  84    aren't checked at the moment.
  85
  86    NaN values: There exist signalling and quiet NaNs.  This implementation
  87    only uses signalling NaN as parameter but does not differenciate
  88    between the two kinds of NaNs as result.
  89
  90    Inline functions: Inlining functions should give an improvement in
  91    speed - but not in precission.  The inlined functions return
  92    reasonable values for a reasonable range of input values.  The
  93    result is not necessarily correct for all values and exceptions are
  94    not correctly raised in all cases.  Problematic input and return
  95    values are infinity, not-a-number and minus zero.  This suite
  96    therefore does not check these specific inputs and the exception
  97    handling for inlined mathematical functions - just the "reasonable"
  98    values are checked.
  99
 100    Beware: The tests might fail for any of the following reasons:
 101    - Tests are wrong
 102    - Functions are wrong
 103    - Floating Point Unit not working properly
 104    - Compiler has errors
 105
 106    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
 107  */
 108
 109 #ifndef _GNU_SOURCE
 110 # define _GNU_SOURCE
 111 #endif
 112
 113 #include "libm-test-ulps.h"
 114 #include <complex.h>
 115 #include <math.h>
 116 #include <float.h>
 117 #include <fenv.h>
 118
 119 #include <errno.h>
 120 #include <stdlib.h>
 121 #include <stdio.h>
 122 #include <argp.h>
 123
 124 /* Possible exceptions */
 125 #define NO_EXCEPTION                    0x0
 126 #define INVALID_EXCEPTION               0x1
 127 #define DIVIDE_BY_ZERO_EXCEPTION        0x2
 128 /* The next flags signals that those exceptions are allowed but not required.   */
 129 #define INVALID_EXCEPTION_OK            0x4
 130 #define DIVIDE_BY_ZERO_EXCEPTION_OK     0x8
 131 #define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK
 132 /* Some special test flags, passed togther with exceptions.  */
 133 #define IGNORE_ZERO_INF_SIGN            0x10
 134
 135 /* Various constants (we must supply them precalculated for accuracy).  */
 136 #define M_PI_6l                 .52359877559829887308L
 137 #define M_E2l                   7.389056098930650227230L
 138 #define M_E3l                   20.08553692318766774093L
 139 #define M_2_SQRT_PIl            3.5449077018110320545963L       /* 2 sqrt (M_PIl)  */
 140 #define M_SQRT_PIl              1.77245385090551602729817L      /* sqrt (M_PIl)  */
 141 #define M_LOG_SQRT_PIl          0.572364942924700087072L        /* log(sqrt(M_PIl))  */
 142 #define M_LOG_2_SQRT_PIl        1.265512123484645396489L        /* log(2*sqrt(M_PIl))  */
 143 #define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */
 144 #define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El
 145 #define M_PI2_LOG10El           M_PI_2l * M_LOG10El
 146 #define M_PI4_LOG10El           M_PI_4l * M_LOG10El
 147 #define M_PI_LOG10El            M_PIl * M_LOG10El
 148
 149 static FILE *ulps_file; /* File to document difference.  */
 150 static int output_ulps; /* Should ulps printed?  */
 151
 152 static int noErrors;    /* number of errors */
 153 static int noTests;     /* number of tests (without testing exceptions) */
 154 static int noExcTests;  /* number of tests for exception flags */
 155 static int noXFails;    /* number of expected failures.  */
 156 static int noXPasses;   /* number of unexpected passes.  */
 157
 158 static int verbose;
 159 static int output_max_error;    /* Should the maximal errors printed?  */
 160 static int output_points;       /* Should the single function results printed?  */
 161 static int ignore_max_ulp;      /* Should we ignore max_ulp?  */
 162
 163 static FLOAT minus_zero, plus_zero;
 164 static FLOAT plus_infty, minus_infty, nan_value;
 165
 166 static FLOAT max_error, real_max_error, imag_max_error;
 167
 168
 169 #define BUILD_COMPLEX(real, imag) \
 170   ({ __complex__ FLOAT __retval;                                              \
 171      __real__ __retval = (real);                                              \
 172      __imag__ __retval = (imag);                                              \
 173      __retval; })
 174
 175 #define BUILD_COMPLEX_INT(real, imag) \
 176   ({ __complex__ int __retval;                                                \
 177      __real__ __retval = (real);                                              \
 178      __imag__ __retval = (imag);                                              \
 179      __retval; })
 180
 181
 182 #define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \
 183                          (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))
 184
 185 static void
 186 init_max_error (void)
 187 {
 188   max_error = 0;
 189   real_max_error = 0;
 190   imag_max_error = 0;
 191 }
 192
 193 static void
 194 set_max_error (FLOAT current, FLOAT *curr_max_error)
 195 {
 196   if (current > *curr_max_error)
 197     *curr_max_error = current;
 198 }
 199
 200
 201 /* Should the message print to screen?  This depends on the verbose flag,
 202    and the test status.  */
 203 static int
 204 print_screen (int ok, int xfail)
 205 {
 206   if (output_points
 207       && (verbose > 1
 208           || (verbose == 1 && ok == xfail)))
 209     return 1;
 210   return 0;
 211 }
 212
 213
 214 /* Should the message print to screen?  This depends on the verbose flag,
 215    and the test status.  */
 216 static int
 217 print_screen_max_error (int ok, int xfail)
 218 {
 219   if (output_max_error
 220       && (verbose > 1
 221           || ((verbose == 1) && (ok == xfail))))
 222     return 1;
 223   return 0;
 224 }
 225
 226 /* Update statistic counters.  */
 227 static void
 228 update_stats (int ok, int xfail)
 229 {
 230   ++noTests;
 231   if (ok && xfail)
 232     ++noXPasses;
 233   else if (!ok && xfail)
 234     ++noXFails;
 235   else if (!ok && !xfail)
 236     ++noErrors;
 237 }
 238
 239 static void
 240 print_ulps (const char *test_name, FLOAT ulp)
 241 {
 242   if (output_ulps)
 243     {
 244       fprintf (ulps_file, "Test \"%s\":\n", test_name);
 245       fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n",
 246                CHOOSE("ldouble", "double", "float",
 247                       "ildouble", "idouble", "ifloat"), ulp);
 248     }
 249 }
 250
 251 static void
 252 print_function_ulps (const char *function_name, FLOAT ulp)
 253 {
 254   if (output_ulps)
 255     {
 256       fprintf (ulps_file, "Function: \"%s\":\n", function_name);
 257       fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n",
 258                CHOOSE("ldouble", "double", "float",
 259                       "ildouble", "idouble", "ifloat"), ulp);
 260     }
 261 }
 262
 263
 264 static void
 265 print_complex_function_ulps (const char *function_name, FLOAT real_ulp,
 266                              FLOAT imag_ulp)
 267 {
 268   if (output_ulps)
 269     {
 270       if (real_ulp != 0.0)
 271         {
 272           fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);
 273           fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n",
 274                    CHOOSE("ldouble", "double", "float",
 275                           "ildouble", "idouble", "ifloat"), real_ulp);
 276         }
 277       if (imag_ulp != 0.0)
 278         {
 279           fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);
 280           fprintf (ulps_file, "%s: % .4" PRINTF_NEXPR "\n",
 281                    CHOOSE("ldouble", "double", "float",
 282                           "ildouble", "idouble", "ifloat"), imag_ulp);
 283         }
 284
 285
 286     }
 287 }
 288
 289
 290
 291 /* Test if Floating-Point stack hasn't changed */
 292 static void
 293 fpstack_test (const char *test_name)
 294 {
 295 #ifdef i386
 296   static int old_stack;
 297   int sw;
 298
 299   asm ("fnstsw" : "=a" (sw));
 300   sw >>= 11;
 301   sw &= 7;
 302
 303   if (sw != old_stack)
 304     {
 305       printf ("FP-Stack wrong after test %s (%d, should be %d)\n",
 306               test_name, sw, old_stack);
 307       ++noErrors;
 308       old_stack = sw;
 309     }
 310 #endif
 311 }
 312
 313
 314 static void
 315 print_max_error (const char *func_name, FLOAT allowed, int xfail)
 316 {
 317   int ok = 0;
 318
 319   if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))
 320     {
 321       ok = 1;
 322     }
 323
 324   if (!ok)
 325     print_function_ulps (func_name, max_error);
 326
 327
 328   if (print_screen_max_error (ok, xfail))
 329     {
 330       printf ("Maximal error of `%s'\n", func_name);
 331       printf (" is      : % .4" PRINTF_NEXPR " ulp\n", max_error);
 332       printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", allowed);
 333     }
 334
 335   update_stats (ok, xfail);
 336 }
 337
 338
 339 static void
 340 print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,
 341                          __complex__ int xfail)
 342 {
 343   int ok = 0;
 344
 345   if ((real_max_error <= __real__ allowed)
 346       && (imag_max_error <= __imag__ allowed))
 347     {
 348       ok = 1;
 349     }
 350
 351   if (!ok)
 352     print_complex_function_ulps (func_name, real_max_error, imag_max_error);
 353
 354
 355   if (print_screen_max_error (ok, xfail))
 356     {
 357       printf ("Maximal error of real part of: %s\n", func_name);
 358       printf (" is      : % .4" PRINTF_NEXPR " ulp\n", real_max_error);
 359       printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", __real__ allowed);
 360       printf ("Maximal error of imaginary part of: %s\n", func_name);
 361       printf (" is      : % .4" PRINTF_NEXPR " ulp\n", imag_max_error);
 362       printf (" accepted: % .4" PRINTF_NEXPR " ulp\n", __imag__ allowed);
 363     }
 364
 365   update_stats (ok, xfail);
 366 }
 367
 368
 369 /* Test whether a given exception was raised.  */
 370 static void
 371 test_single_exception (const char *test_name,
 372                        int exception,
 373                        int exc_flag,
 374                        int fe_flag,
 375                        const char *flag_name)
 376 {
 377 #ifndef TEST_INLINE
 378   int ok = 1;
 379   if (exception & exc_flag)
 380     {
 381       if (fetestexcept (fe_flag))
 382         {
 383           if (print_screen (1, 0))
 384             printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);
 385         }
 386       else
 387         {
 388           ok = 0;
 389           if (print_screen (0, 0))
 390             printf ("Failure: %s: Exception \"%s\" not set\n",
 391                     test_name, flag_name);
 392         }
 393     }
 394   else
 395     {
 396       if (fetestexcept (fe_flag))
 397         {
 398           ok = 0;
 399           if (print_screen (0, 0))
 400             printf ("Failure: %s: Exception \"%s\" set\n",
 401                     test_name, flag_name);
 402         }
 403       else
 404         {
 405           if (print_screen (1, 0))
 406             printf ("%s: Exception \"%s\" not set\n", test_name,
 407                     flag_name);
 408         }
 409     }
 410   if (!ok)
 411     ++noErrors;
 412
 413 #endif
 414 }
 415
 416
 417 /* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby
 418    allowed but not required exceptions.
 419 */
 420 static void
 421 test_exceptions (const char *test_name, int exception)
 422 {
 423   ++noExcTests;
 424 #ifdef FE_DIVBYZERO
 425   if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)
 426     test_single_exception (test_name, exception,
 427                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
 428                            "Divide by zero");
 429 #endif
 430 #ifdef FE_INVALID
 431   if ((exception & INVALID_EXCEPTION_OK) == 0)
 432     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
 433                          "Invalid operation");
 434 #endif
 435   feclearexcept (FE_ALL_EXCEPT);
 436 }
 437
 438
 439 static void
 440 check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,
 441                       FLOAT max_ulp, int xfail, int exceptions,
 442                       FLOAT *curr_max_error)
 443 {
 444   int ok = 0;
 445   int print_diff = 0;
 446   FLOAT diff = 0;
 447   FLOAT ulp = 0;
 448
 449   test_exceptions (test_name, exceptions);
 450   if (isnan (computed) && isnan (expected))
 451     ok = 1;
 452   else if (isinf (computed) && isinf (expected))
 453     {
 454       /* Test for sign of infinities.  */
 455       if (((exceptions & IGNORE_ZERO_INF_SIGN) == 0)
 456           && (isinf (computed) != isinf (expected)))
 457         {
 458           ok = 0;
 459           printf ("infinity has wrong sign.\n");
 460         }
 461       else
 462         ok = 1;
 463     }
 464   /* Don't calc ulp for NaNs or infinities.  */
 465   else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))
 466     ok = 0;
 467   else
 468     {
 469       diff = FUNC(fabs) (computed - expected);
 470       /* ilogb (0) isn't allowed.  */
 471       if (expected == 0.0)
 472         ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);
 473       else
 474         ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);
 475       set_max_error (ulp, curr_max_error);
 476       print_diff = 1;
 477       if (((exceptions & IGNORE_ZERO_INF_SIGN) == 0)
 478           && (computed == 0.0 && expected == 0.0
 479               && signbit(computed) != signbit (expected)))
 480         ok = 0;
 481       else if (ulp == 0.0 || (ulp <= max_ulp && !ignore_max_ulp))
 482         ok = 1;
 483       else
 484         {
 485           ok = 0;
 486           print_ulps (test_name, ulp);
 487         }
 488
 489     }
 490   if (print_screen (ok, xfail))
 491     {
 492       if (!ok)
 493         printf ("Failure: ");
 494       printf ("Test: %s\n", test_name);
 495       printf ("Result:\n");
 496       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 497               computed, computed);
 498       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
 499               expected, expected);
 500       if (print_diff)
 501         {
 502           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
 503                   "\n", diff, diff);
 504           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
 505           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
 506         }
 507     }
 508   update_stats (ok, xfail);
 509
 510   fpstack_test (test_name);
 511 }
 512
 513
 514 static void
 515 check_float (const char *test_name, FLOAT computed, FLOAT expected,
 516              FLOAT max_ulp, int xfail, int exceptions)
 517 {
 518   check_float_internal (test_name, computed, expected, max_ulp, xfail,
 519                         exceptions, &max_error);
 520 }
 521
 522
 523 static void
 524 check_complex (const char *test_name, __complex__ FLOAT computed,
 525                __complex__ FLOAT expected,
 526                __complex__ FLOAT max_ulp, __complex__ int xfail,
 527                int exception)
 528 {
 529   FLOAT part_comp, part_exp, part_max_ulp;
 530   int part_xfail;
 531   char str[200];
 532
 533   sprintf (str, "Real part of: %s", test_name);
 534   part_comp = __real__ computed;
 535   part_exp = __real__ expected;
 536   part_max_ulp = __real__ max_ulp;
 537   part_xfail = __real__ xfail;
 538
 539   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 540                         exception, &real_max_error);
 541
 542   sprintf (str, "Imaginary part of: %s", test_name);
 543   part_comp = __imag__ computed;
 544   part_exp = __imag__ expected;
 545   part_max_ulp = __imag__ max_ulp;
 546   part_xfail = __imag__ xfail;
 547
 548   /* Don't check again for exceptions, just pass through the
 549      zero/inf sign test.  */
 550   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
 551                         exception & IGNORE_ZERO_INF_SIGN,
 552                         &imag_max_error);
 553 }
 554
 555
 556 /* Check that computed and expected values are equal (int values).  */
 557 static void
 558 check_int (const char *test_name, int computed, int expected, int max_ulp,
 559            int xfail, int exceptions)
 560 {
 561   int diff = computed - expected;
 562   int ok = 0;
 563
 564   test_exceptions (test_name, exceptions);
 565   noTests++;
 566   if (abs (diff) <= max_ulp)
 567     ok = 1;
 568
 569   if (!ok)
 570     print_ulps (test_name, diff);
 571
 572   if (print_screen (ok, xfail))
 573     {
 574       if (!ok)
 575         printf ("Failure: ");
 576       printf ("Test: %s\n", test_name);
 577       printf ("Result:\n");
 578       printf (" is:         %d\n", computed);
 579       printf (" should be:  %d\n", expected);
 580     }
 581
 582   update_stats (ok, xfail);
 583   fpstack_test (test_name);
 584 }
 585
 586
 587 /* Check that computed and expected values are equal (long int values).  */
 588 static void
 589 check_long (const char *test_name, long int computed, long int expected,
 590             long int max_ulp, int xfail, int exceptions)
 591 {
 592   long int diff = computed - expected;
 593   int ok = 0;
 594
 595   test_exceptions (test_name, exceptions);
 596   noTests++;
 597   if (labs (diff) <= max_ulp)
 598     ok = 1;
 599
 600   if (!ok)
 601     print_ulps (test_name, diff);
 602
 603   if (print_screen (ok, xfail))
 604     {
 605       if (!ok)
 606         printf ("Failure: ");
 607       printf ("Test: %s\n", test_name);
 608       printf ("Result:\n");
 609       printf (" is:         %ld\n", computed);
 610       printf (" should be:  %ld\n", expected);
 611     }
 612
 613   update_stats (ok, xfail);
 614   fpstack_test (test_name);
 615 }
 616
 617
 618 /* Check that computed value is true/false.  */
 619 static void
 620 check_bool (const char *test_name, int computed, int expected,
 621             long int max_ulp, int xfail, int exceptions)
 622 {
 623   int ok = 0;
 624
 625   test_exceptions (test_name, exceptions);
 626   noTests++;
 627   if ((computed == 0) == (expected == 0))
 628     ok = 1;
 629
 630   if (print_screen (ok, xfail))
 631     {
 632       if (!ok)
 633         printf ("Failure: ");
 634       printf ("Test: %s\n", test_name);
 635       printf ("Result:\n");
 636       printf (" is:         %d\n", computed);
 637       printf (" should be:  %d\n", expected);
 638     }
 639
 640   update_stats (ok, xfail);
 641   fpstack_test (test_name);
 642 }
 643
 644
 645 /* check that computed and expected values are equal (long int values) */
 646 static void
 647 check_longlong (const char *test_name, long long int computed,
 648                 long long int expected,
 649                 long long int max_ulp, int xfail,
 650                 int exceptions)
 651 {
 652   long long int diff = computed - expected;
 653   int ok = 0;
 654
 655   test_exceptions (test_name, exceptions);
 656   noTests++;
 657   if (llabs (diff) <= max_ulp)
 658     ok = 1;
 659
 660   if (!ok)
 661     print_ulps (test_name, diff);
 662
 663   if (print_screen (ok, xfail))
 664     {
 665       if (!ok)
 666         printf ("Failure:");
 667       printf ("Test: %s\n", test_name);
 668       printf ("Result:\n");
 669       printf (" is:         %lld\n", computed);
 670       printf (" should be:  %lld\n", expected);
 671     }
 672
 673   update_stats (ok, xfail);
 674   fpstack_test (test_name);
 675 }
 676
 677
 678
 679 /* This is to prevent messages from the SVID libm emulation.  */
 680 int
 681 matherr (struct exception *x __attribute__ ((unused)))
 682 {
 683   return 1;
 684 }
 685
 686
 687 /****************************************************************************
 688   Tests for single functions of libm.
 689   Please keep them alphabetically sorted!
 690 ****************************************************************************/
 691
 692 static void
 693 acos_test (void)
 694 {
 695   START (acos);
 696
 697   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
 698   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
 699   TEST_f_f (acos, nan_value, nan_value);
 700
 701   /* |x| > 1: */
 702   TEST_f_f (acos, 1.1, nan_value, INVALID_EXCEPTION);
 703   TEST_f_f (acos, -1.1, nan_value, INVALID_EXCEPTION);
 704
 705   TEST_f_f (acos, 0, M_PI_2l);
 706   TEST_f_f (acos, minus_zero, M_PI_2l);
 707   TEST_f_f (acos, 1, 0);
 708   TEST_f_f (acos, -1, M_PIl);
 709   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
 710   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
 711   TEST_f_f (acos, 0.7, 0.7953988301841435554L);
 712
 713   END (acos);
 714 }
 715
 716 static void
 717 acosh_test (void)
 718 {
 719   START (acosh);
 720
 721   TEST_f_f (acosh, plus_infty, plus_infty);
 722   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
 723
 724   /* x < 1:  */
 725   TEST_f_f (acosh, -1.1, nan_value, INVALID_EXCEPTION);
 726
 727   TEST_f_f (acosh, 1, 0);
 728   TEST_f_f (acosh, 7, 2.6339157938496334172L);
 729
 730   END (acosh);
 731 }
 732
 733 static void
 734 asin_test (void)
 735 {
 736
 737   START (asin);
 738
 739   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
 740   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
 741   TEST_f_f (asin, nan_value, nan_value);
 742
 743   /* asin x == NaN plus invalid exception for |x| > 1.  */
 744   TEST_f_f (asin, 1.1, nan_value, INVALID_EXCEPTION);
 745   TEST_f_f (asin, -1.1, nan_value, INVALID_EXCEPTION);
 746
 747   TEST_f_f (asin, 0, 0);
 748   TEST_f_f (asin, minus_zero, minus_zero);
 749   TEST_f_f (asin, 0.5, M_PI_6l);
 750   TEST_f_f (asin, -0.5, -M_PI_6l);
 751   TEST_f_f (asin, 1.0, M_PI_2l);
 752   TEST_f_f (asin, -1.0, -M_PI_2l);
 753   TEST_f_f (asin, 0.7, 0.7753974966107530637L);
 754
 755   END (asin);
 756 }
 757
 758 static void
 759 asinh_test (void)
 760 {
 761   START (asinh);
 762
 763   TEST_f_f (asinh, 0, 0);
 764   TEST_f_f (asinh, minus_zero, minus_zero);
 765 #ifndef TEST_INLINE
 766   TEST_f_f (asinh, plus_infty, plus_infty);
 767   TEST_f_f (asinh, minus_infty, minus_infty);
 768 #endif
 769   TEST_f_f (asinh, nan_value, nan_value);
 770   TEST_f_f (asinh, 0.7, 0.652666566082355786L);
 771
 772   END (asinh);
 773 }
 774
 775 static void
 776 atan_test (void)
 777 {
 778
 779   START (atan);
 780
 781   TEST_f_f (atan, 0, 0);
 782   TEST_f_f (atan, minus_zero, minus_zero);
 783
 784   TEST_f_f (atan, plus_infty, M_PI_2l);
 785   TEST_f_f (atan, minus_infty, -M_PI_2l);
 786   TEST_f_f (atan, nan_value, nan_value);
 787
 788   TEST_f_f (atan, 1, M_PI_4l);
 789   TEST_f_f (atan, -1, -M_PI_4l);
 790
 791   TEST_f_f (atan, 0.7, 0.6107259643892086165L);
 792
 793   END (atan);
 794 }
 795
 796
 797
 798 static void
 799 atanh_test (void)
 800 {
 801
 802   START (atanh);
 803
 804
 805   TEST_f_f (atanh, 0, 0);
 806   TEST_f_f (atanh, minus_zero, minus_zero);
 807
 808   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 809   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
 810   TEST_f_f (atanh, nan_value, nan_value);
 811
 812   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
 813   TEST_f_f (atanh, 1.1, nan_value, INVALID_EXCEPTION);
 814   TEST_f_f (atanh, -1.1, nan_value, INVALID_EXCEPTION);
 815
 816   TEST_f_f (atanh, 0.7, 0.8673005276940531944L);
 817
 818   END (atanh);
 819 }
 820
 821 static void
 822 atan2_test (void)
 823 {
 824   START (atan2);
 825
 826   /* atan2 (0,x) == 0 for x > 0.  */
 827   TEST_ff_f (atan2, 0, 1, 0);
 828
 829   /* atan2 (-0,x) == -0 for x > 0.  */
 830   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
 831
 832   TEST_ff_f (atan2, 0, 0, 0);
 833   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
 834
 835   /* atan2 (+0,x) == +pi for x < 0.  */
 836   TEST_ff_f (atan2, 0, -1, M_PIl);
 837
 838   /* atan2 (-0,x) == -pi for x < 0.  */
 839   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
 840
 841   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
 842   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
 843
 844   /* atan2 (y,+0) == pi/2 for y > 0.  */
 845   TEST_ff_f (atan2, 1, 0, M_PI_2l);
 846
 847   /* atan2 (y,-0) == pi/2 for y > 0.  */
 848   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
 849
 850   /* atan2 (y,+0) == -pi/2 for y < 0.  */
 851   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
 852
 853   /* atan2 (y,-0) == -pi/2 for y < 0.  */
 854   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
 855
 856   /* atan2 (y,inf) == +0 for finite y > 0.  */
 857   TEST_ff_f (atan2, 1, plus_infty, 0);
 858
 859   /* atan2 (y,inf) == -0 for finite y < 0.  */
 860   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
 861
 862   /* atan2(+inf, x) == pi/2 for finite x.  */
 863   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
 864
 865   /* atan2(-inf, x) == -pi/2 for finite x.  */
 866   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
 867
 868   /* atan2 (y,-inf) == +pi for finite y > 0.  */
 869   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
 870
 871   /* atan2 (y,-inf) == -pi for finite y < 0.  */
 872   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
 873
 874   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
 875   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
 876   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
 877   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
 878   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
 879
 880   TEST_ff_f (atan2, 0.7, 1, 0.6107259643892086165L);
 881   TEST_ff_f (atan2, 0.4, 0.0003, 1.5700463269355215718L);
 882
 883   END (atan2);
 884 }
 885
 886
 887 static void
 888 cabs_test (void)
 889 {
 890   START (cabs);
 891
 892   /* cabs (x + iy) is specified as hypot (x,y) */
 893
 894   /* cabs (+inf + i x) == +inf.  */
 895   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
 896   /* cabs (-inf + i x) == +inf.  */
 897   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
 898
 899   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
 900   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
 901
 902   TEST_c_f (cabs, nan_value, nan_value, nan_value);
 903
 904   /* cabs (x,y) == cabs (y,x).  */
 905   TEST_c_f (cabs, 0.7L, 12.4L, 12.41974234837422060118L);
 906   /* cabs (x,y) == cabs (-x,y).  */
 907   TEST_c_f (cabs, -12.4L, 0.7L, 12.41974234837422060118L);
 908   /* cabs (x,y) == cabs (-y,x).  */
 909   TEST_c_f (cabs, -0.7L, 12.4L, 12.41974234837422060118L);
 910   /* cabs (x,y) == cabs (-x,-y).  */
 911   TEST_c_f (cabs, -12.4L, -0.7L, 12.41974234837422060118L);
 912   /* cabs (x,y) == cabs (-y,-x).  */
 913   TEST_c_f (cabs, -0.7L, -12.4L, 12.41974234837422060118L);
 914   /* cabs (x,0) == fabs (x).  */
 915   TEST_c_f (cabs, -0.7L, 0, 0.7L);
 916   TEST_c_f (cabs, 0.7L, 0, 0.7L);
 917   TEST_c_f (cabs, -1.0L, 0, 1.0L);
 918   TEST_c_f (cabs, 1.0L, 0, 1.0L);
 919   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
 920   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
 921
 922   TEST_c_f (cabs, 0.7, 1.2, 1.3892443989449804508L);
 923
 924   END (cabs);
 925 }
 926
 927 static void
 928 cacos_test (void)
 929 {
 930   START (cacos);
 931
 932
 933   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
 934   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
 935   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
 936   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
 937
 938   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
 939   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
 940
 941   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
 942   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
 943
 944   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
 945   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
 946   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
 947   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
 948   TEST_c_c (cacos, 0.1, plus_infty, M_PI_2l, minus_infty);
 949   TEST_c_c (cacos, 0.1, minus_infty, M_PI_2l, plus_infty);
 950
 951   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
 952   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
 953   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
 954   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
 955
 956   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
 957   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
 958   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
 959   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
 960
 961   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
 962   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
 963
 964   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
 965   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
 966
 967   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
 968   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
 969
 970   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
 971   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
 972
 973   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
 974   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
 975
 976   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
 977
 978   TEST_c_c (cacos, 0.7, 1.2, 1.1351827477151551089L, -1.0927647857577371459L);
 979   TEST_c_c (cacos, -2, -3, 2.1414491111159960199L, 1.9833870299165354323L);
 980
 981   END (cacos, complex);
 982 }
 983
 984
 985 static void
 986 cacosh_test (void)
 987 {
 988   START (cacosh);
 989
 990
 991   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
 992   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
 993   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
 994   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
 995   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
 996   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
 997
 998   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
 999   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1000
1001   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1002   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1003   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1004   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1005   TEST_c_c (cacosh, 0.1, plus_infty, plus_infty, M_PI_2l);
1006   TEST_c_c (cacosh, 0.1, minus_infty, plus_infty, -M_PI_2l);
1007
1008   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1009   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1010   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1011   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1012
1013   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1014   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1015   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1016   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1017
1018   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1019   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1020
1021   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1022   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1023
1024   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1025   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1026
1027   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1028   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1029
1030   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1031   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1032
1033   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1034
1035   TEST_c_c (cacosh, 0.7, 1.2, 1.0927647857577371459L, 1.1351827477151551089L);
1036   TEST_c_c (cacosh, -2, -3, -1.9833870299165354323L, 2.1414491111159960199L);
1037
1038   END (cacosh, complex);
1039 }
1040
1041 static void
1042 carg_test (void)
1043 {
1044   START (carg);
1045
1046   /* carg (x + iy) is specified as atan2 (y, x) */
1047
1048   /* carg (x + i 0) == 0 for x > 0.  */
1049   TEST_c_f (carg, 2.0, 0, 0);
1050   /* carg (x - i 0) == -0 for x > 0.  */
1051   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1052
1053   TEST_c_f (carg, 0, 0, 0);
1054   TEST_c_f (carg, 0, minus_zero, minus_zero);
1055
1056   /* carg (x + i 0) == +pi for x < 0.  */
1057   TEST_c_f (carg, -2.0, 0, M_PIl);
1058
1059   /* carg (x - i 0) == -pi for x < 0.  */
1060   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1061
1062   TEST_c_f (carg, minus_zero, 0, M_PIl);
1063   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1064
1065   /* carg (+0 + i y) == pi/2 for y > 0.  */
1066   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1067
1068   /* carg (-0 + i y) == pi/2 for y > 0.  */
1069   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1070
1071   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1072   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1073
1074   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1075   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1076
1077   /* carg (inf + i y) == +0 for finite y > 0.  */
1078   TEST_c_f (carg, plus_infty, 2.0, 0);
1079
1080   /* carg (inf + i y) == -0 for finite y < 0.  */
1081   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1082
1083   /* carg(x + i inf) == pi/2 for finite x.  */
1084   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1085
1086   /* carg(x - i inf) == -pi/2 for finite x.  */
1087   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1088
1089   /* carg (-inf + i y) == +pi for finite y > 0.  */
1090   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1091
1092   /* carg (-inf + i y) == -pi for finite y < 0.  */
1093   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1094
1095   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1096
1097   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1098
1099   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1100
1101   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1102
1103   TEST_c_f (carg, nan_value, nan_value, nan_value);
1104
1105   END (carg);
1106 }
1107
1108 static void
1109 casin_test (void)
1110 {
1111   START (casin);
1112
1113   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1114   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1115   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1116   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1117
1118   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1119   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1120   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1121   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1122
1123   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1124   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1125   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1126   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1127   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1128   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1129   TEST_c_c (casin, 0.1, plus_infty, 0.0, plus_infty);
1130   TEST_c_c (casin, 0.1, minus_infty, 0.0, minus_infty);
1131
1132   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1133   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1134   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1135   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1136
1137   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1138   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1139   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1140   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1141
1142   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1143   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1144
1145   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1146   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1147
1148   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1149   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1150
1151   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1152   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1153
1154   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1155   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1156
1157   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1158
1159   TEST_c_c (casin, 0.7, 1.2, 0.4356135790797415103L, 1.0927647857577371459L);
1160   TEST_c_c (casin, -2, -3, -0.5706527843210994007L, -1.9833870299165354323L);
1161
1162   END (casin, complex);
1163 }
1164
1165
1166 static void
1167 casinh_test (void)
1168 {
1169   START (casinh);
1170
1171   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1172   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1173   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1174   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1175
1176   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1177   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1178   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1179   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1180
1181   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1182   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1183   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1184   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1185   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1186   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1187   TEST_c_c (casinh, 0.1, plus_infty, plus_infty, M_PI_2l);
1188   TEST_c_c (casinh, 0.1, minus_infty, plus_infty, -M_PI_2l);
1189
1190   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1191   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1192   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1193   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1194
1195   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1196   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1197   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1198   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1199
1200   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1201   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1202
1203   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1204   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1205
1206   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1207   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1208
1209   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1210   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1211
1212   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1213   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1214
1215   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1216
1217   TEST_c_c (casinh, 0.7, 1.2, 0.9786545955936738768L, 0.9113541895315601156L);
1218   TEST_c_c (casinh, -2, -3, -1.9686379257930962917L, -0.9646585044076027920L);
1219
1220   END (casinh, complex);
1221 }
1222
1223
1224 static void
1225 catan_test (void)
1226 {
1227   START (catan);
1228
1229   TEST_c_c (catan, 0, 0, 0, 0);
1230   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1231   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1232   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1233
1234   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1235   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1236   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1237   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1238
1239
1240   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1241   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1242   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1243   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1244   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1245   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1246   TEST_c_c (catan, plus_infty, 0.1, M_PI_2l, 0);
1247   TEST_c_c (catan, minus_infty, 0.1, -M_PI_2l, 0);
1248
1249   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1250   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1251   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1252   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1253
1254   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1255   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1256   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1257   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1258
1259   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1260   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1261
1262   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1263   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1264
1265   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1266   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1267
1268   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1269   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1270
1271   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1272   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1273
1274   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1275   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1276
1277   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1278
1279   TEST_c_c (catan, 0.7, 1.2, 1.0785743834118921877L, 0.5770573776534306764L);
1280
1281   TEST_c_c (catan, -2, -3, -1.4099210495965755225L, -0.2290726829685387662L);
1282
1283   END (catan, complex);
1284 }
1285
1286 static void
1287 catanh_test (void)
1288 {
1289   START (catanh);
1290
1291   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1292   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1293   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1294   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1295
1296   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1297   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1298   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1299   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1300
1301   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1302   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1303   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1304   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1305   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1306   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1307   TEST_c_c (catanh, 0.1, plus_infty, 0.0, M_PI_2l);
1308   TEST_c_c (catanh, 0.1, minus_infty, 0.0, -M_PI_2l);
1309
1310   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1311   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1312   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1313   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1314
1315   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1316   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1317   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1318   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1319
1320   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1321   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1322
1323   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1324   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1325
1326   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1327   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1328
1329   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1330   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1331
1332   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1333   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1334
1335   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1336   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1337
1338   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1339
1340   TEST_c_c (catanh, 0.7, 1.2, 0.2600749516525135959L, 0.9702403077950989849L);
1341   TEST_c_c (catanh, -2, -3, -0.1469466662255297520L, -1.3389725222944935611L);
1342
1343   END (catanh, complex);
1344 }
1345
1346 static void
1347 cbrt_test (void)
1348 {
1349   START (cbrt);
1350
1351   TEST_f_f (cbrt, 0.0, 0.0);
1352   TEST_f_f (cbrt, minus_zero, minus_zero);
1353
1354   TEST_f_f (cbrt, plus_infty, plus_infty);
1355   TEST_f_f (cbrt, minus_infty, minus_infty);
1356   TEST_f_f (cbrt, nan_value, nan_value);
1357
1358   TEST_f_f (cbrt, -0.001, -0.1);
1359   TEST_f_f (cbrt, 8, 2);
1360   TEST_f_f (cbrt, -27.0, -3.0);
1361   TEST_f_f (cbrt, 0.970299, 0.99);
1362   TEST_f_f (cbrt, 0.7, 0.8879040017426007084L);
1363
1364   END (cbrt);
1365 }
1366
1367 static void
1368 ccos_test (void)
1369 {
1370
1371   START (ccos);
1372
1373   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1374   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1375   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1376   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1377
1378   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1379   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1380   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1381   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1382
1383   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1384   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1385   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1386   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1387
1388   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1389   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1390   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1391   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1392
1393   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1394   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1395   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1396   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1397
1398   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1399   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1400   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1401   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1402
1403   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1404   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1405
1406   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1407   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1408
1409   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1410   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1411
1412   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1413   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1414
1415   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1416   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1417
1418   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1419   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1420
1421   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1422
1423   TEST_c_c (ccos, 0.7, 1.2, 1.3848657645312111080L, -0.97242170335830028619L);
1424
1425   TEST_c_c (ccos, -2, -3, -4.1896256909688072301L, -9.1092278937553365979L);
1426
1427   END (ccos, complex);
1428 }
1429
1430
1431 static void
1432 ccosh_test (void)
1433 {
1434
1435   START (ccosh);
1436
1437   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1438   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1439   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1440   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1441
1442   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1443   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1444   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1445   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1446
1447   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1448   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1449   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1450   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1451
1452   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1453   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1454   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1455   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1456
1457   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1458   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1459   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1460   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1461
1462   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1463   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1464   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1465   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1466
1467   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1468   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1469
1470   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1471   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1472
1473   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1474   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1475
1476   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1477   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1478
1479   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1480   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1481
1482   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1483   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1484
1485   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1486
1487   TEST_c_c (ccosh, 0.7, 1.2, 0.4548202223691477654L, 0.7070296600921537682L);
1488
1489   TEST_c_c (ccosh, -2, -3, -3.7245455049153225654L, 0.5118225699873846088L);
1490
1491   END (ccosh, complex);
1492 }
1493
1494
1495 static void
1496 ceil_test (void)
1497 {
1498   START (ceil);
1499
1500   TEST_f_f (ceil, 0.0, 0.0);
1501   TEST_f_f (ceil, minus_zero, minus_zero);
1502   TEST_f_f (ceil, plus_infty, plus_infty);
1503   TEST_f_f (ceil, minus_infty, minus_infty);
1504   TEST_f_f (ceil, nan_value, nan_value);
1505
1506   TEST_f_f (ceil, M_PIl, 4.0);
1507   TEST_f_f (ceil, -M_PIl, -3.0);
1508
1509   END (ceil);
1510 }
1511
1512
1513 static void
1514 cexp_test (void)
1515 {
1516   START (cexp);
1517
1518   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1519   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1520   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1521   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1522
1523   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1524   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1525
1526   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1527   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1528
1529   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1530   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1531
1532   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1533   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1534
1535   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1536   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1537
1538   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1539   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1540
1541   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1542   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1543   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1544   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1545
1546   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1547   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1548
1549   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1550   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1551
1552   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1553
1554   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1555
1556   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1557   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1558
1559   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1560   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1561   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1562   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1563
1564   TEST_c_c (cexp, 0.7, 1.2, 0.7296989091503236012L, 1.8768962328348102821L);
1565   TEST_c_c (cexp, -2.0, -3.0, -0.1339809149295426134L, -0.0190985162611351964L);
1566
1567   END (cexp, complex);
1568 }
1569
1570 static void
1571 cimag_test (void)
1572 {
1573   START (cimag);
1574   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1575   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1576   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1577   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1578   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1579   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1580   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1581
1582   END (cimag);
1583 }
1584
1585 static void
1586 clog_test (void)
1587 {
1588   START (clog);
1589
1590   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1591   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1592
1593   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1594   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1595
1596   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1597   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1598
1599   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1600   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1601
1602   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1603   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1604   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1605   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1606   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1607   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1608   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1609   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1610
1611   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1612   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1613   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1614   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1615
1616   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1617   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1618   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1619   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1620
1621   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1622   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1623
1624   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1625   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1626
1627   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1628   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1629   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1630   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1631
1632   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1633   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1634   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1635   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1636
1637   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1638   TEST_c_c (clog, -2, -3, 1.2824746787307683680L, -2.1587989303424641704L);
1639
1640   END (clog, complex);
1641 }
1642
1643
1644 static void
1645 clog10_test (void)
1646 {
1647   START (clog10);
1648
1649   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1650   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1651
1652   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1653   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1654
1655   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1656
1657   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1658   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1659
1660   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1661   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1662   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1663   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1664   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1665   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1666   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1667   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1668
1669   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1670   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1671   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1672   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1673
1674   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1675   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1676   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1677   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1678
1679   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1680   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1681
1682   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1683   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1684
1685   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1686   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1687   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1688   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1689
1690   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1691   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1692   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1693   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1694
1695   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1696
1697   TEST_c_c (clog10, 0.7, 1.2, 0.1427786545038868803L, 0.4528483579352493248L);
1698   TEST_c_c (clog10, -2, -3, 0.5569716761534183846L, -0.9375544629863747085L);
1699
1700   END (clog10, complex);
1701 }
1702
1703 static void
1704 conj_test (void)
1705 {
1706   START (conj);
1707   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1708   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1709   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1710   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1711   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1712   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1713   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1714
1715   END (conj, complex);
1716 }
1717
1718
1719 static void
1720 copysign_test (void)
1721 {
1722   START (copysign);
1723
1724   TEST_ff_f (copysign, 0, 4, 0);
1725   TEST_ff_f (copysign, 0, -4, minus_zero);
1726   TEST_ff_f (copysign, minus_zero, 4, 0);
1727   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1728
1729   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1730   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1731   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1732   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1733
1734   TEST_ff_f (copysign, 0, plus_infty, 0);
1735   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1736   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1737   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1738
1739   /* XXX More correctly we would have to check the sign of the NaN.  */
1740   TEST_ff_f (copysign, nan_value, 0, nan_value);
1741   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1742   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1743   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1744
1745   END (copysign);
1746 }
1747
1748 static void
1749 cos_test (void)
1750 {
1751   START (cos);
1752
1753   TEST_f_f (cos, 0, 1);
1754   TEST_f_f (cos, minus_zero, 1);
1755   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1756   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1757   TEST_f_f (cos, nan_value, nan_value);
1758
1759   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1760   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1761   TEST_f_f (cos, M_PI_2l, 0);
1762
1763   TEST_f_f (cos, 0.7, 0.7648421872844884262L);
1764
1765   END (cos);
1766 }
1767
1768 static void
1769 cosh_test (void)
1770 {
1771   START (cosh);
1772   TEST_f_f (cosh, 0, 1);
1773   TEST_f_f (cosh, minus_zero, 1);
1774
1775 #ifndef TEST_INLINE
1776   TEST_f_f (cosh, plus_infty, plus_infty);
1777   TEST_f_f (cosh, minus_infty, plus_infty);
1778 #endif
1779   TEST_f_f (cosh, nan_value, nan_value);
1780
1781   TEST_f_f (cosh, 0.7, 1.255169005630943018L);
1782   END (cosh);
1783 }
1784
1785
1786 static void
1787 cpow_test (void)
1788 {
1789   START (cpow);
1790
1791   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
1792   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
1793
1794   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
1795   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
1796
1797   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
1798
1799   END (cpow, complex);
1800 }
1801
1802 static void
1803 cproj_test (void)
1804 {
1805   START (cproj);
1806   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
1807   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
1808   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
1809   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
1810
1811   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
1812
1813   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
1814   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
1815   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
1816   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
1817
1818   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
1819   TEST_c_c (cproj, 2.0, 3.0, 0.28571428571428571429L, .42857142857142857143L);
1820
1821   END (cproj, complex);
1822 }
1823
1824 static void
1825 creal_test (void)
1826 {
1827   START (creal);
1828   TEST_c_f (creal, 0.0, 1.0, 0.0);
1829   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
1830   TEST_c_f (creal, nan_value, 1.0, nan_value);
1831   TEST_c_f (creal, nan_value, nan_value, nan_value);
1832   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
1833   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
1834   TEST_c_f (creal, 2.0, 3.0, 2.0);
1835
1836   END (creal);
1837 }
1838
1839 static void
1840 csin_test (void)
1841 {
1842
1843   START (csin);
1844
1845   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
1846   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
1847   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
1848   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
1849
1850   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
1851   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
1852   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
1853   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
1854
1855   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1856   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1857   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1858   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1859
1860   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1861   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1862   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1863   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1864
1865   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1866   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1867   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1868   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
1869
1870   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
1871   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
1872   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
1873   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
1874
1875   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1876   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1877
1878   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1879   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1880
1881   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1882   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1883
1884   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
1885   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
1886
1887   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1888   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1889
1890   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1891   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1892
1893   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
1894
1895   TEST_c_c (csin, 0.7, 1.2, 1.1664563419657581376L, 1.1544997246948547371L);
1896
1897   TEST_c_c (csin, -2, -3, -9.1544991469114295734L, 4.1689069599665643507L);
1898
1899   END (csin, complex);
1900 }
1901
1902
1903 static void
1904 csinh_test (void)
1905 {
1906
1907   START (csinh);
1908
1909   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
1910   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
1911   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
1912   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
1913
1914   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1915   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1916   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1917   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1918
1919   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
1920   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
1921   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
1922   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
1923
1924   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1925   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1926   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1927   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1928
1929   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
1930   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
1931   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
1932   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
1933
1934   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1935   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1936   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1937   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1938
1939   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
1940   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
1941
1942   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1943   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1944
1945   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
1946   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
1947
1948   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
1949   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
1950
1951   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1952   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1953
1954   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1955   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1956
1957   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
1958
1959   TEST_c_c (csinh, 0.7, 1.2, 0.27487868678117583582L, 1.1698665727426565139L);
1960   TEST_c_c (csinh, -2, -3, 3.5905645899857799520L, -0.5309210862485198052L);
1961
1962   END (csinh, complex);
1963 }
1964
1965 static void
1966 csqrt_test (void)
1967 {
1968   START (csqrt);
1969
1970   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
1971   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
1972   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
1973   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
1974
1975   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
1976   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
1977   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
1978   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
1979
1980   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
1981   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
1982   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
1983   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
1984
1985   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
1986   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
1987   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
1988   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
1989   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
1990   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
1991   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
1992   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
1993   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
1994   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
1995   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
1996   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
1997
1998   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1999
2000   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2001
2002   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2003   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2004   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2005   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2006
2007   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2008   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2009   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2010   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2011
2012   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2013
2014   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2015   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2016   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2017   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2018   TEST_c_c (csqrt, 0.7, 1.2, 1.0220676100300264507L, 0.5870453129635652115L);
2019   TEST_c_c (csqrt, -2, -3, 0.8959774761298381247L, -1.6741492280355400404L);
2020   TEST_c_c (csqrt, -2, 3, 0.8959774761298381247L, 1.6741492280355400404L);
2021
2022   END (csqrt, complex);
2023 }
2024
2025 static void
2026 ctan_test (void)
2027 {
2028   START (ctan);
2029
2030   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2031   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2032   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2033   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2034
2035   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2036   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2037   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2038   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2039
2040   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2041   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2042   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2043   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2044
2045   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2046   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2047   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2048   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2049   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2050   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2051   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2052   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2053
2054   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2055   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2056
2057   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2058   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2059
2060   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2061   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2062
2063   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2064   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2065   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2066   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2067
2068   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2069
2070   TEST_c_c (ctan, 0.7, 1.2, 0.1720734197630349001L, 0.9544807059989405538L);
2071   TEST_c_c (ctan, -2, -3, 0.0037640256415042482L, -1.0032386273536098014L);
2072
2073   END (ctan, complex);
2074 }
2075
2076
2077 static void
2078 ctanh_test (void)
2079 {
2080   START (ctanh);
2081
2082   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2083   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2084   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2085   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2086
2087   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2088   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2089   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2090   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2091   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2092   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2093   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2094   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2095
2096   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2097   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2098   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2099   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2100   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2101   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2102   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2103   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2104
2105   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2106   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2107
2108   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2109   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2110
2111   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2112   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2113
2114   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2115   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2116   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2117   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2118
2119   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2120
2121   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2122
2123   TEST_c_c (ctanh, 0.7, 1.2, 1.3472197399061191630L, 0.4778641038326365540L);
2124   TEST_c_c (ctanh, -2, -3, -0.9653858790221331242L, 0.0098843750383224937L);
2125
2126   END (ctanh, complex);
2127 }
2128
2129 static void
2130 erf_test (void)
2131 {
2132   errno = 0;
2133   FUNC(erf) (0);
2134   if (errno == ENOSYS)
2135     /* Function not implemented.  */
2136     return;
2137
2138   START (erf);
2139
2140   TEST_f_f (erf, 0, 0);
2141   TEST_f_f (erf, minus_zero, minus_zero);
2142   TEST_f_f (erf, plus_infty, 1);
2143   TEST_f_f (erf, minus_infty, -1);
2144   TEST_f_f (erf, nan_value, nan_value);
2145
2146   TEST_f_f (erf, 0.7, 0.67780119383741847297L);
2147
2148   TEST_f_f (erf, 1.2, 0.91031397822963538024L);
2149   TEST_f_f (erf, 2.0, 0.99532226501895273416L);
2150   TEST_f_f (erf, 4.1, 0.99999999329997234592L);
2151   TEST_f_f (erf, 27, 1.0L);
2152
2153   END (erf);
2154 }
2155
2156
2157 static void
2158 erfc_test (void)
2159 {
2160   errno = 0;
2161   FUNC(erfc) (0);
2162   if (errno == ENOSYS)
2163     /* Function not implemented.  */
2164     return;
2165
2166   START (erfc);
2167
2168   TEST_f_f (erfc, plus_infty, 0.0);
2169   TEST_f_f (erfc, minus_infty, 2.0);
2170   TEST_f_f (erfc, 0.0, 1.0);
2171   TEST_f_f (erfc, minus_zero, 1.0);
2172   TEST_f_f (erfc, nan_value, nan_value);
2173
2174   TEST_f_f (erfc, 0.7, 0.32219880616258152702L);
2175
2176   TEST_f_f (erfc, 1.2, 0.089686021770364619762L);
2177   TEST_f_f (erfc, 2.0, 0.0046777349810472658379L);
2178   TEST_f_f (erfc, 4.1, 0.67000276540848983727e-8L);
2179   TEST_f_f (erfc, 9, 0.41370317465138102381e-36L);
2180
2181   END (erfc);
2182 }
2183
2184 static void
2185 exp_test (void)
2186 {
2187   START (exp);
2188
2189   TEST_f_f (exp, 0, 1);
2190   TEST_f_f (exp, minus_zero, 1);
2191
2192 #ifndef TEST_INLINE
2193   TEST_f_f (exp, plus_infty, plus_infty);
2194   TEST_f_f (exp, minus_infty, 0);
2195 #endif
2196   TEST_f_f (exp, nan_value, nan_value);
2197   TEST_f_f (exp, 1, M_El);
2198
2199   TEST_f_f (exp, 2, M_E2l);
2200   TEST_f_f (exp, 3, M_E3l);
2201   TEST_f_f (exp, 0.7, 2.0137527074704765216L);
2202
2203   END (exp);
2204 }
2205
2206
2207 static void
2208 exp10_test (void)
2209 {
2210   errno = 0;
2211   FUNC(exp10) (0);
2212   if (errno == ENOSYS)
2213     /* Function not implemented.  */
2214     return;
2215
2216   START (exp10);
2217
2218   TEST_f_f (exp10, 0, 1);
2219   TEST_f_f (exp10, minus_zero, 1);
2220
2221   TEST_f_f (exp10, plus_infty, plus_infty);
2222   TEST_f_f (exp10, minus_infty, 0);
2223   TEST_f_f (exp10, nan_value, nan_value);
2224   TEST_f_f (exp10, 3, 1000);
2225   TEST_f_f (exp10, -1, 0.1);
2226   TEST_f_f (exp10, 1e6, plus_infty);
2227   TEST_f_f (exp10, -1e6, 0);
2228   TEST_f_f (exp10, 0.7, 5.0118723362727228500L);
2229
2230   END (exp10);
2231 }
2232
2233 static void
2234 exp2_test (void)
2235 {
2236   errno = 0;
2237   FUNC(exp2) (0);
2238   if (errno == ENOSYS)
2239     /* Function not implemented.  */
2240     return;
2241
2242   START (exp2);
2243
2244   TEST_f_f (exp2, 0, 1);
2245   TEST_f_f (exp2, minus_zero, 1);
2246   TEST_f_f (exp2, plus_infty, plus_infty);
2247   TEST_f_f (exp2, minus_infty, 0);
2248   TEST_f_f (exp2, nan_value, nan_value);
2249
2250   TEST_f_f (exp2, 10, 1024);
2251   TEST_f_f (exp2, -1, 0.5);
2252   TEST_f_f (exp2, 1e6, plus_infty);
2253   TEST_f_f (exp2, -1e6, 0);
2254   TEST_f_f (exp2, 0.7, 1.6245047927124710452L);
2255
2256   END (exp2);
2257 }
2258
2259 static void
2260 expm1_test (void)
2261 {
2262   START (expm1);
2263
2264   TEST_f_f (expm1, 0, 0);
2265   TEST_f_f (expm1, minus_zero, minus_zero);
2266
2267 #ifndef TEST_INLINE
2268   TEST_f_f (expm1, plus_infty, plus_infty);
2269   TEST_f_f (expm1, minus_infty, -1);
2270 #endif
2271   TEST_f_f (expm1, nan_value, nan_value);
2272
2273   TEST_f_f (expm1, 1, M_El - 1.0);
2274   TEST_f_f (expm1, 0.7, 1.0137527074704765216L);
2275
2276   END (expm1);
2277 }
2278
2279 static void
2280 fabs_test (void)
2281 {
2282   START (fabs);
2283
2284   TEST_f_f (fabs, 0, 0);
2285   TEST_f_f (fabs, minus_zero, 0);
2286
2287   TEST_f_f (fabs, plus_infty, plus_infty);
2288   TEST_f_f (fabs, minus_infty, plus_infty);
2289   TEST_f_f (fabs, nan_value, nan_value);
2290
2291   TEST_f_f (fabs, 38.0, 38.0);
2292   TEST_f_f (fabs, -M_El, M_El);
2293
2294   END (fabs);
2295 }
2296
2297 static void
2298 fdim_test (void)
2299 {
2300   START (fdim);
2301
2302   TEST_ff_f (fdim, 0, 0, 0);
2303   TEST_ff_f (fdim, 9, 0, 9);
2304   TEST_ff_f (fdim, 0, 9, 0);
2305   TEST_ff_f (fdim, -9, 0, 0);
2306   TEST_ff_f (fdim, 0, -9, 9);
2307
2308   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2309   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2310   TEST_ff_f (fdim, minus_infty, 9, 0);
2311   TEST_ff_f (fdim, minus_infty, -9, 0);
2312   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2313   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2314   TEST_ff_f (fdim, 9, plus_infty, 0);
2315   TEST_ff_f (fdim, -9, plus_infty, 0);
2316
2317   TEST_ff_f (fdim, 0, nan_value, nan_value);
2318   TEST_ff_f (fdim, 9, nan_value, nan_value);
2319   TEST_ff_f (fdim, -9, nan_value, nan_value);
2320   TEST_ff_f (fdim, nan_value, 9, nan_value);
2321   TEST_ff_f (fdim, nan_value, -9, nan_value);
2322   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2323   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2324   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2325   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2326   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2327
2328   END (fdim);
2329 }
2330
2331 static void
2332 floor_test (void)
2333 {
2334   START (floor);
2335
2336   TEST_f_f (floor, 0.0, 0.0);
2337   TEST_f_f (floor, minus_zero, minus_zero);
2338   TEST_f_f (floor, plus_infty, plus_infty);
2339   TEST_f_f (floor, minus_infty, minus_infty);
2340   TEST_f_f (floor, nan_value, nan_value);
2341
2342   TEST_f_f (floor, M_PIl, 3.0);
2343   TEST_f_f (floor, -M_PIl, -4.0);
2344
2345   END (floor);
2346 }
2347
2348 static void
2349 fma_test (void)
2350 {
2351   START (fma);
2352
2353   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2354   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2355   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2356   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2357   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2358   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2359   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2360   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2361   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2362   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2363   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2364   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2365
2366   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2367   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2368   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2369   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2370
2371   END (fma);
2372 }
2373
2374
2375 static void
2376 fmax_test (void)
2377 {
2378   START (fmax);
2379
2380   TEST_ff_f (fmax, 0, 0, 0);
2381   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2382   TEST_ff_f (fmax, 9, 0, 9);
2383   TEST_ff_f (fmax, 0, 9, 9);
2384   TEST_ff_f (fmax, -9, 0, 0);
2385   TEST_ff_f (fmax, 0, -9, 0);
2386
2387   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2388   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2389   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2390   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2391
2392   TEST_ff_f (fmax, minus_infty, 9, 9);
2393   TEST_ff_f (fmax, minus_infty, -9, -9);
2394   TEST_ff_f (fmax, 9, minus_infty, 9);
2395   TEST_ff_f (fmax, -9, minus_infty, -9);
2396
2397   TEST_ff_f (fmax, 0, nan_value, 0);
2398   TEST_ff_f (fmax, 9, nan_value, 9);
2399   TEST_ff_f (fmax, -9, nan_value, -9);
2400   TEST_ff_f (fmax, nan_value, 0, 0);
2401   TEST_ff_f (fmax, nan_value, 9, 9);
2402   TEST_ff_f (fmax, nan_value, -9, -9);
2403   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2404   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2405   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2406   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2407   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2408
2409   END (fmax);
2410 }
2411
2412
2413 static void
2414 fmin_test (void)
2415 {
2416   START (fmin);
2417
2418   TEST_ff_f (fmin, 0, 0, 0);
2419   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2420   TEST_ff_f (fmin, 9, 0, 0);
2421   TEST_ff_f (fmin, 0, 9, 0);
2422   TEST_ff_f (fmin, -9, 0, -9);
2423   TEST_ff_f (fmin, 0, -9, -9);
2424
2425   TEST_ff_f (fmin, plus_infty, 9, 9);
2426   TEST_ff_f (fmin, 9, plus_infty, 9);
2427   TEST_ff_f (fmin, plus_infty, -9, -9);
2428   TEST_ff_f (fmin, -9, plus_infty, -9);
2429   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2430   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2431   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2432   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2433
2434   TEST_ff_f (fmin, 0, nan_value, 0);
2435   TEST_ff_f (fmin, 9, nan_value, 9);
2436   TEST_ff_f (fmin, -9, nan_value, -9);
2437   TEST_ff_f (fmin, nan_value, 0, 0);
2438   TEST_ff_f (fmin, nan_value, 9, 9);
2439   TEST_ff_f (fmin, nan_value, -9, -9);
2440   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2441   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2442   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2443   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2444   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2445
2446   END (fmin);
2447 }
2448
2449
2450 static void
2451 fmod_test (void)
2452 {
2453
2454   START (fmod);
2455
2456   /* fmod (+0, y) == +0 for y != 0.  */
2457   TEST_ff_f (fmod, 0, 3, 0);
2458
2459   /* fmod (-0, y) == -0 for y != 0.  */
2460   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2461
2462   /* fmod (+inf, y) == NaN plus invalid exception.  */
2463   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2464   /* fmod (-inf, y) == NaN plus invalid exception.  */
2465   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2466   /* fmod (x, +0) == NaN plus invalid exception.  */
2467   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2468   /* fmod (x, -0) == NaN plus invalid exception.  */
2469   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2470
2471   /* fmod (x, +inf) == x for x not infinite.  */
2472   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2473   /* fmod (x, -inf) == x for x not infinite.  */
2474   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2475
2476   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2477
2478   TEST_ff_f (fmod, 6.5, 2.3, 1.9);
2479   TEST_ff_f (fmod, -6.5, 2.3, -1.9);
2480   TEST_ff_f (fmod, 6.5, -2.3, 1.9);
2481   TEST_ff_f (fmod, -6.5, -2.3, -1.9);
2482
2483   END (fmod);
2484 }
2485
2486 static void
2487 fpclassify_test (void)
2488 {
2489   START (fpclassify);
2490
2491   TEST_f_i (fpclassify, nan_value, FP_NAN);
2492   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2493   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2494   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2495   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2496   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2497
2498   END (fpclassify);
2499 }
2500
2501
2502 static void
2503 frexp_test (void)
2504 {
2505   int x;
2506
2507   START (frexp);
2508
2509   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2510   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2511   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2512
2513   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2514   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2515
2516   TEST_fI_f1 (frexp, 12.8, 0.8, 4);
2517   TEST_fI_f1 (frexp, -27.34, -0.854375, 5);
2518
2519   END (frexp);
2520 }
2521
2522
2523 static void
2524 gamma_test (void)
2525 {
2526   errno = 0;
2527   FUNC(gamma) (1);
2528
2529   if (errno == ENOSYS)
2530     /* Function not implemented.  */
2531     return;
2532   feclearexcept (FE_ALL_EXCEPT);
2533
2534   START (gamma);
2535
2536   TEST_f_f (gamma, plus_infty, plus_infty);
2537   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2538   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2539   TEST_f_f (gamma, minus_infty, plus_infty);
2540   TEST_f_f (gamma, nan_value, nan_value);
2541
2542   TEST_f_f1 (gamma, 1, 0, 1);
2543   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2544
2545   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2546   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2547
2548   END (gamma);
2549 }
2550
2551 static void
2552 hypot_test (void)
2553 {
2554   START (hypot);
2555
2556   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2557   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2558
2559 #ifndef TEST_INLINE
2560   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2561   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2562   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2563   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2564 #endif
2565
2566   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2567
2568   /* hypot (x,y) == hypot (+-x, +-y)  */
2569   TEST_ff_f (hypot, 0.7, 12.4, 12.41974234837422060118L);
2570   TEST_ff_f (hypot, -0.7, 12.4, 12.41974234837422060118L);
2571   TEST_ff_f (hypot, 0.7, -12.4, 12.41974234837422060118L);
2572   TEST_ff_f (hypot, -0.7, -12.4, 12.41974234837422060118L);
2573   TEST_ff_f (hypot, 12.4, 0.7, 12.41974234837422060118L);
2574   TEST_ff_f (hypot, -12.4, 0.7, 12.41974234837422060118L);
2575   TEST_ff_f (hypot, 12.4, -0.7, 12.41974234837422060118L);
2576   TEST_ff_f (hypot, -12.4, -0.7, 12.41974234837422060118L);
2577
2578   /*  hypot (x,0) == fabs (x)  */
2579   TEST_ff_f (hypot, 0.7, 0, 0.7);
2580   TEST_ff_f (hypot, -0.7, 0, 0.7);
2581   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7);
2582
2583   TEST_ff_f (hypot, 0.7, 1.2, 1.3892443989449804508L);
2584
2585   END (hypot);
2586 }
2587
2588
2589 static void
2590 ilogb_test (void)
2591 {
2592   START (ilogb);
2593
2594   TEST_f_i (ilogb, 1, 0);
2595   TEST_f_i (ilogb, M_El, 1);
2596   TEST_f_i (ilogb, 1024, 10);
2597   TEST_f_i (ilogb, -2000, 10);
2598
2599   /* XXX We have a problem here: the standard does not tell us whether
2600      exceptions are allowed/required.  ignore them for now.  */
2601
2602   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2603   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2604
2605   END (ilogb);
2606 }
2607
2608 static void
2609 isfinite_test (void)
2610 {
2611   START (isfinite);
2612
2613   TEST_f_b (isfinite, 0, 1);
2614   TEST_f_b (isfinite, minus_zero, 1);
2615   TEST_f_b (isfinite, 10, 1);
2616   TEST_f_b (isfinite, plus_infty, 0);
2617   TEST_f_b (isfinite, minus_infty, 0);
2618   TEST_f_b (isfinite, nan_value, 0);
2619
2620   END (isfinite);
2621 }
2622
2623 static void
2624 isnormal_test (void)
2625 {
2626   START (isnormal);
2627
2628   TEST_f_b (isnormal, 0, 0);
2629   TEST_f_b (isnormal, minus_zero, 0);
2630   TEST_f_b (isnormal, 10, 1);
2631   TEST_f_b (isnormal, plus_infty, 0);
2632   TEST_f_b (isnormal, minus_infty, 0);
2633   TEST_f_b (isnormal, nan_value, 0);
2634
2635   END (isnormal);
2636 }
2637
2638 static void
2639 j0_test (void)
2640 {
2641   errno = 0;
2642   FUNC(j0) (0);
2643   if (errno == ENOSYS)
2644     /* Function not implemented.  */
2645     return;
2646
2647   START (j0);
2648
2649   /* j0 is the Bessel function of the first kind of order 0 */
2650   TEST_f_f (j0, nan_value, nan_value);
2651   TEST_f_f (j0, plus_infty, 0);
2652   TEST_f_f (j0, -1.0, 0.76519768655796655145);
2653   TEST_f_f (j0, 0.0, 1.0);
2654   TEST_f_f (j0, 0.1, 0.99750156206604003228);
2655   TEST_f_f (j0, 0.7, 0.88120088860740528084);
2656   TEST_f_f (j0, 1.0, 0.76519768655796655145);
2657   TEST_f_f (j0, 1.5, 0.51182767173591812875);
2658   TEST_f_f (j0, 2.0, 0.22389077914123566805);
2659   TEST_f_f (j0, 8.0, 0.17165080713755390609);
2660   TEST_f_f (j0, 10.0, -0.24593576445134833520);
2661
2662   END (j0);
2663 }
2664
2665
2666 static void
2667 j1_test (void)
2668 {
2669   errno = 0;
2670   FUNC(j1) (0);
2671   if (errno == ENOSYS)
2672     /* Function not implemented.  */
2673     return;
2674
2675   /* j1 is the Bessel function of the first kind of order 1 */
2676
2677   START (j1);
2678
2679   TEST_f_f (j1, nan_value, nan_value);
2680   TEST_f_f (j1, plus_infty, 0);
2681
2682   TEST_f_f (j1, -1.0, -0.44005058574493351596);
2683   TEST_f_f (j1, 0.0, 0.0);
2684   TEST_f_f (j1, 0.1, 0.049937526036241997556);
2685   TEST_f_f (j1, 0.7, 0.32899574154005894785);
2686   TEST_f_f (j1, 1.0, 0.44005058574493351596);
2687   TEST_f_f (j1, 1.5, 0.55793650791009964199);
2688   TEST_f_f (j1, 2.0, 0.57672480775687338720);
2689   TEST_f_f (j1, 8.0, 0.23463634685391462438);
2690   TEST_f_f (j1, 10.0, 0.043472746168861436670);
2691
2692   END (j1);
2693 }
2694
2695 static void
2696 jn_test (void)
2697 {
2698   errno = 0;
2699   FUNC(jn) (1, 1);
2700   if (errno == ENOSYS)
2701     /* Function not implemented.  */
2702     return;
2703
2704   /* jn is the Bessel function of the first kind of order n.  */
2705   START (jn);
2706
2707   /* jn (0, x) == j0 (x)  */
2708   TEST_ff_f (jn, 0, nan_value, nan_value);
2709   TEST_ff_f (jn, 0, plus_infty, 0);
2710   TEST_ff_f (jn, 0, -1.0, 0.76519768655796655145);
2711   TEST_ff_f (jn, 0, 0.0, 1.0);
2712   TEST_ff_f (jn, 0, 0.1, 0.99750156206604003228);
2713   TEST_ff_f (jn, 0, 0.7, 0.88120088860740528084);
2714   TEST_ff_f (jn, 0, 1.0, 0.76519768655796655145);
2715   TEST_ff_f (jn, 0, 1.5, 0.51182767173591812875);
2716   TEST_ff_f (jn, 0, 2.0, 0.22389077914123566805);
2717   TEST_ff_f (jn, 0, 8.0, 0.17165080713755390609);
2718   TEST_ff_f (jn, 0, 10.0, -0.24593576445134833520);
2719
2720   /* jn (1, x) == j1 (x)  */
2721   TEST_ff_f (jn, 1, nan_value, nan_value);
2722   TEST_ff_f (jn, 1, plus_infty, 0);
2723
2724   TEST_ff_f (jn, 1, -1.0, -0.44005058574493351596);
2725   TEST_ff_f (jn, 1, 0.0, 0.0);
2726   TEST_ff_f (jn, 1, 0.1, 0.049937526036241997556);
2727   TEST_ff_f (jn, 1, 0.7, 0.32899574154005894785);
2728   TEST_ff_f (jn, 1, 1.0, 0.44005058574493351596);
2729   TEST_ff_f (jn, 1, 1.5, 0.55793650791009964199);
2730   TEST_ff_f (jn, 1, 2.0, 0.57672480775687338720);
2731   TEST_ff_f (jn, 1, 8.0, 0.23463634685391462438);
2732   TEST_ff_f (jn, 1, 10.0, 0.043472746168861436670);
2733
2734   /* jn (3, x)  */
2735   TEST_ff_f (jn, 3, nan_value, nan_value);
2736   TEST_ff_f (jn, 3, plus_infty, 0);
2737
2738   TEST_ff_f (jn, 3, -1.0, -0.019563353982668405919);
2739   TEST_ff_f (jn, 3, 0.0, 0.0);
2740   TEST_ff_f (jn, 3, 0.1, 0.000020820315754756261429);
2741   TEST_ff_f (jn, 3, 0.7, 0.0069296548267508408077);
2742   TEST_ff_f (jn, 3, 1.0, 0.019563353982668405919);
2743   TEST_ff_f (jn, 3, 2.0, 0.12894324947440205110);
2744   TEST_ff_f (jn, 3, 10.0, 0.058379379305186812343);
2745
2746   /*  jn (10, x)  */
2747   TEST_ff_f (jn, 10, nan_value, nan_value);
2748   TEST_ff_f (jn, 10, plus_infty, 0);
2749
2750   TEST_ff_f (jn, 10, -1.0, 0.26306151236874532070e-9);
2751   TEST_ff_f (jn, 10, 0.0, 0.0);
2752   TEST_ff_f (jn, 10, 0.1, 0.26905328954342155795e-19);
2753   TEST_ff_f (jn, 10, 0.7, 0.75175911502153953928e-11);
2754   TEST_ff_f (jn, 10, 1.0, 0.26306151236874532070e-9);
2755   TEST_ff_f (jn, 10, 2.0, 0.25153862827167367096e-6);
2756   TEST_ff_f (jn, 10, 10.0, 0.20748610663335885770);
2757
2758   END (jn);
2759 }
2760
2761
2762 static void
2763 ldexp_test (void)
2764 {
2765   TEST_ff_f (ldexp, 0, 0, 0);
2766   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
2767
2768   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
2769   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
2770   TEST_ff_f (ldexp, nan_value, 1, nan_value);
2771
2772   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
2773   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
2774
2775   /* ldexp (x, 0) == x.  */
2776   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
2777 }
2778
2779 static void
2780 lgamma_test (void)
2781 {
2782   errno = 0;
2783   FUNC(lgamma) (0);
2784   if (errno == ENOSYS)
2785     /* Function not implemented.  */
2786     return;
2787   feclearexcept (FE_ALL_EXCEPT);
2788
2789   START (lgamma);
2790
2791   TEST_f_f (lgamma, plus_infty, plus_infty);
2792   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2793   TEST_f_f (lgamma, nan_value, nan_value);
2794
2795   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
2796   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2797   TEST_f_f (lgamma, minus_infty, plus_infty);
2798
2799   TEST_f_f1 (lgamma, 1, 0, 1);
2800
2801   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
2802
2803   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
2804   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2805   TEST_f_f1 (lgamma, 0.7, 0.26086724653166651439L, 1);
2806   TEST_f_f1 (lgamma, 1.2, -0.853740900033158497197e-1L, 1);
2807
2808   END (lgamma);
2809 }
2810
2811 static void
2812 lrint_test (void)
2813 {
2814   /* XXX this test is incomplete.  We need to have a way to specifiy
2815      the rounding method and test the critical cases.  So far, only
2816      unproblematic numbers are tested.  */
2817
2818   START (lrint);
2819
2820   TEST_f_l (lrint, 0.0, 0);
2821   TEST_f_l (lrint, minus_zero, 0);
2822   TEST_f_l (lrint, 0.2, 0);
2823   TEST_f_l (lrint, -0.2, 0);
2824
2825   TEST_f_l (lrint, 1.4, 1);
2826   TEST_f_l (lrint, -1.4, -1);
2827
2828   TEST_f_l (lrint, 8388600.3, 8388600);
2829   TEST_f_l (lrint, -8388600.3, -8388600);
2830
2831   END (lrint);
2832 }
2833
2834 static void
2835 llrint_test (void)
2836 {
2837   /* XXX this test is incomplete.  We need to have a way to specifiy
2838      the rounding method and test the critical cases.  So far, only
2839      unproblematic numbers are tested.  */
2840
2841   START (llrint);
2842
2843   TEST_f_L (llrint, 0.0, 0);
2844   TEST_f_L (llrint, minus_zero, 0);
2845   TEST_f_L (llrint, 0.2, 0);
2846   TEST_f_L (llrint, -0.2, 0);
2847
2848   TEST_f_L (llrint, 1.4, 1);
2849   TEST_f_L (llrint, -1.4, -1);
2850
2851   TEST_f_L (llrint, 8388600.3, 8388600);
2852   TEST_f_L (llrint, -8388600.3, -8388600);
2853
2854   /* Test boundary conditions.  */
2855   /* 0x1FFFFF */
2856   TEST_f_L (llrint, 2097151.0,2097151LL);
2857   /* 0x800000 */
2858   TEST_f_L (llrint, 8388608.0, 8388608LL);
2859   /* 0x1000000 */
2860   TEST_f_L (llrint, 16777216.0, 16777216LL);
2861   /* 0x20000000000 */
2862   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
2863   /* 0x40000000000 */
2864   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
2865   /* 0x10000000000000 */
2866   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
2867   /* 0x10000080000000 */
2868   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
2869   /* 0x20000000000000 */
2870   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
2871   /* 0x80000000000000 */
2872   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
2873   /* 0x100000000000000 */
2874   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
2875
2876   END (llrint);
2877 }
2878
2879 static void
2880 log_test (void)
2881 {
2882   START (log);
2883
2884   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2885   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2886
2887   TEST_f_f (log, 1, 0);
2888
2889   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
2890   TEST_f_f (log, plus_infty, plus_infty);
2891
2892   TEST_f_f (log, M_El, 1);
2893   TEST_f_f (log, 1.0 / M_El, -1);
2894   TEST_f_f (log, 2, M_LN2l);
2895   TEST_f_f (log, 10, M_LN10l);
2896   TEST_f_f (log, 0.7, -0.35667494393873237891L);
2897
2898   END (log);
2899 }
2900
2901
2902 static void
2903 log10_test (void)
2904 {
2905   START (log10);
2906
2907   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2908   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2909
2910   TEST_f_f (log10, 1, 0);
2911
2912   /* log10 (x) == NaN plus invalid exception if x < 0.  */
2913   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
2914
2915   TEST_f_f (log10, plus_infty, plus_infty);
2916   TEST_f_f (log10, nan_value, nan_value);
2917
2918   TEST_f_f (log10, 0.1L, -1);
2919   TEST_f_f (log10, 10.0, 1);
2920   TEST_f_f (log10, 100.0, 2);
2921   TEST_f_f (log10, 10000.0, 4);
2922   TEST_f_f (log10, M_El, M_LOG10El);
2923   TEST_f_f (log10, 0.7, -0.15490195998574316929L);
2924
2925   END (log10);
2926 }
2927
2928
2929 static void
2930 log1p_test (void)
2931 {
2932   START (log1p);
2933
2934   TEST_f_f (log1p, 0, 0);
2935   TEST_f_f (log1p, minus_zero, minus_zero);
2936
2937   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2938   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
2939
2940   TEST_f_f (log1p, plus_infty, plus_infty);
2941   TEST_f_f (log1p, nan_value, nan_value);
2942
2943   TEST_f_f (log1p, M_El - 1.0, 1);
2944
2945   TEST_f_f (log1p, -0.3, -0.35667494393873237891L);
2946
2947   END (log1p);
2948 }
2949
2950
2951 static void
2952 log2_test (void)
2953 {
2954   START (log2);
2955
2956   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2957   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2958
2959   TEST_f_f (log2, 1, 0);
2960
2961   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
2962
2963   TEST_f_f (log2, plus_infty, plus_infty);
2964   TEST_f_f (log2, nan_value, nan_value);
2965
2966   TEST_f_f (log2, M_El, M_LOG2El);
2967   TEST_f_f (log2, 2.0, 1);
2968   TEST_f_f (log2, 16.0, 4);
2969   TEST_f_f (log2, 256.0, 8);
2970   TEST_f_f (log2, 0.7, -0.51457317282975824043L);
2971
2972   END (log2);
2973 }
2974
2975
2976 static void
2977 logb_test (void)
2978 {
2979   START (logb);
2980
2981   TEST_f_f (logb, plus_infty, plus_infty);
2982   TEST_f_f (logb, minus_infty, plus_infty);
2983
2984   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2985
2986   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2987   TEST_f_f (logb, nan_value, nan_value);
2988
2989   TEST_f_f (logb, 1, 0);
2990   TEST_f_f (logb, M_El, 1);
2991   TEST_f_f (logb, 1024, 10);
2992   TEST_f_f (logb, -2000, 10);
2993
2994   END (logb);
2995 }
2996
2997 static void
2998 lround_test (void)
2999 {
3000   START (lround);
3001
3002   TEST_f_l (lround, 0, 0);
3003   TEST_f_l (lround, minus_zero, 0);
3004   TEST_f_l (lround, 0.2, 0.0);
3005   TEST_f_l (lround, -0.2, 0);
3006   TEST_f_l (lround, 0.5, 1);
3007   TEST_f_l (lround, -0.5, -1);
3008   TEST_f_l (lround, 0.8, 1);
3009   TEST_f_l (lround, -0.8, -1);
3010   TEST_f_l (lround, 1.5, 2);
3011   TEST_f_l (lround, -1.5, -2);
3012   TEST_f_l (lround, 22514.5, 22515);
3013   TEST_f_l (lround, -22514.5, -22515);
3014 #ifndef TEST_FLOAT
3015   TEST_f_l (lround, 2097152.5, 2097153);
3016   TEST_f_l (lround, -2097152.5, -2097153);
3017 #endif
3018   END (lround);
3019 }
3020
3021
3022 static void
3023 llround_test (void)
3024 {
3025   START (llround);
3026
3027   TEST_f_L (llround, 0, 0);
3028   TEST_f_L (llround, minus_zero, 0);
3029   TEST_f_L (llround, 0.2, 0.0);
3030   TEST_f_L (llround, -0.2, 0);
3031   TEST_f_L (llround, 0.5, 1);
3032   TEST_f_L (llround, -0.5, -1);
3033   TEST_f_L (llround, 0.8, 1);
3034   TEST_f_L (llround, -0.8, -1);
3035   TEST_f_L (llround, 1.5, 2);
3036   TEST_f_L (llround, -1.5, -2);
3037   TEST_f_L (llround, 22514.5, 22515);
3038   TEST_f_L (llround, -22514.5, -22515);
3039 #ifndef TEST_FLOAT
3040   TEST_f_L (llround, 2097152.5, 2097153);
3041   TEST_f_L (llround, -2097152.5, -2097153);
3042   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3043   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3044 #endif
3045
3046   /* Test boundary conditions.  */
3047   /* 0x1FFFFF */
3048   TEST_f_L (llround, 2097151.0, 2097151LL);
3049   /* 0x800000 */
3050   TEST_f_L (llround, 8388608.0, 8388608LL);
3051   /* 0x1000000 */
3052   TEST_f_L (llround, 16777216.0, 16777216LL);
3053   /* 0x20000000000 */
3054   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3055   /* 0x40000000000 */
3056   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3057   /* 0x10000000000000 */
3058   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3059   /* 0x10000080000000 */
3060   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3061   /* 0x20000000000000 */
3062   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3063   /* 0x80000000000000 */
3064   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3065   /* 0x100000000000000 */
3066   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3067
3068   END (llround);
3069 }
3070
3071 static void
3072 modf_test (void)
3073 {
3074   FLOAT x;
3075
3076   START (modf);
3077
3078   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3079   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3080   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3081   TEST_fF_f1 (modf, 0, 0, 0);
3082   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3083   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3084   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3085   TEST_fF_f1 (modf, 20, 0, 20);
3086   TEST_fF_f1 (modf, 21, 0, 21);
3087   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3088
3089   END (modf);
3090 }
3091
3092
3093 static void
3094 nearbyint_test (void)
3095 {
3096   START (nearbyint);
3097
3098   TEST_f_f (nearbyint, 0.0, 0.0);
3099   TEST_f_f (nearbyint, minus_zero, minus_zero);
3100   TEST_f_f (nearbyint, plus_infty, plus_infty);
3101   TEST_f_f (nearbyint, minus_infty, minus_infty);
3102   TEST_f_f (nearbyint, nan_value, nan_value);
3103
3104   /* Default rounding mode is round to nearest.  */
3105   TEST_f_f (nearbyint, 0.5, 0.0);
3106   TEST_f_f (nearbyint, 1.5, 2.0);
3107   TEST_f_f (nearbyint, -0.5, minus_zero);
3108   TEST_f_f (nearbyint, -1.5, -2.0);
3109
3110   END (nearbyint);
3111 }
3112
3113 static void
3114 nextafter_test (void)
3115 {
3116
3117   START (nextafter);
3118
3119   TEST_ff_f (nextafter, 0, 0, 0);
3120   TEST_ff_f (nextafter, minus_zero, 0, 0);
3121   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3122   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3123
3124   TEST_ff_f (nextafter, 9, 9, 9);
3125   TEST_ff_f (nextafter, -9, -9, -9);
3126   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3127   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3128
3129   TEST_ff_f (nextafter, nan_value, 1.1, nan_value);
3130   TEST_ff_f (nextafter, 1.1, nan_value, nan_value);
3131   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3132
3133   /* XXX We need the hexadecimal FP number representation here for further
3134      tests.  */
3135
3136   END (nextafter);
3137 }
3138
3139
3140 static void
3141 nexttoward_test (void)
3142 {
3143   START (nexttoward);
3144   TEST_ff_f (nexttoward, 0, 0, 0);
3145   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3146   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3147   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3148
3149   TEST_ff_f (nexttoward, 9, 9, 9);
3150   TEST_ff_f (nexttoward, -9, -9, -9);
3151   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3152   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3153
3154   TEST_ff_f (nexttoward, nan_value, 1.1, nan_value);
3155   TEST_ff_f (nexttoward, 1.1, nan_value, nan_value);
3156   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3157
3158   /* XXX We need the hexadecimal FP number representation here for further
3159      tests.  */
3160
3161   END (nexttoward);
3162 }
3163
3164
3165 static void
3166 pow_test (void)
3167 {
3168
3169   START (pow);
3170
3171   TEST_ff_f (pow, 0, 0, 1);
3172   TEST_ff_f (pow, 0, minus_zero, 1);
3173   TEST_ff_f (pow, minus_zero, 0, 1);
3174   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3175
3176   TEST_ff_f (pow, 10, 0, 1);
3177   TEST_ff_f (pow, 10, minus_zero, 1);
3178   TEST_ff_f (pow, -10, 0, 1);
3179   TEST_ff_f (pow, -10, minus_zero, 1);
3180
3181   TEST_ff_f (pow, nan_value, 0, 1);
3182   TEST_ff_f (pow, nan_value, minus_zero, 1);
3183
3184
3185 #ifndef TEST_INLINE
3186   TEST_ff_f (pow, 1.1, plus_infty, plus_infty);
3187   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3188   TEST_ff_f (pow, -1.1, plus_infty, plus_infty);
3189   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3190
3191   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3192   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3193   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3194   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3195
3196   TEST_ff_f (pow, 1.1, minus_infty, 0);
3197   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3198   TEST_ff_f (pow, -1.1, minus_infty, 0);
3199   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3200
3201   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3202   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3203   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3204   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3205
3206   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3207   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3208   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3209
3210   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3211   TEST_ff_f (pow, plus_infty, -1, 0);
3212   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3213
3214   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3215   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3216   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3217
3218   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3219   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3220   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3221   TEST_ff_f (pow, minus_infty, 0.1, plus_infty);
3222   TEST_ff_f (pow, minus_infty, 1.1, plus_infty);
3223   TEST_ff_f (pow, minus_infty, 11.1, plus_infty);
3224   TEST_ff_f (pow, minus_infty, 1001.1, plus_infty);
3225
3226   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3227   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3228   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3229
3230   TEST_ff_f (pow, minus_infty, -2, 0);
3231   TEST_ff_f (pow, minus_infty, -12, 0);
3232   TEST_ff_f (pow, minus_infty, -1002, 0);
3233   TEST_ff_f (pow, minus_infty, -0.1, 0);
3234   TEST_ff_f (pow, minus_infty, -1.1, 0);
3235   TEST_ff_f (pow, minus_infty, -11.1, 0);
3236   TEST_ff_f (pow, minus_infty, -1001.1, 0);
3237 #endif
3238
3239   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3240   TEST_ff_f (pow, 0, nan_value, nan_value);
3241   TEST_ff_f (pow, 1, nan_value, nan_value);
3242   TEST_ff_f (pow, -1, nan_value, nan_value);
3243   TEST_ff_f (pow, nan_value, 1, nan_value);
3244   TEST_ff_f (pow, nan_value, -1, nan_value);
3245
3246   /* pow (x, NaN) == NaN.  */
3247   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3248
3249   TEST_ff_f (pow, 1, plus_infty, nan_value, INVALID_EXCEPTION);
3250   TEST_ff_f (pow, -1, plus_infty, nan_value, INVALID_EXCEPTION);
3251   TEST_ff_f (pow, 1, minus_infty, nan_value, INVALID_EXCEPTION);
3252   TEST_ff_f (pow, -1, minus_infty, nan_value, INVALID_EXCEPTION);
3253
3254   TEST_ff_f (pow, -0.1, 1.1, nan_value, INVALID_EXCEPTION);
3255   TEST_ff_f (pow, -0.1, -1.1, nan_value, INVALID_EXCEPTION);
3256   TEST_ff_f (pow, -10.1, 1.1, nan_value, INVALID_EXCEPTION);
3257   TEST_ff_f (pow, -10.1, -1.1, nan_value, INVALID_EXCEPTION);
3258
3259   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3260   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3261   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3262   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3263
3264   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3265   TEST_ff_f (pow, 0, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3266   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3267   TEST_ff_f (pow, minus_zero, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3268
3269
3270   TEST_ff_f (pow, 0, 1, 0);
3271   TEST_ff_f (pow, 0, 11, 0);
3272
3273   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3274   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3275
3276
3277   TEST_ff_f (pow, 0, 2, 0);
3278   TEST_ff_f (pow, 0, 11.1, 0);
3279
3280
3281   TEST_ff_f (pow, minus_zero, 2, 0);
3282   TEST_ff_f (pow, minus_zero, 11.1, 0);
3283
3284 #ifndef TEST_INLINE
3285   /* pow (x, +inf) == +inf for |x| > 1.  */
3286   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3287
3288   /* pow (x, +inf) == +0 for |x| < 1.  */
3289   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3290
3291   /* pow (x, -inf) == +0 for |x| > 1.  */
3292   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3293
3294   /* pow (x, -inf) == +inf for |x| < 1.  */
3295   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3296 #endif
3297
3298   /* pow (+inf, y) == +inf for y > 0.  */
3299   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3300
3301   /* pow (+inf, y) == +0 for y < 0.  */
3302   TEST_ff_f (pow, plus_infty, -1, 0.0);
3303
3304   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3305   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3306
3307   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3308   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3309
3310   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3311   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3312   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3313   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3314
3315   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3316   TEST_ff_f (pow, 0.0, 27, 0.0);
3317
3318   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3319   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3320
3321   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3322   TEST_ff_f (pow, 0.0, 4, 0.0);
3323
3324   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3325   TEST_ff_f (pow, minus_zero, 4, 0.0);
3326
3327   TEST_ff_f (pow, 0.7, 1.2, 0.65180494056638638188L);
3328
3329 #ifdef TEST_DOUBLE
3330   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3331 #endif
3332
3333   END (pow);
3334 }
3335
3336 static void
3337 remainder_test (void)
3338 {
3339
3340   START (remainder);
3341
3342   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3343   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3344   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3345   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3346   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3347
3348   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3349   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3350   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3351   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3352   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3353   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3354
3355   END (remainder);
3356 }
3357
3358 static void
3359 remquo_test (void)
3360 {
3361   /* x is needed.  */
3362   int x;
3363
3364   START (remquo);
3365
3366   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3367   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3368   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3369   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3370   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3371
3372   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3373   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3374   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3375   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3376
3377   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3378   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3379
3380   END (remquo);
3381 }
3382
3383 static void
3384 rint_test (void)
3385 {
3386   START (rint);
3387
3388   TEST_f_f (rint, 0.0, 0.0);
3389   TEST_f_f (rint, minus_zero, minus_zero);
3390   TEST_f_f (rint, plus_infty, plus_infty);
3391   TEST_f_f (rint, minus_infty, minus_infty);
3392
3393   /* Default rounding mode is round to nearest.  */
3394   TEST_f_f (rint, 0.5, 0.0);
3395   TEST_f_f (rint, 1.5, 2.0);
3396   TEST_f_f (rint, -0.5, -0.0);
3397   TEST_f_f (rint, -1.5, -2.0);
3398
3399   END (rint);
3400 }
3401
3402 static void
3403 round_test (void)
3404 {
3405   START (round);
3406
3407   TEST_f_f (round, 0, 0);
3408   TEST_f_f (round, minus_zero, minus_zero);
3409   TEST_f_f (round, 0.2, 0.0);
3410   TEST_f_f (round, -0.2, minus_zero);
3411   TEST_f_f (round, 0.5, 1.0);
3412   TEST_f_f (round, -0.5, -1.0);
3413   TEST_f_f (round, 0.8, 1.0);
3414   TEST_f_f (round, -0.8, -1.0);
3415   TEST_f_f (round, 1.5, 2.0);
3416   TEST_f_f (round, -1.5, -2.0);
3417   TEST_f_f (round, 2097152.5, 2097153);
3418   TEST_f_f (round, -2097152.5, -2097153);
3419
3420   END (round);
3421 }
3422
3423
3424 static void
3425 scalb_test (void)
3426 {
3427
3428   START (scalb);
3429
3430   TEST_ff_f (scalb, 2.0, 0.5, nan_value);
3431   TEST_ff_f (scalb, 3.0, -2.5, nan_value);
3432
3433   TEST_ff_f (scalb, 0, nan_value, nan_value);
3434   TEST_ff_f (scalb, 1, nan_value, nan_value);
3435
3436   TEST_ff_f (scalb, 1, 0, 1);
3437   TEST_ff_f (scalb, -1, 0, -1);
3438
3439   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3440   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3441
3442   TEST_ff_f (scalb, 0, 2, 0);
3443   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3444   TEST_ff_f (scalb, 0, 0, 0);
3445   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3446   TEST_ff_f (scalb, 0, -1, 0);
3447   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3448   TEST_ff_f (scalb, 0, minus_infty, 0);
3449   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3450
3451   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3452   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3453   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3454   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3455   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3456   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3457
3458   TEST_ff_f (scalb, 0.1, minus_infty, 0.0);
3459   TEST_ff_f (scalb, -0.1, minus_infty, minus_zero);
3460
3461   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3462   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3463   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3464   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3465
3466   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value);
3467   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value);
3468
3469   TEST_ff_f (scalb, nan_value, 1, nan_value);
3470   TEST_ff_f (scalb, 1, nan_value, nan_value);
3471   TEST_ff_f (scalb, nan_value, 0, nan_value);
3472   TEST_ff_f (scalb, 0, nan_value, nan_value);
3473   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3474   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3475   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3476
3477   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3478   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3479
3480   END (scalb);
3481 }
3482
3483
3484 static void
3485 scalbn_test (void)
3486 {
3487
3488   START (scalbn);
3489
3490   TEST_fi_f (scalbn, 0, 0, 0);
3491   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3492
3493   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
3494   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
3495   TEST_fi_f (scalbn, nan_value, 1, nan_value);
3496
3497   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
3498   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
3499
3500   TEST_fi_f (scalbn, 1, 0L, 1);
3501
3502   END (scalbn);
3503 }
3504
3505 static void
3506 scalbln_test (void)
3507 {
3508
3509   START (scalbln);
3510
3511   TEST_fl_f (scalbln, 0, 0, 0);
3512   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
3513
3514   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
3515   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
3516   TEST_fl_f (scalbln, nan_value, 1, nan_value);
3517
3518   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
3519   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
3520
3521   TEST_fl_f (scalbln, 1, 0L, 1);
3522
3523   END (scalbn);
3524 }
3525
3526 static void
3527 signbit_test (void)
3528 {
3529
3530   START (signbit);
3531
3532   TEST_f_b (signbit, 0, 0);
3533   TEST_f_b (signbit, minus_zero, 1);
3534   TEST_f_b (signbit, plus_infty, 0);
3535   TEST_f_b (signbit, minus_infty, 1);
3536
3537   /* signbit (x) != 0 for x < 0.  */
3538   TEST_f_b (signbit, -1, 1);
3539   /* signbit (x) == 0 for x >= 0.  */
3540   TEST_f_b (signbit, 1, 0);
3541
3542   END (signbit);
3543 }
3544
3545 static void
3546 sin_test (void)
3547 {
3548   START (sin);
3549
3550   TEST_f_f (sin, 0, 0);
3551   TEST_f_f (sin, minus_zero, minus_zero);
3552   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
3553   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
3554   TEST_f_f (sin, nan_value, nan_value);
3555
3556   TEST_f_f (sin, M_PI_6l, 0.5);
3557   TEST_f_f (sin, -M_PI_6l, -0.5);
3558   TEST_f_f (sin, M_PI_2l, 1);
3559   TEST_f_f (sin, -M_PI_2l, -1);
3560   TEST_f_f (sin, 0.7, 0.64421768723769105367L);
3561
3562   END (sin);
3563
3564 }
3565
3566 static void
3567 sincos_test (void)
3568 {
3569   FLOAT sin_res, cos_res;
3570
3571   START (sincos);
3572
3573   /* sincos is treated differently because it returns void.  */
3574   TEST_extra (sincos, 0, 0, 1);
3575
3576   TEST_extra (sincos, minus_zero, minus_zero, 1);
3577   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3578   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3579   TEST_extra (sincos, nan_value, nan_value, nan_value);
3580
3581   TEST_extra (sincos, M_PI_2l, 1, 0);
3582   TEST_extra (sincos, M_PI_6l, 0.5, 0.866025403784438646764L);
3583   TEST_extra (sincos, M_PI_6l*2.0, 0.866025403784438646764L, 0.5);
3584   TEST_extra (sincos, 0.7, 0.64421768723769105367L, 0.76484218728448842626L);
3585
3586   END (sincos);
3587 }
3588
3589 static void
3590 sinh_test (void)
3591 {
3592   START (sinh);
3593   TEST_f_f (sinh, 0, 0);
3594   TEST_f_f (sinh, minus_zero, minus_zero);
3595
3596 #ifndef TEST_INLINE
3597   TEST_f_f (sinh, plus_infty, plus_infty);
3598   TEST_f_f (sinh, minus_infty, minus_infty);
3599 #endif
3600   TEST_f_f (sinh, nan_value, nan_value);
3601
3602   TEST_f_f (sinh, 0.7, 0.75858370183953350346L);
3603
3604   END (sinh);
3605 }
3606
3607 static void
3608 sqrt_test (void)
3609 {
3610   START (sqrt);
3611
3612   TEST_f_f (sqrt, 0, 0);
3613   TEST_f_f (sqrt, nan_value, nan_value);
3614   TEST_f_f (sqrt, plus_infty, plus_infty);
3615
3616   TEST_f_f (sqrt, minus_zero, minus_zero);
3617
3618   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
3619   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
3620   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
3621   TEST_f_f (sqrt, nan_value, nan_value);
3622
3623   TEST_f_f (sqrt, 2209, 47);
3624   TEST_f_f (sqrt, 4, 2);
3625   TEST_f_f (sqrt, 2, M_SQRT2l);
3626   TEST_f_f (sqrt, 0.25, 0.5);
3627   TEST_f_f (sqrt, 6642.25, 81.5);
3628   TEST_f_f (sqrt, 15239.9025, 123.45);
3629   TEST_f_f (sqrt, 0.7, 0.83666002653407554798L);
3630
3631   END (sqrt);
3632 }
3633
3634 static void
3635 tan_test (void)
3636 {
3637   START (tan);
3638
3639   TEST_f_f (tan, 0, 0);
3640   TEST_f_f (tan, minus_zero, minus_zero);
3641   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
3642   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
3643   TEST_f_f (tan, nan_value, nan_value);
3644
3645   TEST_f_f (tan, M_PI_4l, 1);
3646   TEST_f_f (tan, 0.7, 0.84228838046307944813L);
3647
3648   END (tan);
3649 }
3650
3651 static void
3652 tanh_test (void)
3653 {
3654   START (tanh);
3655
3656   TEST_f_f (tanh, 0, 0);
3657   TEST_f_f (tanh, minus_zero, minus_zero);
3658
3659 #ifndef TEST_INLINE
3660   TEST_f_f (tanh, plus_infty, 1);
3661   TEST_f_f (tanh, minus_infty, -1);
3662 #endif
3663   TEST_f_f (tanh, nan_value, nan_value);
3664
3665   TEST_f_f (tanh, 0.7, 0.60436777711716349631L);
3666
3667   END (tanh);
3668 }
3669
3670 static void
3671 tgamma_test (void)
3672 {
3673   errno = 0;
3674   FUNC(tgamma) (1);
3675   if (errno == ENOSYS)
3676     /* Function not implemented.  */
3677     return;
3678   feclearexcept (FE_ALL_EXCEPT);
3679
3680   START (tgamma);
3681
3682   TEST_f_f (tgamma, plus_infty, plus_infty);
3683   TEST_f_f (tgamma, 0, nan_value, INVALID_EXCEPTION);
3684   TEST_f_f (tgamma, minus_zero, nan_value, INVALID_EXCEPTION);
3685   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
3686   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
3687   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
3688   TEST_f_f (tgamma, nan_value, nan_value);
3689
3690   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
3691   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
3692
3693   TEST_f_f (tgamma, 1, 1);
3694   TEST_f_f (tgamma, 4, 6);
3695
3696   TEST_f_f (tgamma, 0.7, 1.29805533264755778568L);
3697   TEST_f_f (tgamma, 1.2, 0.91816874239976061064L);
3698
3699   END (tgamma);
3700 }
3701
3702 static void
3703 trunc_test (void)
3704 {
3705   START (trunc);
3706
3707   TEST_f_f (trunc, plus_infty, plus_infty);
3708   TEST_f_f (trunc, minus_infty, minus_infty);
3709   TEST_f_f (trunc, nan_value, nan_value);
3710
3711   TEST_f_f (trunc, 0, 0);
3712   TEST_f_f (trunc, minus_zero, minus_zero);
3713   TEST_f_f (trunc, 0.625, 0);
3714   TEST_f_f (trunc, -0.625, minus_zero);
3715   TEST_f_f (trunc, 1, 1);
3716   TEST_f_f (trunc, -1, -1);
3717   TEST_f_f (trunc, 1.625, 1);
3718   TEST_f_f (trunc, -1.625, -1);
3719
3720   TEST_f_f (trunc, 1048580.625L, 1048580L);
3721   TEST_f_f (trunc, -1048580.625L, -1048580L);
3722
3723   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
3724   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
3725
3726   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
3727   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
3728
3729
3730   END (trunc);
3731 }
3732
3733 static void
3734 y0_test (void)
3735 {
3736   errno = 0;
3737   FUNC(y0) (1);
3738   if (errno == ENOSYS)
3739     /* Function not implemented.  */
3740     return;
3741
3742   /* y0 is the Bessel function of the second kind of order 0 */
3743   START (y0);
3744
3745   TEST_f_f (y0, -1.0, minus_infty);
3746   TEST_f_f (y0, 0.0, minus_infty);
3747   TEST_f_f (y0, nan_value, nan_value);
3748   TEST_f_f (y0, plus_infty, 0);
3749
3750   TEST_f_f (y0, 0.1, -1.5342386513503668441);
3751   TEST_f_f (y0, 0.7, -0.19066492933739506743);
3752   TEST_f_f (y0, 1.0, 0.088256964215676957983);
3753   TEST_f_f (y0, 1.5, 0.38244892379775884396);
3754   TEST_f_f (y0, 2.0, 0.51037567264974511960);
3755   TEST_f_f (y0, 8.0, 0.22352148938756622053);
3756   TEST_f_f (y0, 10.0, 0.055671167283599391424);
3757
3758   END (y0);
3759 }
3760
3761
3762 static void
3763 y1_test (void)
3764 {
3765   errno = 0;
3766   FUNC(y1) (1);
3767   if (errno == ENOSYS)
3768     /* Function not implemented.  */
3769     return;
3770
3771   /* y1 is the Bessel function of the second kind of order 1 */
3772   START (y1);
3773
3774   TEST_f_f (y1, -1.0, minus_infty);
3775   TEST_f_f (y1, 0.0, minus_infty);
3776   TEST_f_f (y1, plus_infty, 0);
3777   TEST_f_f (y1, nan_value, nan_value);
3778
3779   TEST_f_f (y1, 0.1, -6.4589510947020269877);
3780   TEST_f_f (y1, 0.7, -1.1032498719076333697);
3781   TEST_f_f (y1, 1.0, -0.78121282130028871655);
3782   TEST_f_f (y1, 1.5, -0.41230862697391129595);
3783   TEST_f_f (y1, 2.0, -0.10703243154093754689);
3784   TEST_f_f (y1, 8.0, -0.15806046173124749426);
3785   TEST_f_f (y1, 10.0, 0.24901542420695388392);
3786
3787   END (y1);
3788 }
3789
3790 static void
3791 yn_test (void)
3792 {
3793   errno = 0;
3794   FUNC(yn) (1, 1);
3795   if (errno == ENOSYS)
3796     /* Function not implemented.  */
3797     return;
3798
3799   /* yn is the Bessel function of the second kind of order n */
3800   START (yn);
3801
3802   /* yn (0, x) == y0 (x)  */
3803   TEST_ff_f (yn, 0, -1.0, minus_infty);
3804   TEST_ff_f (yn, 0, 0.0, minus_infty);
3805   TEST_ff_f (yn, 0, nan_value, nan_value);
3806   TEST_ff_f (yn, 0, plus_infty, 0);
3807
3808   TEST_ff_f (yn, 0, 0.1, -1.5342386513503668441);
3809   TEST_ff_f (yn, 0, 0.7, -0.19066492933739506743);
3810   TEST_ff_f (yn, 0, 1.0, 0.088256964215676957983);
3811   TEST_ff_f (yn, 0, 1.5, 0.38244892379775884396);
3812   TEST_ff_f (yn, 0, 2.0, 0.51037567264974511960);
3813   TEST_ff_f (yn, 0, 8.0, 0.22352148938756622053);
3814   TEST_ff_f (yn, 0, 10.0, 0.055671167283599391424);
3815
3816   /* yn (1, x) == y1 (x)  */
3817   TEST_ff_f (yn, 1, -1.0, minus_infty);
3818   TEST_ff_f (yn, 1, 0.0, minus_infty);
3819   TEST_ff_f (yn, 1, plus_infty, 0);
3820   TEST_ff_f (yn, 1, nan_value, nan_value);
3821
3822   TEST_ff_f (yn, 1, 0.1, -6.4589510947020269877);
3823   TEST_ff_f (yn, 1, 0.7, -1.1032498719076333697);
3824   TEST_ff_f (yn, 1, 1.0, -0.78121282130028871655);
3825   TEST_ff_f (yn, 1, 1.5, -0.41230862697391129595);
3826   TEST_ff_f (yn, 1, 2.0, -0.10703243154093754689);
3827   TEST_ff_f (yn, 1, 8.0, -0.15806046173124749426);
3828   TEST_ff_f (yn, 1, 10.0, 0.24901542420695388392);
3829
3830   /* yn (3, x)  */
3831   TEST_ff_f (yn, 3, plus_infty, 0);
3832   TEST_ff_f (yn, 3, nan_value, nan_value);
3833
3834   TEST_ff_f (yn, 3, 0.1, -5099.3323786129048894);
3835   TEST_ff_f (yn, 3, 0.7, -15.819479052819633505);
3836   TEST_ff_f (yn, 3, 1.0, -5.8215176059647288478);
3837   TEST_ff_f (yn, 3, 2.0, -1.1277837768404277861);
3838   TEST_ff_f (yn, 3, 10.0, -0.25136265718383732978);
3839
3840   /* yn (10, x)  */
3841   TEST_ff_f (yn, 10, plus_infty, 0);
3842   TEST_ff_f (yn, 10, nan_value, nan_value);
3843
3844   TEST_ff_f (yn, 10, 0.1, -0.11831335132045197885e19);
3845   TEST_ff_f (yn, 10, 0.7, -0.42447194260703866924e10);
3846   TEST_ff_f (yn, 10, 1.0, -0.12161801427868918929e9);
3847   TEST_ff_f (yn, 10, 2.0, -129184.54220803928264);
3848   TEST_ff_f (yn, 10, 10.0, -0.35981415218340272205);
3849
3850   END (yn);
3851
3852 }
3853
3854
3855
3856 static void
3857 initialize (void)
3858 {
3859   fpstack_test ("start *init*");
3860   plus_zero = 0.0;
3861   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
3862
3863   minus_zero = FUNC(copysign) (0.0, -1.0);
3864   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
3865                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
3866   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
3867                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
3868
3869   (void) &plus_zero;
3870   (void) &nan_value;
3871   (void) &minus_zero;
3872   (void) &plus_infty;
3873   (void) &minus_infty;
3874
3875   /* Clear all exceptions.  From now on we must not get random exceptions.  */
3876   feclearexcept (FE_ALL_EXCEPT);
3877
3878   /* Test to make sure we start correctly.  */
3879   fpstack_test ("end *init*");
3880 }
3881
3882 /* Definitions of arguments for argp functions.  */
3883 static const struct argp_option options[] =
3884 {
3885   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
3886   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
3887   { "no-max-error", 'f', NULL, 0,
3888     "Don't output maximal errors of functions"},
3889   { "no-points", 'p', NULL, 0,
3890     "Don't output results of functions invocations"},
3891   { "ignore-max-ulp", 'i', "yes/no", 0,
3892     "Ignore given maximal errors"},
3893   { NULL, 0, NULL, 0, NULL }
3894 };
3895
3896 /* Short description of program.  */
3897 static const char doc[] = "Math test suite: " TEST_MSG ;
3898
3899 /* Prototype for option handler.  */
3900 static error_t parse_opt (int key, char *arg, struct argp_state *state);
3901
3902 /* Data structure to communicate with argp functions.  */
3903 static struct argp argp =
3904 {
3905   options, parse_opt, NULL, doc,
3906 };
3907
3908
3909 /* Handle program arguments.  */
3910 static error_t
3911 parse_opt (int key, char *arg, struct argp_state *state)
3912 {
3913   switch (key)
3914     {
3915     case 'f':
3916       output_max_error = 0;
3917       break;
3918     case 'i':
3919       if (strcmp (arg, "yes") == 0)
3920         ignore_max_ulp = 1;
3921       else if (strcmp (arg, "no") == 0)
3922         ignore_max_ulp = 0;
3923       break;
3924     case 'p':
3925       output_points = 0;
3926       break;
3927     case 'u':
3928       output_ulps = 1;
3929       break;
3930     case 'v':
3931       if (optarg)
3932         verbose = (unsigned int) strtoul (optarg, NULL, 0);
3933       else
3934         verbose = 3;
3935       break;
3936     default:
3937       return ARGP_ERR_UNKNOWN;
3938     }
3939   return 0;
3940 }
3941
3942 #if 0
3943 /* function to check our ulp calculation.  */
3944 void
3945 check_ulp (void)
3946 {
3947   int i;
3948
3949   FLOAT u, diff, ulp;
3950   /* This gives one ulp.  */
3951   u = FUNC(nextafter) (10, 20);
3952   check_equal (10.0, u, 1, &diff, &ulp);
3953   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
3954
3955   /* This gives one more ulp.  */
3956   u = FUNC(nextafter) (u, 20);
3957   check_equal (10.0, u, 2, &diff, &ulp);
3958   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
3959
3960   /* And now calculate 100 ulp.  */
3961   for (i = 2; i < 100; i++)
3962     u = FUNC(nextafter) (u, 20);
3963   check_equal (10.0, u, 100, &diff, &ulp);
3964   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
3965 }
3966 #endif
3967
3968 int
3969 main (int argc, char **argv)
3970 {
3971
3972   int remaining;
3973
3974   verbose = 1;
3975   output_ulps = 0;
3976   output_max_error = 1;
3977   output_points = 1;
3978   /* XXX set to 0 for releases.  */
3979   ignore_max_ulp = 0;
3980
3981   /* Parse and process arguments.  */
3982   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
3983
3984   if (remaining != argc)
3985     {
3986       fprintf (stderr, "wrong number of arguments");
3987       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
3988       exit (EXIT_FAILURE);
3989     }
3990
3991   if (output_ulps)
3992     {
3993       ulps_file = fopen ("ULPs", "a");
3994       if (ulps_file == NULL)
3995         {
3996           perror ("can't open file `ULPs' for writing: ");
3997           exit (1);
3998         }
3999     }
4000
4001
4002   initialize ();
4003   printf (TEST_MSG);
4004
4005 #if 0
4006   check_ulp ();
4007 #endif
4008
4009   /* Keep the tests a wee bit ordered (according to ISO C99).  */
4010   /* Classification macros:  */
4011   fpclassify_test ();
4012   isfinite_test ();
4013   isnormal_test ();
4014   signbit_test ();
4015
4016   /* Trigonometric functions:  */
4017   acos_test ();
4018   asin_test ();
4019   atan_test ();
4020   atan2_test ();
4021   cos_test ();
4022   sin_test ();
4023   sincos_test ();
4024   tan_test ();
4025
4026   /* Hyperbolic functions:  */
4027   acosh_test ();
4028   asinh_test ();
4029   atanh_test ();
4030   cosh_test ();
4031   sinh_test ();
4032   tanh_test ();
4033
4034   /* Exponential and logarithmic functions:  */
4035   exp_test ();
4036   exp10_test ();
4037   exp2_test ();
4038   expm1_test ();
4039   frexp_test ();
4040   ldexp_test ();
4041   log_test ();
4042   log10_test ();
4043   log1p_test ();
4044   log2_test ();
4045   logb_test ();
4046   modf_test ();
4047   ilogb_test ();
4048   scalb_test ();
4049   scalbn_test ();
4050   scalbln_test ();
4051
4052   /* Power and absolute value functions:  */
4053   cbrt_test ();
4054   fabs_test ();
4055   hypot_test ();
4056   pow_test ();
4057   sqrt_test ();
4058
4059   /* Error and gamma functions:  */
4060   erf_test ();
4061   erfc_test ();
4062   gamma_test ();
4063   lgamma_test ();
4064   tgamma_test ();
4065
4066   /* Nearest integer functions:  */
4067   ceil_test ();
4068   floor_test ();
4069   nearbyint_test ();
4070   rint_test ();
4071   lrint_test ();
4072   llrint_test ();
4073   round_test ();
4074   lround_test ();
4075   llround_test ();
4076   trunc_test ();
4077
4078   /* Remainder functions:  */
4079   fmod_test ();
4080   remainder_test ();
4081   remquo_test ();
4082
4083   /* Manipulation functions:  */
4084   copysign_test ();
4085   nextafter_test ();
4086   nexttoward_test ();
4087
4088   /* maximum, minimum and positive difference functions */
4089   fdim_test ();
4090   fmax_test ();
4091   fmin_test ();
4092
4093   /* Multiply and add:  */
4094   fma_test ();
4095
4096   /* Complex functions:  */
4097   cabs_test ();
4098   cacos_test ();
4099   cacosh_test ();
4100   carg_test ();
4101   casin_test ();
4102   casinh_test ();
4103   catan_test ();
4104   catanh_test ();
4105   ccos_test ();
4106   ccosh_test ();
4107   cexp_test ();
4108   cimag_test ();
4109   clog10_test ();
4110   clog_test ();
4111   conj_test ();
4112   cpow_test ();
4113   cproj_test ();
4114   creal_test ();
4115   csin_test ();
4116   csinh_test ();
4117   csqrt_test ();
4118   ctan_test ();
4119   ctanh_test ();
4120
4121   /* Bessel functions:  */
4122   j0_test ();
4123   j1_test ();
4124   jn_test ();
4125   y0_test ();
4126   y1_test ();
4127   yn_test ();
4128
4129   if (output_ulps)
4130     fclose (ulps_file);
4131
4132   printf ("\nTest suite completed:\n");
4133   printf ("  %d test cases plus %d tests for exception flags executed.\n",
4134           noTests, noExcTests);
4135   if (noXFails)
4136     printf ("  %d expected failures occured.\n", noXFails);
4137   if (noXPasses)
4138     printf ("  %d unexpected passes occured.\n", noXPasses);
4139   if (noErrors)
4140     {
4141       printf ("  %d errors occured.\n", noErrors);
4142       exit (1);
4143     }
4144   printf ("  All tests passed successfully.\n");
4145   exit (0);
4146 }
4147
4148 /*
4149  * Local Variables:
4150  * mode:c
4151  * End:
4152  */