math/libm-test.inc

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