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