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.80338464113663849327153994379639112L);
 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   TEST_ff_f (fdim, plus_infty, plus_infty, 0);
2561
2562   END (fdim);
2563 }
2564
2565
2566 static void
2567 floor_test (void)
2568 {
2569   START (floor);
2570
2571   TEST_f_f (floor, 0.0, 0.0);
2572   TEST_f_f (floor, minus_zero, minus_zero);
2573   TEST_f_f (floor, plus_infty, plus_infty);
2574   TEST_f_f (floor, minus_infty, minus_infty);
2575   TEST_f_f (floor, nan_value, nan_value);
2576
2577   TEST_f_f (floor, M_PIl, 3.0);
2578   TEST_f_f (floor, -M_PIl, -4.0);
2579
2580   TEST_f_f (floor, 0.25, 0.0);
2581   TEST_f_f (floor, -0.25, -1.0);
2582
2583   END (floor);
2584 }
2585
2586
2587 static void
2588 fma_test (void)
2589 {
2590   START (fma);
2591
2592   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2593   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2594   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2595   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2596   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2597   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2598   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2599   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2600   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2601   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2602   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2603   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2604
2605   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2606   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2607   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2608   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2609
2610   TEST_fff_f (fma, 1.25L, 0.75L, 0.0625L, 1.0L);
2611
2612   END (fma);
2613 }
2614
2615
2616 static void
2617 fmax_test (void)
2618 {
2619   START (fmax);
2620
2621   TEST_ff_f (fmax, 0, 0, 0);
2622   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2623   TEST_ff_f (fmax, 9, 0, 9);
2624   TEST_ff_f (fmax, 0, 9, 9);
2625   TEST_ff_f (fmax, -9, 0, 0);
2626   TEST_ff_f (fmax, 0, -9, 0);
2627
2628   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2629   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2630   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2631   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2632
2633   TEST_ff_f (fmax, minus_infty, 9, 9);
2634   TEST_ff_f (fmax, minus_infty, -9, -9);
2635   TEST_ff_f (fmax, 9, minus_infty, 9);
2636   TEST_ff_f (fmax, -9, minus_infty, -9);
2637
2638   TEST_ff_f (fmax, 0, nan_value, 0);
2639   TEST_ff_f (fmax, 9, nan_value, 9);
2640   TEST_ff_f (fmax, -9, nan_value, -9);
2641   TEST_ff_f (fmax, nan_value, 0, 0);
2642   TEST_ff_f (fmax, nan_value, 9, 9);
2643   TEST_ff_f (fmax, nan_value, -9, -9);
2644   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2645   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2646   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2647   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2648   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2649
2650   END (fmax);
2651 }
2652
2653
2654 static void
2655 fmin_test (void)
2656 {
2657   START (fmin);
2658
2659   TEST_ff_f (fmin, 0, 0, 0);
2660   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2661   TEST_ff_f (fmin, 9, 0, 0);
2662   TEST_ff_f (fmin, 0, 9, 0);
2663   TEST_ff_f (fmin, -9, 0, -9);
2664   TEST_ff_f (fmin, 0, -9, -9);
2665
2666   TEST_ff_f (fmin, plus_infty, 9, 9);
2667   TEST_ff_f (fmin, 9, plus_infty, 9);
2668   TEST_ff_f (fmin, plus_infty, -9, -9);
2669   TEST_ff_f (fmin, -9, plus_infty, -9);
2670   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2671   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2672   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2673   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2674
2675   TEST_ff_f (fmin, 0, nan_value, 0);
2676   TEST_ff_f (fmin, 9, nan_value, 9);
2677   TEST_ff_f (fmin, -9, nan_value, -9);
2678   TEST_ff_f (fmin, nan_value, 0, 0);
2679   TEST_ff_f (fmin, nan_value, 9, 9);
2680   TEST_ff_f (fmin, nan_value, -9, -9);
2681   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2682   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2683   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2684   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2685   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2686
2687   END (fmin);
2688 }
2689
2690
2691 static void
2692 fmod_test (void)
2693 {
2694   errno = 0;
2695   FUNC(fmod) (6.5, 2.3L);
2696   if (errno == ENOSYS)
2697     /* Function not implemented.  */
2698     return;
2699
2700   START (fmod);
2701
2702   /* fmod (+0, y) == +0 for y != 0.  */
2703   TEST_ff_f (fmod, 0, 3, 0);
2704
2705   /* fmod (-0, y) == -0 for y != 0.  */
2706   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2707
2708   /* fmod (+inf, y) == NaN plus invalid exception.  */
2709   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2710   /* fmod (-inf, y) == NaN plus invalid exception.  */
2711   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2712   /* fmod (x, +0) == NaN plus invalid exception.  */
2713   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2714   /* fmod (x, -0) == NaN plus invalid exception.  */
2715   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2716
2717   /* fmod (x, +inf) == x for x not infinite.  */
2718   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2719   /* fmod (x, -inf) == x for x not infinite.  */
2720   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2721
2722   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2723
2724   TEST_ff_f (fmod, 6.5, 2.25L, 2.0L);
2725   TEST_ff_f (fmod, -6.5, 2.25L, -2.0L);
2726   TEST_ff_f (fmod, 6.5, -2.25L, 2.0L);
2727   TEST_ff_f (fmod, -6.5, -2.25L, -2.0L);
2728
2729   END (fmod);
2730 }
2731
2732
2733 static void
2734 fpclassify_test (void)
2735 {
2736   START (fpclassify);
2737
2738   TEST_f_i (fpclassify, nan_value, FP_NAN);
2739   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2740   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2741   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2742   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2743   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2744
2745   END (fpclassify);
2746 }
2747
2748
2749 static void
2750 frexp_test (void)
2751 {
2752   int x;
2753
2754   START (frexp);
2755
2756   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2757   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2758   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2759
2760   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2761   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2762
2763   TEST_fI_f1 (frexp, 12.8L, 0.8L, 4);
2764   TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5);
2765
2766   END (frexp);
2767 }
2768
2769
2770 static void
2771 gamma_test (void)
2772 {
2773   errno = 0;
2774   FUNC(gamma) (1);
2775
2776   if (errno == ENOSYS)
2777     /* Function not implemented.  */
2778     return;
2779   feclearexcept (FE_ALL_EXCEPT);
2780
2781   START (gamma);
2782
2783   TEST_f_f (gamma, plus_infty, plus_infty);
2784   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2785   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2786   TEST_f_f (gamma, minus_infty, plus_infty);
2787   TEST_f_f (gamma, nan_value, nan_value);
2788
2789   TEST_f_f1 (gamma, 1, 0, 1);
2790   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2791
2792   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2793   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2794
2795   END (gamma);
2796 }
2797
2798 static void
2799 hypot_test (void)
2800 {
2801   errno = 0;
2802   FUNC(hypot) (0.7L, 12.4L);
2803   if (errno == ENOSYS)
2804     /* Function not implemented.  */
2805     return;
2806
2807   START (hypot);
2808
2809   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2810   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2811
2812 #ifndef TEST_INLINE
2813   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2814   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2815   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2816   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2817 #endif
2818
2819   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2820
2821   /* hypot (x,y) == hypot (+-x, +-y)  */
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, 0.7L, -12.4L, 12.419742348374220601176836866763271L);
2825   TEST_ff_f (hypot, -0.7L, -12.4L, 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   TEST_ff_f (hypot, 12.4L, -0.7L, 12.419742348374220601176836866763271L);
2829   TEST_ff_f (hypot, -12.4L, -0.7L, 12.419742348374220601176836866763271L);
2830
2831   /*  hypot (x,0) == fabs (x)  */
2832   TEST_ff_f (hypot, 0.75L, 0, 0.75L);
2833   TEST_ff_f (hypot, -0.75L, 0, 0.75L);
2834   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
2835
2836   TEST_ff_f (hypot, 0.75L, 1.25L, 1.45773797371132511771853821938639577L);
2837
2838   END (hypot);
2839 }
2840
2841
2842 static void
2843 ilogb_test (void)
2844 {
2845   START (ilogb);
2846
2847   TEST_f_i (ilogb, 1, 0);
2848   TEST_f_i (ilogb, M_El, 1);
2849   TEST_f_i (ilogb, 1024, 10);
2850   TEST_f_i (ilogb, -2000, 10);
2851
2852   /* XXX We have a problem here: the standard does not tell us whether
2853      exceptions are allowed/required.  ignore them for now.  */
2854
2855   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2856   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2857   TEST_f_i (ilogb, plus_infty, INT_MAX, EXCEPTIONS_OK);
2858   TEST_f_i (ilogb, minus_infty, INT_MAX, EXCEPTIONS_OK);
2859
2860   END (ilogb);
2861 }
2862
2863 static void
2864 isfinite_test (void)
2865 {
2866   START (isfinite);
2867
2868   TEST_f_b (isfinite, 0, 1);
2869   TEST_f_b (isfinite, minus_zero, 1);
2870   TEST_f_b (isfinite, 10, 1);
2871   TEST_f_b (isfinite, plus_infty, 0);
2872   TEST_f_b (isfinite, minus_infty, 0);
2873   TEST_f_b (isfinite, nan_value, 0);
2874
2875   END (isfinite);
2876 }
2877
2878 static void
2879 isnormal_test (void)
2880 {
2881   START (isnormal);
2882
2883   TEST_f_b (isnormal, 0, 0);
2884   TEST_f_b (isnormal, minus_zero, 0);
2885   TEST_f_b (isnormal, 10, 1);
2886   TEST_f_b (isnormal, plus_infty, 0);
2887   TEST_f_b (isnormal, minus_infty, 0);
2888   TEST_f_b (isnormal, nan_value, 0);
2889
2890   END (isnormal);
2891 }
2892
2893 static void
2894 j0_test (void)
2895 {
2896   FLOAT s, c;
2897   errno = 0;
2898   FUNC (sincos) (0, &s, &c);
2899   if (errno == ENOSYS)
2900     /* Required function not implemented.  */
2901     return;
2902   FUNC(j0) (0);
2903   if (errno == ENOSYS)
2904     /* Function not implemented.  */
2905     return;
2906
2907   START (j0);
2908
2909   /* j0 is the Bessel function of the first kind of order 0 */
2910   TEST_f_f (j0, nan_value, nan_value);
2911   TEST_f_f (j0, plus_infty, 0);
2912   TEST_f_f (j0, -1.0, 0.765197686557966551449717526102663221L);
2913   TEST_f_f (j0, 0.0, 1.0);
2914   TEST_f_f (j0, 0.125L, 0.996097563041985204620768999453174712L);
2915   TEST_f_f (j0, 0.75L, 0.864242275166648623555731103820923211L);
2916   TEST_f_f (j0, 1.0, 0.765197686557966551449717526102663221L);
2917   TEST_f_f (j0, 1.5, 0.511827671735918128749051744283411720L);
2918   TEST_f_f (j0, 2.0, 0.223890779141235668051827454649948626L);
2919   TEST_f_f (j0, 8.0, 0.171650807137553906090869407851972001L);
2920   TEST_f_f (j0, 10.0, -0.245935764451348335197760862485328754L);
2921   TEST_f_f (j0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
2922   TEST_f_f (j0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
2923
2924   END (j0);
2925 }
2926
2927
2928 static void
2929 j1_test (void)
2930 {
2931   FLOAT s, c;
2932   errno = 0;
2933   FUNC (sincos) (0, &s, &c);
2934   if (errno == ENOSYS)
2935     /* Required function not implemented.  */
2936     return;
2937   FUNC(j1) (0);
2938   if (errno == ENOSYS)
2939     /* Function not implemented.  */
2940     return;
2941
2942   /* j1 is the Bessel function of the first kind of order 1 */
2943
2944   START (j1);
2945
2946   TEST_f_f (j1, nan_value, nan_value);
2947   TEST_f_f (j1, plus_infty, 0);
2948
2949   TEST_f_f (j1, -1.0, -0.440050585744933515959682203718914913L);
2950   TEST_f_f (j1, 0.0, 0.0);
2951   TEST_f_f (j1, 0.125L, 0.0623780091344946810942311355879361177L);
2952   TEST_f_f (j1, 0.75L, 0.349243602174862192523281016426251335L);
2953   TEST_f_f (j1, 1.0, 0.440050585744933515959682203718914913L);
2954   TEST_f_f (j1, 1.5, 0.557936507910099641990121213156089400L);
2955   TEST_f_f (j1, 2.0, 0.576724807756873387202448242269137087L);
2956   TEST_f_f (j1, 8.0, 0.234636346853914624381276651590454612L);
2957   TEST_f_f (j1, 10.0, 0.0434727461688614366697487680258592883L);
2958
2959   END (j1);
2960 }
2961
2962 static void
2963 jn_test (void)
2964 {
2965   FLOAT s, c;
2966   errno = 0;
2967   FUNC (sincos) (0, &s, &c);
2968   if (errno == ENOSYS)
2969     /* Required function not implemented.  */
2970     return;
2971   FUNC(jn) (1, 1);
2972   if (errno == ENOSYS)
2973     /* Function not implemented.  */
2974     return;
2975
2976   /* jn is the Bessel function of the first kind of order n.  */
2977   START (jn);
2978
2979   /* jn (0, x) == j0 (x)  */
2980   TEST_ff_f (jn, 0, nan_value, nan_value);
2981   TEST_ff_f (jn, 0, plus_infty, 0);
2982   TEST_ff_f (jn, 0, -1.0, 0.765197686557966551449717526102663221L);
2983   TEST_ff_f (jn, 0, 0.0, 1.0);
2984   TEST_ff_f (jn, 0, 0.125L, 0.996097563041985204620768999453174712L);
2985   TEST_ff_f (jn, 0, 0.75L, 0.864242275166648623555731103820923211L);
2986   TEST_ff_f (jn, 0, 1.0, 0.765197686557966551449717526102663221L);
2987   TEST_ff_f (jn, 0, 1.5, 0.511827671735918128749051744283411720L);
2988   TEST_ff_f (jn, 0, 2.0, 0.223890779141235668051827454649948626L);
2989   TEST_ff_f (jn, 0, 8.0, 0.171650807137553906090869407851972001L);
2990   TEST_ff_f (jn, 0, 10.0, -0.245935764451348335197760862485328754L);
2991   TEST_ff_f (jn, 0, 4.0, -3.9714980986384737228659076845169804197562E-1L);
2992   TEST_ff_f (jn, 0, -4.0, -3.9714980986384737228659076845169804197562E-1L);
2993
2994   /* jn (1, x) == j1 (x)  */
2995   TEST_ff_f (jn, 1, nan_value, nan_value);
2996   TEST_ff_f (jn, 1, plus_infty, 0);
2997   TEST_ff_f (jn, 1, -1.0, -0.440050585744933515959682203718914913L);
2998   TEST_ff_f (jn, 1, 0.0, 0.0);
2999   TEST_ff_f (jn, 1, 0.125L, 0.0623780091344946810942311355879361177L);
3000   TEST_ff_f (jn, 1, 0.75L, 0.349243602174862192523281016426251335L);
3001   TEST_ff_f (jn, 1, 1.0, 0.440050585744933515959682203718914913L);
3002   TEST_ff_f (jn, 1, 1.5, 0.557936507910099641990121213156089400L);
3003   TEST_ff_f (jn, 1, 2.0, 0.576724807756873387202448242269137087L);
3004   TEST_ff_f (jn, 1, 8.0, 0.234636346853914624381276651590454612L);
3005   TEST_ff_f (jn, 1, 10.0, 0.0434727461688614366697487680258592883L);
3006
3007   /* jn (3, x)  */
3008   TEST_ff_f (jn, 3, nan_value, nan_value);
3009   TEST_ff_f (jn, 3, plus_infty, 0);
3010
3011   TEST_ff_f (jn, 3, -1.0, -0.0195633539826684059189053216217515083L);
3012   TEST_ff_f (jn, 3, 0.0, 0.0);
3013   TEST_ff_f (jn, 3, 0.125L, 0.406503832554912875023029337653442868e-4L);
3014   TEST_ff_f (jn, 3, 0.75L, 0.848438342327410884392755236884386804e-2L);
3015   TEST_ff_f (jn, 3, 1.0, 0.0195633539826684059189053216217515083L);
3016   TEST_ff_f (jn, 3, 2.0, 0.128943249474402051098793332969239835L);
3017   TEST_ff_f (jn, 3, 10.0, 0.0583793793051868123429354784103409563L);
3018
3019   /*  jn (10, x)  */
3020   TEST_ff_f (jn, 10, nan_value, nan_value);
3021   TEST_ff_f (jn, 10, plus_infty, 0);
3022
3023   TEST_ff_f (jn, 10, -1.0, 0.263061512368745320699785368779050294e-9L);
3024   TEST_ff_f (jn, 10, 0.0, 0.0);
3025   TEST_ff_f (jn, 10, 0.125L, 0.250543369809369890173993791865771547e-18L);
3026   TEST_ff_f (jn, 10, 0.75L, 0.149621713117596814698712483621682835e-10L);
3027   TEST_ff_f (jn, 10, 1.0, 0.263061512368745320699785368779050294e-9L);
3028   TEST_ff_f (jn, 10, 2.0, 0.251538628271673670963516093751820639e-6L);
3029   TEST_ff_f (jn, 10, 10.0, 0.207486106633358857697278723518753428L);
3030
3031   END (jn);
3032 }
3033
3034
3035 static void
3036 ldexp_test (void)
3037 {
3038   TEST_ff_f (ldexp, 0, 0, 0);
3039   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
3040
3041   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
3042   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
3043   TEST_ff_f (ldexp, nan_value, 1, nan_value);
3044
3045   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
3046   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
3047
3048   /* ldexp (x, 0) == x.  */
3049   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
3050 }
3051
3052
3053 static void
3054 lgamma_test (void)
3055 {
3056   errno = 0;
3057   FUNC(lgamma) (0);
3058   if (errno == ENOSYS)
3059     /* Function not implemented.  */
3060     return;
3061   feclearexcept (FE_ALL_EXCEPT);
3062
3063   START (lgamma);
3064
3065   TEST_f_f (lgamma, plus_infty, plus_infty);
3066   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3067   TEST_f_f (lgamma, nan_value, nan_value);
3068
3069   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
3070   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3071   TEST_f_f (lgamma, minus_infty, plus_infty);
3072
3073   TEST_f_f1 (lgamma, 1, 0, 1);
3074
3075   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
3076
3077   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
3078   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
3079   TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1);
3080   TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1);
3081
3082   END (lgamma);
3083 }
3084
3085
3086 static void
3087 lrint_test (void)
3088 {
3089   /* XXX this test is incomplete.  We need to have a way to specifiy
3090      the rounding method and test the critical cases.  So far, only
3091      unproblematic numbers are tested.  */
3092
3093   START (lrint);
3094
3095   TEST_f_l (lrint, 0.0, 0);
3096   TEST_f_l (lrint, minus_zero, 0);
3097   TEST_f_l (lrint, 0.2L, 0);
3098   TEST_f_l (lrint, -0.2L, 0);
3099
3100   TEST_f_l (lrint, 1.4L, 1);
3101   TEST_f_l (lrint, -1.4L, -1);
3102
3103   TEST_f_l (lrint, 8388600.3L, 8388600);
3104   TEST_f_l (lrint, -8388600.3L, -8388600);
3105
3106   TEST_f_l (lrint, 1071930.0008, 1071930);
3107 #ifndef TEST_FLOAT
3108   TEST_f_l (lrint, 1073741824.01, 1073741824);
3109 # if LONG_MAX > 281474976710656
3110   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3111 # endif
3112 #endif
3113
3114   END (lrint);
3115 }
3116
3117
3118 static void
3119 llrint_test (void)
3120 {
3121   /* XXX this test is incomplete.  We need to have a way to specifiy
3122      the rounding method and test the critical cases.  So far, only
3123      unproblematic numbers are tested.  */
3124
3125   START (llrint);
3126
3127   TEST_f_L (llrint, 0.0, 0);
3128   TEST_f_L (llrint, minus_zero, 0);
3129   TEST_f_L (llrint, 0.2L, 0);
3130   TEST_f_L (llrint, -0.2L, 0);
3131
3132   TEST_f_L (llrint, 1.4L, 1);
3133   TEST_f_L (llrint, -1.4L, -1);
3134
3135   TEST_f_L (llrint, 8388600.3L, 8388600);
3136   TEST_f_L (llrint, -8388600.3L, -8388600);
3137
3138   TEST_f_l (llrint, 1071930.0008, 1071930);
3139
3140   /* Test boundary conditions.  */
3141   /* 0x1FFFFF */
3142   TEST_f_L (llrint, 2097151.0,2097151LL);
3143   /* 0x800000 */
3144   TEST_f_L (llrint, 8388608.0, 8388608LL);
3145   /* 0x1000000 */
3146   TEST_f_L (llrint, 16777216.0, 16777216LL);
3147   /* 0x20000000000 */
3148   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3149   /* 0x40000000000 */
3150   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3151   /* 0x1000000000000 */
3152   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3153   /* 0x10000000000000 */
3154   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3155   /* 0x10000080000000 */
3156   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3157   /* 0x20000000000000 */
3158   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3159   /* 0x80000000000000 */
3160   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3161   /* 0x100000000000000 */
3162   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3163
3164   END (llrint);
3165 }
3166
3167
3168 static void
3169 log_test (void)
3170 {
3171   errno = 0;
3172   FUNC(log) (1);
3173   if (errno == ENOSYS)
3174     /* Function not implemented.  */
3175     return;
3176   START (log);
3177
3178   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3179   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3180
3181   TEST_f_f (log, 1, 0);
3182
3183   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3184   TEST_f_f (log, plus_infty, plus_infty);
3185
3186   TEST_f_f (log, M_El, 1);
3187   TEST_f_f (log, 1.0 / M_El, -1);
3188   TEST_f_f (log, 2, M_LN2l);
3189   TEST_f_f (log, 10, M_LN10l);
3190   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
3191
3192   END (log);
3193 }
3194
3195
3196 static void
3197 log10_test (void)
3198 {
3199   errno = 0;
3200   FUNC(log10) (1);
3201   if (errno == ENOSYS)
3202     /* Function not implemented.  */
3203     return;
3204
3205   START (log10);
3206
3207   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3208   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3209
3210   TEST_f_f (log10, 1, 0);
3211
3212   /* log10 (x) == NaN plus invalid exception if x < 0.  */
3213   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3214
3215   TEST_f_f (log10, plus_infty, plus_infty);
3216   TEST_f_f (log10, nan_value, nan_value);
3217
3218   TEST_f_f (log10, 0.1L, -1);
3219   TEST_f_f (log10, 10.0, 1);
3220   TEST_f_f (log10, 100.0, 2);
3221   TEST_f_f (log10, 10000.0, 4);
3222   TEST_f_f (log10, M_El, M_LOG10El);
3223   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
3224
3225   END (log10);
3226 }
3227
3228
3229 static void
3230 log1p_test (void)
3231 {
3232   errno = 0;
3233   FUNC(log1p) (0);
3234   if (errno == ENOSYS)
3235     /* Function not implemented.  */
3236     return;
3237
3238   START (log1p);
3239
3240   TEST_f_f (log1p, 0, 0);
3241   TEST_f_f (log1p, minus_zero, minus_zero);
3242
3243   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3244   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3245
3246   TEST_f_f (log1p, plus_infty, plus_infty);
3247   TEST_f_f (log1p, nan_value, nan_value);
3248
3249   TEST_f_f (log1p, M_El - 1.0, 1);
3250
3251   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
3252   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
3253
3254   END (log1p);
3255 }
3256
3257
3258 static void
3259 log2_test (void)
3260 {
3261   errno = 0;
3262   FUNC(log2) (1);
3263   if (errno == ENOSYS)
3264     /* Function not implemented.  */
3265     return;
3266
3267   START (log2);
3268
3269   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3270   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3271
3272   TEST_f_f (log2, 1, 0);
3273
3274   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3275
3276   TEST_f_f (log2, plus_infty, plus_infty);
3277   TEST_f_f (log2, nan_value, nan_value);
3278
3279   TEST_f_f (log2, M_El, M_LOG2El);
3280   TEST_f_f (log2, 2.0, 1);
3281   TEST_f_f (log2, 16.0, 4);
3282   TEST_f_f (log2, 256.0, 8);
3283   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
3284
3285   END (log2);
3286 }
3287
3288
3289 static void
3290 logb_test (void)
3291 {
3292   START (logb);
3293
3294   TEST_f_f (logb, plus_infty, plus_infty);
3295   TEST_f_f (logb, minus_infty, plus_infty);
3296
3297   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3298
3299   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3300   TEST_f_f (logb, nan_value, nan_value);
3301
3302   TEST_f_f (logb, 1, 0);
3303   TEST_f_f (logb, M_El, 1);
3304   TEST_f_f (logb, 1024, 10);
3305   TEST_f_f (logb, -2000, 10);
3306
3307   END (logb);
3308 }
3309
3310
3311 static void
3312 lround_test (void)
3313 {
3314   START (lround);
3315
3316   TEST_f_l (lround, 0, 0);
3317   TEST_f_l (lround, minus_zero, 0);
3318   TEST_f_l (lround, 0.2L, 0.0);
3319   TEST_f_l (lround, -0.2L, 0);
3320   TEST_f_l (lround, 0.5, 1);
3321   TEST_f_l (lround, -0.5, -1);
3322   TEST_f_l (lround, 0.8L, 1);
3323   TEST_f_l (lround, -0.8L, -1);
3324   TEST_f_l (lround, 1.5, 2);
3325   TEST_f_l (lround, -1.5, -2);
3326   TEST_f_l (lround, 22514.5, 22515);
3327   TEST_f_l (lround, -22514.5, -22515);
3328   TEST_f_l (lround, 1071930.0008, 1071930);
3329 #ifndef TEST_FLOAT
3330   TEST_f_l (lround, 1073741824.01, 1073741824);
3331 # if LONG_MAX > 281474976710656
3332   TEST_f_l (lround, 281474976710656.025, 281474976710656);
3333 # endif
3334   TEST_f_l (lround, 2097152.5, 2097153);
3335   TEST_f_l (lround, -2097152.5, -2097153);
3336 #endif
3337   END (lround);
3338 }
3339
3340
3341 static void
3342 llround_test (void)
3343 {
3344   START (llround);
3345
3346   TEST_f_L (llround, 0, 0);
3347   TEST_f_L (llround, minus_zero, 0);
3348   TEST_f_L (llround, 0.2L, 0.0);
3349   TEST_f_L (llround, -0.2L, 0);
3350   TEST_f_L (llround, 0.5, 1);
3351   TEST_f_L (llround, -0.5, -1);
3352   TEST_f_L (llround, 0.8L, 1);
3353   TEST_f_L (llround, -0.8L, -1);
3354   TEST_f_L (llround, 1.5, 2);
3355   TEST_f_L (llround, -1.5, -2);
3356   TEST_f_L (llround, 22514.5, 22515);
3357   TEST_f_L (llround, -22514.5, -22515);
3358   TEST_f_l (llround, 1071930.0008, 1071930);
3359 #ifndef TEST_FLOAT
3360   TEST_f_L (llround, 2097152.5, 2097153);
3361   TEST_f_L (llround, -2097152.5, -2097153);
3362   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3363   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3364 #endif
3365
3366   /* Test boundary conditions.  */
3367   /* 0x1FFFFF */
3368   TEST_f_L (llround, 2097151.0, 2097151LL);
3369   /* 0x800000 */
3370   TEST_f_L (llround, 8388608.0, 8388608LL);
3371   /* 0x1000000 */
3372   TEST_f_L (llround, 16777216.0, 16777216LL);
3373   /* 0x20000000000 */
3374   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3375   /* 0x40000000000 */
3376   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3377   /* 0x1000000000000 */
3378   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
3379   /* 0x10000000000000 */
3380   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3381   /* 0x10000080000000 */
3382   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
3383   /* 0x20000000000000 */
3384   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3385   /* 0x80000000000000 */
3386   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3387   /* 0x100000000000000 */
3388   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3389
3390 #ifndef TEST_FLOAT
3391   /* 0x100000000 */
3392   TEST_f_L (llround, 4294967295.5, 4294967296LL);
3393   /* 0x200000000 */
3394   TEST_f_L (llround, 8589934591.5, 8589934592LL);
3395 #endif
3396
3397   END (llround);
3398 }
3399
3400 static void
3401 modf_test (void)
3402 {
3403   FLOAT x;
3404
3405   START (modf);
3406
3407   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3408   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3409   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3410   TEST_fF_f1 (modf, 0, 0, 0);
3411   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3412   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3413   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3414   TEST_fF_f1 (modf, 20, 0, 20);
3415   TEST_fF_f1 (modf, 21, 0, 21);
3416   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3417
3418   END (modf);
3419 }
3420
3421
3422 static void
3423 nearbyint_test (void)
3424 {
3425   START (nearbyint);
3426
3427   TEST_f_f (nearbyint, 0.0, 0.0);
3428   TEST_f_f (nearbyint, minus_zero, minus_zero);
3429   TEST_f_f (nearbyint, plus_infty, plus_infty);
3430   TEST_f_f (nearbyint, minus_infty, minus_infty);
3431   TEST_f_f (nearbyint, nan_value, nan_value);
3432
3433   /* Default rounding mode is round to nearest.  */
3434   TEST_f_f (nearbyint, 0.5, 0.0);
3435   TEST_f_f (nearbyint, 1.5, 2.0);
3436   TEST_f_f (nearbyint, -0.5, minus_zero);
3437   TEST_f_f (nearbyint, -1.5, -2.0);
3438
3439   END (nearbyint);
3440 }
3441
3442 static void
3443 nextafter_test (void)
3444 {
3445
3446   START (nextafter);
3447
3448   TEST_ff_f (nextafter, 0, 0, 0);
3449   TEST_ff_f (nextafter, minus_zero, 0, 0);
3450   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3451   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3452
3453   TEST_ff_f (nextafter, 9, 9, 9);
3454   TEST_ff_f (nextafter, -9, -9, -9);
3455   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3456   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3457
3458   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
3459   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
3460   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3461
3462   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3463                          LDBL_MAX, DBL_MAX, FLT_MAX);
3464   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
3465   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
3466
3467 #ifdef TEST_LDOUBLE
3468   // XXX Enable once gcc is fixed.
3469   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
3470 #endif
3471
3472   /* XXX We need the hexadecimal FP number representation here for further
3473      tests.  */
3474
3475   END (nextafter);
3476 }
3477
3478
3479 static void
3480 nexttoward_test (void)
3481 {
3482   START (nexttoward);
3483   TEST_ff_f (nexttoward, 0, 0, 0);
3484   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3485   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3486   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3487
3488   TEST_ff_f (nexttoward, 9, 9, 9);
3489   TEST_ff_f (nexttoward, -9, -9, -9);
3490   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3491   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3492
3493   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
3494   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
3495   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3496
3497   /* XXX We need the hexadecimal FP number representation here for further
3498      tests.  */
3499
3500   END (nexttoward);
3501 }
3502
3503
3504 static void
3505 pow_test (void)
3506 {
3507
3508   errno = 0;
3509   FUNC(pow) (0, 0);
3510   if (errno == ENOSYS)
3511     /* Function not implemented.  */
3512     return;
3513
3514   START (pow);
3515
3516   TEST_ff_f (pow, 0, 0, 1);
3517   TEST_ff_f (pow, 0, minus_zero, 1);
3518   TEST_ff_f (pow, minus_zero, 0, 1);
3519   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3520
3521   TEST_ff_f (pow, 10, 0, 1);
3522   TEST_ff_f (pow, 10, minus_zero, 1);
3523   TEST_ff_f (pow, -10, 0, 1);
3524   TEST_ff_f (pow, -10, minus_zero, 1);
3525
3526   TEST_ff_f (pow, nan_value, 0, 1);
3527   TEST_ff_f (pow, nan_value, minus_zero, 1);
3528
3529
3530 #ifndef TEST_INLINE
3531   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
3532   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3533   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
3534   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3535
3536   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3537   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3538   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3539   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3540
3541   TEST_ff_f (pow, 1.1L, minus_infty, 0);
3542   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3543   TEST_ff_f (pow, -1.1L, minus_infty, 0);
3544   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3545
3546   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3547   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3548   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3549   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3550
3551   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3552   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3553   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3554
3555   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3556   TEST_ff_f (pow, plus_infty, -1, 0);
3557   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3558
3559   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3560   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3561   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3562
3563   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3564   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3565   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3566   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
3567   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
3568   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
3569   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
3570
3571   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3572   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3573   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3574
3575   TEST_ff_f (pow, minus_infty, -2, 0);
3576   TEST_ff_f (pow, minus_infty, -12, 0);
3577   TEST_ff_f (pow, minus_infty, -1002, 0);
3578   TEST_ff_f (pow, minus_infty, -0.1L, 0);
3579   TEST_ff_f (pow, minus_infty, -1.1L, 0);
3580   TEST_ff_f (pow, minus_infty, -11.1L, 0);
3581   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
3582 #endif
3583
3584   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3585   TEST_ff_f (pow, 0, nan_value, nan_value);
3586   TEST_ff_f (pow, 1, nan_value, 1);
3587   TEST_ff_f (pow, -1, nan_value, nan_value);
3588   TEST_ff_f (pow, nan_value, 1, nan_value);
3589   TEST_ff_f (pow, nan_value, -1, nan_value);
3590
3591   /* pow (x, NaN) == NaN.  */
3592   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3593
3594   TEST_ff_f (pow, 1, plus_infty, 1);
3595   TEST_ff_f (pow, -1, plus_infty, 1);
3596   TEST_ff_f (pow, 1, minus_infty, 1);
3597   TEST_ff_f (pow, -1, minus_infty, 1);
3598   TEST_ff_f (pow, 1, 1, 1);
3599   TEST_ff_f (pow, 1, -1, 1);
3600   TEST_ff_f (pow, 1, 1.25, 1);
3601   TEST_ff_f (pow, 1, -1.25, 1);
3602   TEST_ff_f (pow, 1, 0x1p62L, 1);
3603   TEST_ff_f (pow, 1, 0x1p63L, 1);
3604   TEST_ff_f (pow, 1, 0x1p64L, 1);
3605   TEST_ff_f (pow, 1, 0x1p72L, 1);
3606
3607   /* pow (x, +-0) == 1.  */
3608   TEST_ff_f (pow, plus_infty, 0, 1);
3609   TEST_ff_f (pow, plus_infty, minus_zero, 1);
3610   TEST_ff_f (pow, minus_infty, 0, 1);
3611   TEST_ff_f (pow, minus_infty, 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, -32.75L, 0, 1);
3615   TEST_ff_f (pow, -32.75L, minus_zero, 1);
3616   TEST_ff_f (pow, 0x1p72L, 0, 1);
3617   TEST_ff_f (pow, 0x1p72L, minus_zero, 1);
3618   TEST_ff_f (pow, 0x1p-72L, 0, 1);
3619   TEST_ff_f (pow, 0x1p-72L, minus_zero, 1);
3620
3621   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3622   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3623   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3624   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3625
3626   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3627   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3628   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3629   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3630
3631   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3632   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3633   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3634   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3635
3636   TEST_ff_f (pow, 0x1p72L, 0x1p72L, plus_infty);
3637   TEST_ff_f (pow, 10, -0x1p72L, 0);
3638   TEST_ff_f (pow, max_value, max_value, plus_infty);
3639   TEST_ff_f (pow, 10, -max_value, 0);
3640
3641   TEST_ff_f (pow, 0, 1, 0);
3642   TEST_ff_f (pow, 0, 11, 0);
3643
3644   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3645   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3646
3647
3648   TEST_ff_f (pow, 0, 2, 0);
3649   TEST_ff_f (pow, 0, 11.1L, 0);
3650
3651
3652   TEST_ff_f (pow, minus_zero, 2, 0);
3653   TEST_ff_f (pow, minus_zero, 11.1L, 0);
3654   TEST_ff_f (pow, 0, plus_infty, 0);
3655   TEST_ff_f (pow, minus_zero, plus_infty, 0);
3656
3657 #ifndef TEST_INLINE
3658   /* pow (x, +inf) == +inf for |x| > 1.  */
3659   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3660
3661   /* pow (x, +inf) == +0 for |x| < 1.  */
3662   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3663
3664   /* pow (x, -inf) == +0 for |x| > 1.  */
3665   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3666
3667   /* pow (x, -inf) == +inf for |x| < 1.  */
3668   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3669 #endif
3670
3671   /* pow (+inf, y) == +inf for y > 0.  */
3672   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3673
3674   /* pow (+inf, y) == +0 for y < 0.  */
3675   TEST_ff_f (pow, plus_infty, -1, 0.0);
3676
3677   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3678   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3679
3680   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3681   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3682
3683   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3684   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3685   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3686   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3687
3688   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3689   TEST_ff_f (pow, 0.0, 27, 0.0);
3690
3691   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3692   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3693
3694   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3695   TEST_ff_f (pow, 0.0, 4, 0.0);
3696
3697   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3698   TEST_ff_f (pow, minus_zero, 4, 0.0);
3699
3700   TEST_ff_f (pow, 16, 0.25L, 2);
3701   TEST_ff_f (pow, 0x1p64L, 0.125L, 256);
3702   TEST_ff_f (pow, 2, 4, 16);
3703   TEST_ff_f (pow, 256, 8, 0x1p64L);
3704
3705   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
3706
3707 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
3708   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3709 #endif
3710
3711   END (pow);
3712 }
3713
3714 static void
3715 remainder_test (void)
3716 {
3717   errno = 0;
3718   FUNC(remainder) (1.625, 1.0);
3719   if (errno == ENOSYS)
3720     /* Function not implemented.  */
3721     return;
3722
3723   START (remainder);
3724
3725   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3726   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3727   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3728   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3729   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3730
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, 1.625, -1.0, -0.375);
3734   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3735   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3736   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3737
3738   END (remainder);
3739 }
3740
3741 static void
3742 remquo_test (void)
3743 {
3744   /* x is needed.  */
3745   int x;
3746
3747   errno = 0;
3748   FUNC(remquo) (1.625, 1.0, &x);
3749   if (errno == ENOSYS)
3750     /* Function not implemented.  */
3751     return;
3752
3753   START (remquo);
3754
3755   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3756   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3757   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3758   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3759   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3760
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   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3764   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3765
3766   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3767   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3768
3769   END (remquo);
3770 }
3771
3772 static void
3773 rint_test (void)
3774 {
3775   START (rint);
3776
3777   TEST_f_f (rint, 0.0, 0.0);
3778   TEST_f_f (rint, minus_zero, minus_zero);
3779   TEST_f_f (rint, plus_infty, plus_infty);
3780   TEST_f_f (rint, minus_infty, minus_infty);
3781
3782   /* Default rounding mode is round to even.  */
3783   TEST_f_f (rint, 0.5, 0.0);
3784   TEST_f_f (rint, 1.5, 2.0);
3785   TEST_f_f (rint, 2.5, 2.0);
3786   TEST_f_f (rint, 3.5, 4.0);
3787   TEST_f_f (rint, 4.5, 4.0);
3788   TEST_f_f (rint, -0.5, -0.0);
3789   TEST_f_f (rint, -1.5, -2.0);
3790   TEST_f_f (rint, -2.5, -2.0);
3791   TEST_f_f (rint, -3.5, -4.0);
3792   TEST_f_f (rint, -4.5, -4.0);
3793
3794   END (rint);
3795 }
3796
3797 static void
3798 rint_test_tonearest (void)
3799 {
3800   int save_round_mode;
3801   START (rint_tonearest);
3802
3803   save_round_mode = fegetround();
3804
3805   if (!fesetround (FE_TONEAREST))
3806   {
3807     TEST_f_f (rint, 2.0, 2.0);
3808     TEST_f_f (rint, 1.5, 2.0);
3809     TEST_f_f (rint, 1.0, 1.0);
3810     TEST_f_f (rint, 0.5, 0.0);
3811     TEST_f_f (rint, 0.0, 0.0);
3812     TEST_f_f (rint, minus_zero, minus_zero);
3813     TEST_f_f (rint, -0.5, -0.0);
3814     TEST_f_f (rint, -1.0, -1.0);
3815     TEST_f_f (rint, -1.5, -2.0);
3816     TEST_f_f (rint, -2.0, -2.0);
3817   }
3818
3819   fesetround(save_round_mode);
3820
3821   END (rint_tonearest);
3822 }
3823
3824 static void
3825 rint_test_towardzero (void)
3826 {
3827   int save_round_mode;
3828   START (rint_towardzero);
3829
3830   save_round_mode = fegetround();
3831
3832   if (!fesetround (FE_TOWARDZERO))
3833   {
3834     TEST_f_f (rint, 2.0, 2.0);
3835     TEST_f_f (rint, 1.5, 1.0);
3836     TEST_f_f (rint, 1.0, 1.0);
3837     TEST_f_f (rint, 0.5, 0.0);
3838     TEST_f_f (rint, 0.0, 0.0);
3839     TEST_f_f (rint, minus_zero, minus_zero);
3840     TEST_f_f (rint, -0.5, -0.0);
3841     TEST_f_f (rint, -1.0, -1.0);
3842     TEST_f_f (rint, -1.5, -1.0);
3843     TEST_f_f (rint, -2.0, -2.0);
3844   }
3845
3846   fesetround(save_round_mode);
3847
3848   END (rint_towardzero);
3849 }
3850
3851 static void
3852 rint_test_downward (void)
3853 {
3854   int save_round_mode;
3855   START (rint_downward);
3856
3857   save_round_mode = fegetround();
3858
3859   if (!fesetround (FE_DOWNWARD))
3860   {
3861     TEST_f_f (rint, 2.0, 2.0);
3862     TEST_f_f (rint, 1.5, 1.0);
3863     TEST_f_f (rint, 1.0, 1.0);
3864     TEST_f_f (rint, 0.5, 0.0);
3865     TEST_f_f (rint, 0.0, 0.0);
3866     TEST_f_f (rint, minus_zero, minus_zero);
3867     TEST_f_f (rint, -0.5, -1.0);
3868     TEST_f_f (rint, -1.0, -1.0);
3869     TEST_f_f (rint, -1.5, -2.0);
3870     TEST_f_f (rint, -2.0, -2.0);
3871   }
3872
3873   fesetround(save_round_mode);
3874
3875   END (rint_downward);
3876 }
3877
3878 static void
3879 rint_test_upward (void)
3880 {
3881   int save_round_mode;
3882   START (rint_upward);
3883
3884   save_round_mode = fegetround();
3885
3886   if (!fesetround (FE_UPWARD))
3887   {
3888     TEST_f_f (rint, 2.0, 2.0);
3889     TEST_f_f (rint, 1.5, 2.0);
3890     TEST_f_f (rint, 1.0, 1.0);
3891     TEST_f_f (rint, 0.5, 1.0);
3892     TEST_f_f (rint, 0.0, 0.0);
3893     TEST_f_f (rint, minus_zero, minus_zero);
3894     TEST_f_f (rint, -0.5, -0.0);
3895     TEST_f_f (rint, -1.0, -1.0);
3896     TEST_f_f (rint, -1.5, -1.0);
3897     TEST_f_f (rint, -2.0, -2.0);
3898   }
3899
3900   fesetround(save_round_mode);
3901
3902   END (rint_upward);
3903 }
3904
3905 static void
3906 round_test (void)
3907 {
3908   START (round);
3909
3910   TEST_f_f (round, 0, 0);
3911   TEST_f_f (round, minus_zero, minus_zero);
3912   TEST_f_f (round, 0.2L, 0.0);
3913   TEST_f_f (round, -0.2L, minus_zero);
3914   TEST_f_f (round, 0.5, 1.0);
3915   TEST_f_f (round, -0.5, -1.0);
3916   TEST_f_f (round, 0.8L, 1.0);
3917   TEST_f_f (round, -0.8L, -1.0);
3918   TEST_f_f (round, 1.5, 2.0);
3919   TEST_f_f (round, -1.5, -2.0);
3920   TEST_f_f (round, 2097152.5, 2097153);
3921   TEST_f_f (round, -2097152.5, -2097153);
3922
3923   END (round);
3924 }
3925
3926
3927 static void
3928 scalb_test (void)
3929 {
3930
3931   START (scalb);
3932
3933   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
3934   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
3935
3936   TEST_ff_f (scalb, 0, nan_value, nan_value);
3937   TEST_ff_f (scalb, 1, nan_value, nan_value);
3938
3939   TEST_ff_f (scalb, 1, 0, 1);
3940   TEST_ff_f (scalb, -1, 0, -1);
3941
3942   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3943   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3944
3945   TEST_ff_f (scalb, 0, 2, 0);
3946   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3947   TEST_ff_f (scalb, 0, 0, 0);
3948   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3949   TEST_ff_f (scalb, 0, -1, 0);
3950   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3951   TEST_ff_f (scalb, 0, minus_infty, 0);
3952   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3953
3954   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3955   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3956   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3957   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3958   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3959   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3960
3961   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
3962   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
3963
3964   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3965   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3966   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3967   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3968
3969   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3970   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3971
3972   TEST_ff_f (scalb, nan_value, 1, nan_value);
3973   TEST_ff_f (scalb, 1, nan_value, nan_value);
3974   TEST_ff_f (scalb, nan_value, 0, nan_value);
3975   TEST_ff_f (scalb, 0, nan_value, nan_value);
3976   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3977   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3978   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3979
3980   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3981   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3982
3983   END (scalb);
3984 }
3985
3986
3987 static void
3988 scalbn_test (void)
3989 {
3990
3991   START (scalbn);
3992
3993   TEST_fi_f (scalbn, 0, 0, 0);
3994   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3995
3996   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
3997   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
3998   TEST_fi_f (scalbn, nan_value, 1, nan_value);
3999
4000   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
4001   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
4002
4003   TEST_fi_f (scalbn, 1, 0L, 1);
4004
4005   END (scalbn);
4006 }
4007
4008
4009 static void
4010 scalbln_test (void)
4011 {
4012
4013   START (scalbln);
4014
4015   TEST_fl_f (scalbln, 0, 0, 0);
4016   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
4017
4018   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
4019   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
4020   TEST_fl_f (scalbln, nan_value, 1, nan_value);
4021
4022   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
4023   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
4024
4025   TEST_fl_f (scalbln, 1, 0L, 1);
4026
4027   END (scalbn);
4028 }
4029
4030
4031 static void
4032 signbit_test (void)
4033 {
4034
4035   START (signbit);
4036
4037   TEST_f_b (signbit, 0, 0);
4038   TEST_f_b (signbit, minus_zero, 1);
4039   TEST_f_b (signbit, plus_infty, 0);
4040   TEST_f_b (signbit, minus_infty, 1);
4041
4042   /* signbit (x) != 0 for x < 0.  */
4043   TEST_f_b (signbit, -1, 1);
4044   /* signbit (x) == 0 for x >= 0.  */
4045   TEST_f_b (signbit, 1, 0);
4046
4047   END (signbit);
4048 }
4049
4050
4051 static void
4052 sin_test (void)
4053 {
4054   errno = 0;
4055   FUNC(sin) (0);
4056   if (errno == ENOSYS)
4057     /* Function not implemented.  */
4058     return;
4059
4060   START (sin);
4061
4062   TEST_f_f (sin, 0, 0);
4063   TEST_f_f (sin, minus_zero, minus_zero);
4064   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
4065   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
4066   TEST_f_f (sin, nan_value, nan_value);
4067
4068   TEST_f_f (sin, M_PI_6l, 0.5);
4069   TEST_f_f (sin, -M_PI_6l, -0.5);
4070   TEST_f_f (sin, M_PI_2l, 1);
4071   TEST_f_f (sin, -M_PI_2l, -1);
4072   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
4073
4074 #ifdef TEST_DOUBLE
4075   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
4076 #endif
4077
4078   END (sin);
4079
4080 }
4081
4082
4083 static void
4084 sincos_test (void)
4085 {
4086   FLOAT sin_res, cos_res;
4087
4088   errno = 0;
4089   FUNC(sincos) (0, &sin_res, &cos_res);
4090   if (errno == ENOSYS)
4091     /* Function not implemented.  */
4092     return;
4093
4094   START (sincos);
4095
4096   /* sincos is treated differently because it returns void.  */
4097   TEST_extra (sincos, 0, 0, 1);
4098
4099   TEST_extra (sincos, minus_zero, minus_zero, 1);
4100   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4101   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
4102   TEST_extra (sincos, nan_value, nan_value, nan_value);
4103
4104   TEST_extra (sincos, M_PI_2l, 1, 0);
4105   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
4106   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
4107   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
4108
4109 #ifdef TEST_DOUBLE
4110   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
4111 #endif
4112
4113   END (sincos);
4114 }
4115
4116 static void
4117 sinh_test (void)
4118 {
4119   errno = 0;
4120   FUNC(sinh) (0.7L);
4121   if (errno == ENOSYS)
4122     /* Function not implemented.  */
4123     return;
4124
4125   START (sinh);
4126   TEST_f_f (sinh, 0, 0);
4127   TEST_f_f (sinh, minus_zero, minus_zero);
4128
4129 #ifndef TEST_INLINE
4130   TEST_f_f (sinh, plus_infty, plus_infty);
4131   TEST_f_f (sinh, minus_infty, minus_infty);
4132 #endif
4133   TEST_f_f (sinh, nan_value, nan_value);
4134
4135   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
4136   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
4137
4138   END (sinh);
4139 }
4140
4141 static void
4142 sqrt_test (void)
4143 {
4144   errno = 0;
4145   FUNC(sqrt) (1);
4146   if (errno == ENOSYS)
4147     /* Function not implemented.  */
4148     return;
4149
4150   START (sqrt);
4151
4152   TEST_f_f (sqrt, 0, 0);
4153   TEST_f_f (sqrt, nan_value, nan_value);
4154   TEST_f_f (sqrt, plus_infty, plus_infty);
4155
4156   TEST_f_f (sqrt, minus_zero, minus_zero);
4157
4158   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
4159   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
4160   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
4161   TEST_f_f (sqrt, nan_value, nan_value);
4162
4163   TEST_f_f (sqrt, 2209, 47);
4164   TEST_f_f (sqrt, 4, 2);
4165   TEST_f_f (sqrt, 2, M_SQRT2l);
4166   TEST_f_f (sqrt, 0.25, 0.5);
4167   TEST_f_f (sqrt, 6642.25, 81.5);
4168   TEST_f_f (sqrt, 15190.5625L, 123.25L);
4169   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
4170
4171   END (sqrt);
4172 }
4173
4174
4175 static void
4176 tan_test (void)
4177 {
4178   errno = 0;
4179   FUNC(tan) (0);
4180   if (errno == ENOSYS)
4181     /* Function not implemented.  */
4182     return;
4183
4184   START (tan);
4185
4186   TEST_f_f (tan, 0, 0);
4187   TEST_f_f (tan, minus_zero, minus_zero);
4188   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
4189   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
4190   TEST_f_f (tan, nan_value, nan_value);
4191
4192   TEST_f_f (tan, M_PI_4l, 1);
4193   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
4194
4195   END (tan);
4196 }
4197
4198 static void
4199 tanh_test (void)
4200 {
4201   errno = 0;
4202   FUNC(tanh) (0.7L);
4203   if (errno == ENOSYS)
4204     /* Function not implemented.  */
4205     return;
4206
4207   START (tanh);
4208
4209   TEST_f_f (tanh, 0, 0);
4210   TEST_f_f (tanh, minus_zero, minus_zero);
4211
4212 #ifndef TEST_INLINE
4213   TEST_f_f (tanh, plus_infty, 1);
4214   TEST_f_f (tanh, minus_infty, -1);
4215 #endif
4216   TEST_f_f (tanh, nan_value, nan_value);
4217
4218   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
4219   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
4220
4221   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
4222   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
4223
4224   /* 2^-57  */
4225   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
4226
4227   END (tanh);
4228 }
4229
4230 static void
4231 tgamma_test (void)
4232 {
4233   errno = 0;
4234   FUNC(tgamma) (1);
4235   if (errno == ENOSYS)
4236     /* Function not implemented.  */
4237     return;
4238   feclearexcept (FE_ALL_EXCEPT);
4239
4240   START (tgamma);
4241
4242   TEST_f_f (tgamma, plus_infty, plus_infty);
4243   TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4244   TEST_f_f (tgamma, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
4245   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
4246   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
4247   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
4248   TEST_f_f (tgamma, nan_value, nan_value);
4249
4250   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
4251   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
4252
4253   TEST_f_f (tgamma, 1, 1);
4254   TEST_f_f (tgamma, 4, 6);
4255
4256   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
4257   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
4258
4259   END (tgamma);
4260 }
4261
4262
4263 static void
4264 trunc_test (void)
4265 {
4266   START (trunc);
4267
4268   TEST_f_f (trunc, plus_infty, plus_infty);
4269   TEST_f_f (trunc, minus_infty, minus_infty);
4270   TEST_f_f (trunc, nan_value, nan_value);
4271
4272   TEST_f_f (trunc, 0, 0);
4273   TEST_f_f (trunc, minus_zero, minus_zero);
4274   TEST_f_f (trunc, 0.625, 0);
4275   TEST_f_f (trunc, -0.625, minus_zero);
4276   TEST_f_f (trunc, 1, 1);
4277   TEST_f_f (trunc, -1, -1);
4278   TEST_f_f (trunc, 1.625, 1);
4279   TEST_f_f (trunc, -1.625, -1);
4280
4281   TEST_f_f (trunc, 1048580.625L, 1048580L);
4282   TEST_f_f (trunc, -1048580.625L, -1048580L);
4283
4284   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
4285   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
4286
4287   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
4288   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
4289
4290
4291   END (trunc);
4292 }
4293
4294 static void
4295 y0_test (void)
4296 {
4297   FLOAT s, c;
4298   errno = 0;
4299   FUNC (sincos) (0, &s, &c);
4300   if (errno == ENOSYS)
4301     /* Required function not implemented.  */
4302     return;
4303   FUNC(y0) (1);
4304   if (errno == ENOSYS)
4305     /* Function not implemented.  */
4306     return;
4307
4308   /* y0 is the Bessel function of the second kind of order 0 */
4309   START (y0);
4310
4311   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
4312   TEST_f_f (y0, 0.0, minus_infty);
4313   TEST_f_f (y0, nan_value, nan_value);
4314   TEST_f_f (y0, plus_infty, 0);
4315
4316   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
4317   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
4318   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
4319   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
4320   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
4321   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
4322   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
4323
4324   END (y0);
4325 }
4326
4327
4328 static void
4329 y1_test (void)
4330 {
4331   FLOAT s, c;
4332   errno = 0;
4333   FUNC (sincos) (0, &s, &c);
4334   if (errno == ENOSYS)
4335     /* Required function not implemented.  */
4336     return;
4337   FUNC(y1) (1);
4338   if (errno == ENOSYS)
4339     /* Function not implemented.  */
4340     return;
4341
4342   /* y1 is the Bessel function of the second kind of order 1 */
4343   START (y1);
4344
4345   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
4346   TEST_f_f (y1, 0.0, minus_infty);
4347   TEST_f_f (y1, plus_infty, 0);
4348   TEST_f_f (y1, nan_value, nan_value);
4349
4350   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
4351   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
4352   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
4353   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
4354   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
4355   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
4356   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
4357
4358   END (y1);
4359 }
4360
4361
4362 static void
4363 yn_test (void)
4364 {
4365   FLOAT s, c;
4366   errno = 0;
4367   FUNC (sincos) (0, &s, &c);
4368   if (errno == ENOSYS)
4369     /* Required function not implemented.  */
4370     return;
4371   FUNC(yn) (1, 1);
4372   if (errno == ENOSYS)
4373     /* Function not implemented.  */
4374     return;
4375
4376   /* yn is the Bessel function of the second kind of order n */
4377   START (yn);
4378
4379   /* yn (0, x) == y0 (x)  */
4380   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
4381   TEST_ff_f (yn, 0, 0.0, minus_infty);
4382   TEST_ff_f (yn, 0, nan_value, nan_value);
4383   TEST_ff_f (yn, 0, plus_infty, 0);
4384
4385   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
4386   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
4387   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
4388   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
4389   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
4390   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
4391   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
4392
4393   /* yn (1, x) == y1 (x)  */
4394   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
4395   TEST_ff_f (yn, 1, 0.0, minus_infty);
4396   TEST_ff_f (yn, 1, plus_infty, 0);
4397   TEST_ff_f (yn, 1, nan_value, nan_value);
4398
4399   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
4400   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
4401   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
4402   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
4403   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
4404   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
4405   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
4406
4407   /* yn (3, x)  */
4408   TEST_ff_f (yn, 3, plus_infty, 0);
4409   TEST_ff_f (yn, 3, nan_value, nan_value);
4410
4411   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
4412   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
4413   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
4414   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
4415   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
4416
4417   /* yn (10, x)  */
4418   TEST_ff_f (yn, 10, plus_infty, 0);
4419   TEST_ff_f (yn, 10, nan_value, nan_value);
4420
4421   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
4422   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
4423   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
4424   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
4425   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
4426
4427   END (yn);
4428
4429 }
4430
4431
4432 static void
4433 significand_test (void)
4434 {
4435   /* significand returns the mantissa of the exponential representation.  */
4436   START (significand);
4437
4438   TEST_f_f (significand, 4.0, 1.0);
4439   TEST_f_f (significand, 6.0, 1.5);
4440   TEST_f_f (significand, 8.0, 1.0);
4441
4442   END (significand);
4443 }
4444
4445
4446 static void
4447 initialize (void)
4448 {
4449   fpstack_test ("start *init*");
4450   plus_zero = 0.0;
4451   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
4452
4453   minus_zero = FUNC(copysign) (0.0, -1.0);
4454   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
4455                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
4456   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
4457                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
4458   max_value = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
4459                       LDBL_MAX, DBL_MAX, FLT_MAX);
4460   min_value = CHOOSE (LDBL_MIN, DBL_MIN, FLT_MIN,
4461                       LDBL_MIN, DBL_MIN, FLT_MIN);
4462
4463   (void) &plus_zero;
4464   (void) &nan_value;
4465   (void) &minus_zero;
4466   (void) &plus_infty;
4467   (void) &minus_infty;
4468   (void) &max_value;
4469   (void) &min_value;
4470
4471   /* Clear all exceptions.  From now on we must not get random exceptions.  */
4472   feclearexcept (FE_ALL_EXCEPT);
4473
4474   /* Test to make sure we start correctly.  */
4475   fpstack_test ("end *init*");
4476 }
4477
4478 /* Definitions of arguments for argp functions.  */
4479 static const struct argp_option options[] =
4480 {
4481   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
4482   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
4483   { "no-max-error", 'f', NULL, 0,
4484     "Don't output maximal errors of functions"},
4485   { "no-points", 'p', NULL, 0,
4486     "Don't output results of functions invocations"},
4487   { "ignore-max-ulp", 'i', "yes/no", 0,
4488     "Ignore given maximal errors"},
4489   { NULL, 0, NULL, 0, NULL }
4490 };
4491
4492 /* Short description of program.  */
4493 static const char doc[] = "Math test suite: " TEST_MSG ;
4494
4495 /* Prototype for option handler.  */
4496 static error_t parse_opt (int key, char *arg, struct argp_state *state);
4497
4498 /* Data structure to communicate with argp functions.  */
4499 static struct argp argp =
4500 {
4501   options, parse_opt, NULL, doc,
4502 };
4503
4504
4505 /* Handle program arguments.  */
4506 static error_t
4507 parse_opt (int key, char *arg, struct argp_state *state)
4508 {
4509   switch (key)
4510     {
4511     case 'f':
4512       output_max_error = 0;
4513       break;
4514     case 'i':
4515       if (strcmp (arg, "yes") == 0)
4516         ignore_max_ulp = 1;
4517       else if (strcmp (arg, "no") == 0)
4518         ignore_max_ulp = 0;
4519       break;
4520     case 'p':
4521       output_points = 0;
4522       break;
4523     case 'u':
4524       output_ulps = 1;
4525       break;
4526     case 'v':
4527       if (optarg)
4528         verbose = (unsigned int) strtoul (optarg, NULL, 0);
4529       else
4530         verbose = 3;
4531       break;
4532     default:
4533       return ARGP_ERR_UNKNOWN;
4534     }
4535   return 0;
4536 }
4537
4538 #if 0
4539 /* function to check our ulp calculation.  */
4540 void
4541 check_ulp (void)
4542 {
4543   int i;
4544
4545   FLOAT u, diff, ulp;
4546   /* This gives one ulp.  */
4547   u = FUNC(nextafter) (10, 20);
4548   check_equal (10.0, u, 1, &diff, &ulp);
4549   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
4550
4551   /* This gives one more ulp.  */
4552   u = FUNC(nextafter) (u, 20);
4553   check_equal (10.0, u, 2, &diff, &ulp);
4554   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
4555
4556   /* And now calculate 100 ulp.  */
4557   for (i = 2; i < 100; i++)
4558     u = FUNC(nextafter) (u, 20);
4559   check_equal (10.0, u, 100, &diff, &ulp);
4560   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
4561 }
4562 #endif
4563
4564 int
4565 main (int argc, char **argv)
4566 {
4567
4568   int remaining;
4569
4570   verbose = 1;
4571   output_ulps = 0;
4572   output_max_error = 1;
4573   output_points = 1;
4574   /* XXX set to 0 for releases.  */
4575   ignore_max_ulp = 0;
4576
4577   /* Parse and process arguments.  */
4578   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
4579
4580   if (remaining != argc)
4581     {
4582       fprintf (stderr, "wrong number of arguments");
4583       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
4584       exit (EXIT_FAILURE);
4585     }
4586
4587   if (output_ulps)
4588     {
4589       ulps_file = fopen ("ULPs", "a");
4590       if (ulps_file == NULL)
4591         {
4592           perror ("can't open file `ULPs' for writing: ");
4593           exit (1);
4594         }
4595     }
4596
4597
4598   initialize ();
4599   printf (TEST_MSG);
4600
4601 #if 0
4602   check_ulp ();
4603 #endif
4604
4605   /* Keep the tests a wee bit ordered (according to ISO C99).  */
4606   /* Classification macros:  */
4607   fpclassify_test ();
4608   isfinite_test ();
4609   isnormal_test ();
4610   signbit_test ();
4611
4612   /* Trigonometric functions:  */
4613   acos_test ();
4614   asin_test ();
4615   atan_test ();
4616   atan2_test ();
4617   cos_test ();
4618   sin_test ();
4619   sincos_test ();
4620   tan_test ();
4621
4622   /* Hyperbolic functions:  */
4623   acosh_test ();
4624   asinh_test ();
4625   atanh_test ();
4626   cosh_test ();
4627   sinh_test ();
4628   tanh_test ();
4629
4630   /* Exponential and logarithmic functions:  */
4631   exp_test ();
4632   exp10_test ();
4633   exp2_test ();
4634   expm1_test ();
4635   frexp_test ();
4636   ldexp_test ();
4637   log_test ();
4638   log10_test ();
4639   log1p_test ();
4640   log2_test ();
4641   logb_test ();
4642   modf_test ();
4643   ilogb_test ();
4644   scalb_test ();
4645   scalbn_test ();
4646   scalbln_test ();
4647   significand_test ();
4648
4649   /* Power and absolute value functions:  */
4650   cbrt_test ();
4651   fabs_test ();
4652   hypot_test ();
4653   pow_test ();
4654   sqrt_test ();
4655
4656   /* Error and gamma functions:  */
4657   erf_test ();
4658   erfc_test ();
4659   gamma_test ();
4660   lgamma_test ();
4661   tgamma_test ();
4662
4663   /* Nearest integer functions:  */
4664   ceil_test ();
4665   floor_test ();
4666   nearbyint_test ();
4667   rint_test ();
4668   rint_test_tonearest ();
4669   rint_test_towardzero ();
4670   rint_test_downward ();
4671   rint_test_upward ();
4672   lrint_test ();
4673   llrint_test ();
4674   round_test ();
4675   lround_test ();
4676   llround_test ();
4677   trunc_test ();
4678
4679   /* Remainder functions:  */
4680   fmod_test ();
4681   remainder_test ();
4682   remquo_test ();
4683
4684   /* Manipulation functions:  */
4685   copysign_test ();
4686   nextafter_test ();
4687   nexttoward_test ();
4688
4689   /* maximum, minimum and positive difference functions */
4690   fdim_test ();
4691   fmax_test ();
4692   fmin_test ();
4693
4694   /* Multiply and add:  */
4695   fma_test ();
4696
4697   /* Complex functions:  */
4698   cabs_test ();
4699   cacos_test ();
4700   cacosh_test ();
4701   carg_test ();
4702   casin_test ();
4703   casinh_test ();
4704   catan_test ();
4705   catanh_test ();
4706   ccos_test ();
4707   ccosh_test ();
4708   cexp_test ();
4709   cimag_test ();
4710   clog10_test ();
4711   clog_test ();
4712   conj_test ();
4713   cpow_test ();
4714   cproj_test ();
4715   creal_test ();
4716   csin_test ();
4717   csinh_test ();
4718   csqrt_test ();
4719   ctan_test ();
4720   ctanh_test ();
4721
4722   /* Bessel functions:  */
4723   j0_test ();
4724   j1_test ();
4725   jn_test ();
4726   y0_test ();
4727   y1_test ();
4728   yn_test ();
4729
4730   if (output_ulps)
4731     fclose (ulps_file);
4732
4733   printf ("\nTest suite completed:\n");
4734   printf ("  %d test cases plus %d tests for exception flags executed.\n",
4735           noTests, noExcTests);
4736   if (noXFails)
4737     printf ("  %d expected failures occurred.\n", noXFails);
4738   if (noXPasses)
4739     printf ("  %d unexpected passes occurred.\n", noXPasses);
4740   if (noErrors)
4741     {
4742       printf ("  %d errors occurred.\n", noErrors);
4743       return 1;
4744     }
4745   printf ("  All tests passed successfully.\n");
4746
4747   return 0;
4748 }
4749
4750 /*
4751  * Local Variables:
4752  * mode:c
4753  * End:
4754  */