math/libm-test.inc

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