math/libm-test.inc

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