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