math/libm-test.inc

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