math/libm-test.inc

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