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