math/libm-test.inc

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