math/libm-test.inc

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