math/libm-test.inc

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