test/math/libm-test.inc

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