(M_PI_6l, M_E2l, M_E3l, M_2_SQRT_PIl, M_SQRT_PIl): Increase precision.
[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                 .52359877559829887307710723054658383L
138 #define M_E2l                   7.389056098930650227230427460575008L
139 #define M_E3l                   20.085536923187667740928529654581719L
140 #define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */
141 #define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* 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   errno = 0;
1433   FUNC(cbrt) (8);
1434   if (errno == ENOSYS)
1435     /* Function not implemented.  */
1436     return;
1437
1438   START (cbrt);
1439
1440   TEST_f_f (cbrt, 0.0, 0.0);
1441   TEST_f_f (cbrt, minus_zero, minus_zero);
1442
1443   TEST_f_f (cbrt, plus_infty, plus_infty);
1444   TEST_f_f (cbrt, minus_infty, minus_infty);
1445   TEST_f_f (cbrt, nan_value, nan_value);
1446
1447   TEST_f_f (cbrt, -0.001, -0.1L);
1448   TEST_f_f (cbrt, 8, 2);
1449   TEST_f_f (cbrt, -27.0, -3.0);
1450   TEST_f_f (cbrt, 0.970299, 0.99L);
1451   TEST_f_f (cbrt, 0.7, 0.8879040017426007084L);
1452
1453   END (cbrt);
1454 }
1455
1456 static void
1457 ccos_test (void)
1458 {
1459   errno = 0;
1460   FUNC(ccos) (BUILD_COMPLEX (0, 0));
1461   if (errno == ENOSYS)
1462     /* Function not implemented.  */
1463     return;
1464
1465   START (ccos);
1466
1467   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1468   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1469   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1470   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1471
1472   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1473   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1474   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1475   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1476
1477   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1478   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1479   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1480   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1481
1482   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1483   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1484   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1485   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1486
1487   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1488   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1489   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1490   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1491
1492   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1493   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1494   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1495   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1496
1497   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1498   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1499
1500   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1501   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1502
1503   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1504   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1505
1506   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1507   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1508
1509   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1510   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1511
1512   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1513   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1514
1515   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1516
1517   TEST_c_c (ccos, 0.7, 1.2, 1.3848657645312111080L, -0.97242170335830028619L);
1518
1519   TEST_c_c (ccos, -2, -3, -4.1896256909688072301L, -9.1092278937553365979L);
1520
1521   END (ccos, complex);
1522 }
1523
1524
1525 static void
1526 ccosh_test (void)
1527 {
1528   errno = 0;
1529   FUNC(ccosh) (BUILD_COMPLEX (0.7, 1.2));
1530   if (errno == ENOSYS)
1531     /* Function not implemented.  */
1532     return;
1533
1534   START (ccosh);
1535
1536   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1537   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1538   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1539   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1540
1541   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1542   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1543   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1544   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1545
1546   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1547   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1548   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1549   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1550
1551   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1552   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1553   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1554   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1555
1556   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1557   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1558   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1559   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1560
1561   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1562   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1563   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1564   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1565
1566   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1567   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1568
1569   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1570   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1571
1572   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1573   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1574
1575   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1576   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1577
1578   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1579   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1580
1581   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1582   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1583
1584   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1585
1586   TEST_c_c (ccosh, 0.7, 1.2, 0.4548202223691477654L, 0.7070296600921537682L);
1587
1588   TEST_c_c (ccosh, -2, -3, -3.7245455049153225654L, 0.5118225699873846088L);
1589
1590   END (ccosh, complex);
1591 }
1592
1593
1594 static void
1595 ceil_test (void)
1596 {
1597   START (ceil);
1598
1599   TEST_f_f (ceil, 0.0, 0.0);
1600   TEST_f_f (ceil, minus_zero, minus_zero);
1601   TEST_f_f (ceil, plus_infty, plus_infty);
1602   TEST_f_f (ceil, minus_infty, minus_infty);
1603   TEST_f_f (ceil, nan_value, nan_value);
1604
1605   TEST_f_f (ceil, M_PIl, 4.0);
1606   TEST_f_f (ceil, -M_PIl, -3.0);
1607
1608   END (ceil);
1609 }
1610
1611
1612 static void
1613 cexp_test (void)
1614 {
1615   errno = 0;
1616   FUNC(cexp) (BUILD_COMPLEX (0, 0));
1617   if (errno == ENOSYS)
1618     /* Function not implemented.  */
1619     return;
1620
1621   START (cexp);
1622
1623   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1624   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1625   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1626   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1627
1628   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1629   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1630
1631   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1632   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1633
1634   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1635   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1636
1637   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1638   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1639
1640   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1641   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1642
1643   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1644   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1645
1646   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1647   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1648   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1649   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1650
1651   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1652   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1653
1654   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1655   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1656
1657   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1658
1659   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1660
1661   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1662   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1663
1664   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1665   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1666   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1667   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1668
1669   TEST_c_c (cexp, 0.7, 1.2, 0.7296989091503236012L, 1.8768962328348102821L);
1670   TEST_c_c (cexp, -2.0, -3.0, -0.1339809149295426134L, -0.0190985162611351964L);
1671
1672   END (cexp, complex);
1673 }
1674
1675 static void
1676 cimag_test (void)
1677 {
1678   START (cimag);
1679   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1680   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1681   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1682   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1683   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1684   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1685   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1686
1687   END (cimag);
1688 }
1689
1690 static void
1691 clog_test (void)
1692 {
1693   errno = 0;
1694   FUNC(clog) (BUILD_COMPLEX (-2, -3));
1695   if (errno == ENOSYS)
1696     /* Function not implemented.  */
1697     return;
1698
1699   START (clog);
1700
1701   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1702   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1703
1704   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1705   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1706
1707   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1708   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1709
1710   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1711   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1712
1713   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1714   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1715   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1716   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1717   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1718   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1719   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1720   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1721
1722   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1723   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1724   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1725   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1726
1727   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1728   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1729   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1730   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1731
1732   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1733   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1734
1735   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1736   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1737
1738   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1739   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1740   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1741   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1742
1743   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1744   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1745   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1746   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1747
1748   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1749   TEST_c_c (clog, -2, -3, 1.2824746787307683680L, -2.1587989303424641704L);
1750
1751   END (clog, complex);
1752 }
1753
1754
1755 static void
1756 clog10_test (void)
1757 {
1758   errno = 0;
1759   FUNC(clog10) (BUILD_COMPLEX (0.7, 1.2));
1760   if (errno == ENOSYS)
1761     /* Function not implemented.  */
1762     return;
1763
1764   START (clog10);
1765
1766   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1767   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1768
1769   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1770   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1771
1772   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1773
1774   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1775   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1776
1777   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1778   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1779   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1780   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1781   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1782   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1783   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1784   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1785
1786   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1787   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1788   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1789   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1790
1791   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1792   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1793   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1794   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1795
1796   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1797   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1798
1799   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1800   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1801
1802   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1803   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1804   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1805   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1806
1807   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1808   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1809   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1810   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1811
1812   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1813
1814   TEST_c_c (clog10, 0.7, 1.2, 0.1427786545038868803L, 0.4528483579352493248L);
1815   TEST_c_c (clog10, -2, -3, 0.5569716761534183846L, -0.9375544629863747085L);
1816
1817   END (clog10, complex);
1818 }
1819
1820 static void
1821 conj_test (void)
1822 {
1823   START (conj);
1824   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1825   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1826   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1827   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1828   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1829   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1830   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1831
1832   END (conj, complex);
1833 }
1834
1835
1836 static void
1837 copysign_test (void)
1838 {
1839   START (copysign);
1840
1841   TEST_ff_f (copysign, 0, 4, 0);
1842   TEST_ff_f (copysign, 0, -4, minus_zero);
1843   TEST_ff_f (copysign, minus_zero, 4, 0);
1844   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1845
1846   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1847   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1848   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1849   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1850
1851   TEST_ff_f (copysign, 0, plus_infty, 0);
1852   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1853   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1854   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1855
1856   /* XXX More correctly we would have to check the sign of the NaN.  */
1857   TEST_ff_f (copysign, nan_value, 0, nan_value);
1858   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1859   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1860   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1861
1862   END (copysign);
1863 }
1864
1865 static void
1866 cos_test (void)
1867 {
1868   errno = 0;
1869   FUNC(cos) (0);
1870   if (errno == ENOSYS)
1871     /* Function not implemented.  */
1872     return;
1873
1874   START (cos);
1875
1876   TEST_f_f (cos, 0, 1);
1877   TEST_f_f (cos, minus_zero, 1);
1878   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1879   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1880   TEST_f_f (cos, nan_value, nan_value);
1881
1882   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1883   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1884   TEST_f_f (cos, M_PI_2l, 0);
1885
1886   TEST_f_f (cos, 0.7, 0.7648421872844884262L);
1887
1888   END (cos);
1889 }
1890
1891 static void
1892 cosh_test (void)
1893 {
1894   errno = 0;
1895   FUNC(cosh) (0.7);
1896   if (errno == ENOSYS)
1897     /* Function not implemented.  */
1898     return;
1899
1900   START (cosh);
1901   TEST_f_f (cosh, 0, 1);
1902   TEST_f_f (cosh, minus_zero, 1);
1903
1904 #ifndef TEST_INLINE
1905   TEST_f_f (cosh, plus_infty, plus_infty);
1906   TEST_f_f (cosh, minus_infty, plus_infty);
1907 #endif
1908   TEST_f_f (cosh, nan_value, nan_value);
1909
1910   TEST_f_f (cosh, 0.7, 1.255169005630943018L);
1911   END (cosh);
1912 }
1913
1914
1915 static void
1916 cpow_test (void)
1917 {
1918   errno = 0;
1919   FUNC(cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0));
1920   if (errno == ENOSYS)
1921     /* Function not implemented.  */
1922     return;
1923
1924   START (cpow);
1925
1926   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
1927   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
1928
1929   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
1930   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
1931
1932   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
1933
1934   END (cpow, complex);
1935 }
1936
1937 static void
1938 cproj_test (void)
1939 {
1940   START (cproj);
1941   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
1942   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
1943   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
1944   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
1945
1946   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
1947
1948   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
1949   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
1950   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
1951   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
1952
1953   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
1954   TEST_c_c (cproj, 2.0, 3.0, 0.28571428571428571429L, .42857142857142857143L);
1955
1956   END (cproj, complex);
1957 }
1958
1959 static void
1960 creal_test (void)
1961 {
1962   START (creal);
1963   TEST_c_f (creal, 0.0, 1.0, 0.0);
1964   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
1965   TEST_c_f (creal, nan_value, 1.0, nan_value);
1966   TEST_c_f (creal, nan_value, nan_value, nan_value);
1967   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
1968   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
1969   TEST_c_f (creal, 2.0, 3.0, 2.0);
1970
1971   END (creal);
1972 }
1973
1974 static void
1975 csin_test (void)
1976 {
1977   errno = 0;
1978   FUNC(csin) (BUILD_COMPLEX (0.7, 1.2));
1979   if (errno == ENOSYS)
1980     /* Function not implemented.  */
1981     return;
1982
1983   START (csin);
1984
1985   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
1986   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
1987   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
1988   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
1989
1990   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
1991   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
1992   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
1993   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
1994
1995   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1996   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1997   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1998   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1999
2000   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2001   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2002   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2003   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2004
2005   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2006   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
2007   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
2008   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
2009
2010   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
2011   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
2012   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
2013   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
2014
2015   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2016   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
2017
2018   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2019   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2020
2021   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2022   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2023
2024   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
2025   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
2026
2027   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2028   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2029
2030   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2031   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2032
2033   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
2034
2035   TEST_c_c (csin, 0.7, 1.2, 1.1664563419657581376L, 1.1544997246948547371L);
2036
2037   TEST_c_c (csin, -2, -3, -9.1544991469114295734L, 4.1689069599665643507L);
2038
2039   END (csin, complex);
2040 }
2041
2042
2043 static void
2044 csinh_test (void)
2045 {
2046   errno = 0;
2047   FUNC(csinh) (BUILD_COMPLEX (0.7, 1.2));
2048   if (errno == ENOSYS)
2049     /* Function not implemented.  */
2050     return;
2051
2052   START (csinh);
2053
2054   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
2055   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
2056   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
2057   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
2058
2059   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2060   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2061   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2062   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2063
2064   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
2065   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
2066   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
2067   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
2068
2069   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2070   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2071   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2072   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
2073
2074   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
2075   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
2076   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
2077   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
2078
2079   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2080   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2081   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2082   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2083
2084   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2085   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
2086
2087   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2088   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
2089
2090   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
2091   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
2092
2093   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
2094   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
2095
2096   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2097   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2098
2099   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2100   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2101
2102   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
2103
2104   TEST_c_c (csinh, 0.7, 1.2, 0.27487868678117583582L, 1.1698665727426565139L);
2105   TEST_c_c (csinh, -2, -3, 3.5905645899857799520L, -0.5309210862485198052L);
2106
2107   END (csinh, complex);
2108 }
2109
2110 static void
2111 csqrt_test (void)
2112 {
2113   errno = 0;
2114   FUNC(csqrt) (BUILD_COMPLEX (-1, 0));
2115   if (errno == ENOSYS)
2116     /* Function not implemented.  */
2117     return;
2118
2119   START (csqrt);
2120
2121   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
2122   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
2123   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
2124   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
2125
2126   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
2127   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
2128   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
2129   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
2130
2131   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
2132   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
2133   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
2134   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
2135
2136   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
2137   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
2138   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
2139   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
2140   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
2141   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
2142   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
2143   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
2144   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
2145   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
2146   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
2147   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
2148
2149   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
2150
2151   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2152
2153   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2154   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2155   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2156   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2157
2158   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2159   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2160   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2161   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2162
2163   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2164
2165   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2166   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2167   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2168   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2169   TEST_c_c (csqrt, 0.7, 1.2, 1.0220676100300264507L, 0.5870453129635652115L);
2170   TEST_c_c (csqrt, -2, -3, 0.8959774761298381247L, -1.6741492280355400404L);
2171   TEST_c_c (csqrt, -2, 3, 0.8959774761298381247L, 1.6741492280355400404L);
2172
2173   END (csqrt, complex);
2174 }
2175
2176 static void
2177 ctan_test (void)
2178 {
2179   errno = 0;
2180   FUNC(ctan) (BUILD_COMPLEX (0.7, 1.2));
2181   if (errno == ENOSYS)
2182     /* Function not implemented.  */
2183     return;
2184
2185   START (ctan);
2186
2187   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2188   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2189   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2190   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2191
2192   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2193   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2194   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2195   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2196
2197   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2198   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2199   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2200   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2201
2202   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2203   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2204   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2205   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2206   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2207   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2208   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2209   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2210
2211   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2212   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2213
2214   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2215   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2216
2217   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2218   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2219
2220   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2221   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2222   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2223   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2224
2225   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2226
2227   TEST_c_c (ctan, 0.7, 1.2, 0.1720734197630349001L, 0.9544807059989405538L);
2228   TEST_c_c (ctan, -2, -3, 0.0037640256415042482L, -1.0032386273536098014L);
2229
2230   END (ctan, complex);
2231 }
2232
2233
2234 static void
2235 ctanh_test (void)
2236 {
2237   errno = 0;
2238   FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2239   if (errno == ENOSYS)
2240     /* Function not implemented.  */
2241     return;
2242
2243   START (ctanh);
2244
2245   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2246   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2247   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2248   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2249
2250   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2251   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2252   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2253   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2254   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2255   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2256   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2257   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2258
2259   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2260   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2261   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2262   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2263   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2264   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2265   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2266   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2267
2268   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2269   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2270
2271   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2272   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2273
2274   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2275   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2276
2277   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2278   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2279   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2280   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2281
2282   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2283
2284   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2285
2286   TEST_c_c (ctanh, 0.7, 1.2, 1.3472197399061191630L, 0.4778641038326365540L);
2287   TEST_c_c (ctanh, -2, -3, -0.9653858790221331242L, 0.0098843750383224937L);
2288
2289   END (ctanh, complex);
2290 }
2291
2292 static void
2293 erf_test (void)
2294 {
2295   errno = 0;
2296   FUNC(erf) (0);
2297   if (errno == ENOSYS)
2298     /* Function not implemented.  */
2299     return;
2300
2301   START (erf);
2302
2303   TEST_f_f (erf, 0, 0);
2304   TEST_f_f (erf, minus_zero, minus_zero);
2305   TEST_f_f (erf, plus_infty, 1);
2306   TEST_f_f (erf, minus_infty, -1);
2307   TEST_f_f (erf, nan_value, nan_value);
2308
2309   TEST_f_f (erf, 0.7, 0.67780119383741847297L);
2310
2311   TEST_f_f (erf, 1.2, 0.91031397822963538024L);
2312   TEST_f_f (erf, 2.0, 0.99532226501895273416L);
2313   TEST_f_f (erf, 4.1, 0.99999999329997234592L);
2314   TEST_f_f (erf, 27, 1.0L);
2315
2316   END (erf);
2317 }
2318
2319
2320 static void
2321 erfc_test (void)
2322 {
2323   errno = 0;
2324   FUNC(erfc) (0);
2325   if (errno == ENOSYS)
2326     /* Function not implemented.  */
2327     return;
2328
2329   START (erfc);
2330
2331   TEST_f_f (erfc, plus_infty, 0.0);
2332   TEST_f_f (erfc, minus_infty, 2.0);
2333   TEST_f_f (erfc, 0.0, 1.0);
2334   TEST_f_f (erfc, minus_zero, 1.0);
2335   TEST_f_f (erfc, nan_value, nan_value);
2336
2337   TEST_f_f (erfc, 0.7, 0.32219880616258152702L);
2338
2339   TEST_f_f (erfc, 1.2, 0.089686021770364619762L);
2340   TEST_f_f (erfc, 2.0, 0.0046777349810472658379L);
2341   TEST_f_f (erfc, 4.1, 0.67000276540848983727e-8L);
2342   TEST_f_f (erfc, 9, 0.41370317465138102381e-36L);
2343
2344   END (erfc);
2345 }
2346
2347 static void
2348 exp_test (void)
2349 {
2350   errno = 0;
2351   FUNC(exp) (0);
2352   if (errno == ENOSYS)
2353     /* Function not implemented.  */
2354     return;
2355
2356   START (exp);
2357
2358   TEST_f_f (exp, 0, 1);
2359   TEST_f_f (exp, minus_zero, 1);
2360
2361 #ifndef TEST_INLINE
2362   TEST_f_f (exp, plus_infty, plus_infty);
2363   TEST_f_f (exp, minus_infty, 0);
2364 #endif
2365   TEST_f_f (exp, nan_value, nan_value);
2366   TEST_f_f (exp, 1, M_El);
2367
2368   TEST_f_f (exp, 2, M_E2l);
2369   TEST_f_f (exp, 3, M_E3l);
2370   TEST_f_f (exp, 0.7, 2.0137527074704765216L);
2371
2372   END (exp);
2373 }
2374
2375
2376 static void
2377 exp10_test (void)
2378 {
2379   errno = 0;
2380   FUNC(exp10) (0);
2381   if (errno == ENOSYS)
2382     /* Function not implemented.  */
2383     return;
2384
2385   START (exp10);
2386
2387   TEST_f_f (exp10, 0, 1);
2388   TEST_f_f (exp10, minus_zero, 1);
2389
2390   TEST_f_f (exp10, plus_infty, plus_infty);
2391   TEST_f_f (exp10, minus_infty, 0);
2392   TEST_f_f (exp10, nan_value, nan_value);
2393   TEST_f_f (exp10, 3, 1000);
2394   TEST_f_f (exp10, -1, 0.1L);
2395   TEST_f_f (exp10, 1e6, plus_infty);
2396   TEST_f_f (exp10, -1e6, 0);
2397   TEST_f_f (exp10, 0.7, 5.0118723362727228500L);
2398
2399   END (exp10);
2400 }
2401
2402 static void
2403 exp2_test (void)
2404 {
2405   errno = 0;
2406   FUNC(exp2) (0);
2407   if (errno == ENOSYS)
2408     /* Function not implemented.  */
2409     return;
2410
2411   START (exp2);
2412
2413   TEST_f_f (exp2, 0, 1);
2414   TEST_f_f (exp2, minus_zero, 1);
2415   TEST_f_f (exp2, plus_infty, plus_infty);
2416   TEST_f_f (exp2, minus_infty, 0);
2417   TEST_f_f (exp2, nan_value, nan_value);
2418
2419   TEST_f_f (exp2, 10, 1024);
2420   TEST_f_f (exp2, -1, 0.5);
2421   TEST_f_f (exp2, 1e6, plus_infty);
2422   TEST_f_f (exp2, -1e6, 0);
2423   TEST_f_f (exp2, 0.7, 1.6245047927124710452L);
2424
2425   END (exp2);
2426 }
2427
2428 static void
2429 expm1_test (void)
2430 {
2431   errno = 0;
2432   FUNC(expm1) (0);
2433   if (errno == ENOSYS)
2434     /* Function not implemented.  */
2435     return;
2436
2437   START (expm1);
2438
2439   TEST_f_f (expm1, 0, 0);
2440   TEST_f_f (expm1, minus_zero, minus_zero);
2441
2442 #ifndef TEST_INLINE
2443   TEST_f_f (expm1, plus_infty, plus_infty);
2444   TEST_f_f (expm1, minus_infty, -1);
2445 #endif
2446   TEST_f_f (expm1, nan_value, nan_value);
2447
2448   TEST_f_f (expm1, 1, M_El - 1.0);
2449   TEST_f_f (expm1, 0.7, 1.0137527074704765216L);
2450
2451   END (expm1);
2452 }
2453
2454 static void
2455 fabs_test (void)
2456 {
2457   START (fabs);
2458
2459   TEST_f_f (fabs, 0, 0);
2460   TEST_f_f (fabs, minus_zero, 0);
2461
2462   TEST_f_f (fabs, plus_infty, plus_infty);
2463   TEST_f_f (fabs, minus_infty, plus_infty);
2464   TEST_f_f (fabs, nan_value, nan_value);
2465
2466   TEST_f_f (fabs, 38.0, 38.0);
2467   TEST_f_f (fabs, -M_El, M_El);
2468
2469   END (fabs);
2470 }
2471
2472 static void
2473 fdim_test (void)
2474 {
2475   START (fdim);
2476
2477   TEST_ff_f (fdim, 0, 0, 0);
2478   TEST_ff_f (fdim, 9, 0, 9);
2479   TEST_ff_f (fdim, 0, 9, 0);
2480   TEST_ff_f (fdim, -9, 0, 0);
2481   TEST_ff_f (fdim, 0, -9, 9);
2482
2483   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2484   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2485   TEST_ff_f (fdim, minus_infty, 9, 0);
2486   TEST_ff_f (fdim, minus_infty, -9, 0);
2487   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2488   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2489   TEST_ff_f (fdim, 9, plus_infty, 0);
2490   TEST_ff_f (fdim, -9, plus_infty, 0);
2491
2492   TEST_ff_f (fdim, 0, nan_value, nan_value);
2493   TEST_ff_f (fdim, 9, nan_value, nan_value);
2494   TEST_ff_f (fdim, -9, nan_value, nan_value);
2495   TEST_ff_f (fdim, nan_value, 9, nan_value);
2496   TEST_ff_f (fdim, nan_value, -9, nan_value);
2497   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2498   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2499   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2500   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2501   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2502
2503   END (fdim);
2504 }
2505
2506 static void
2507 floor_test (void)
2508 {
2509   START (floor);
2510
2511   TEST_f_f (floor, 0.0, 0.0);
2512   TEST_f_f (floor, minus_zero, minus_zero);
2513   TEST_f_f (floor, plus_infty, plus_infty);
2514   TEST_f_f (floor, minus_infty, minus_infty);
2515   TEST_f_f (floor, nan_value, nan_value);
2516
2517   TEST_f_f (floor, M_PIl, 3.0);
2518   TEST_f_f (floor, -M_PIl, -4.0);
2519
2520   END (floor);
2521 }
2522
2523 static void
2524 fma_test (void)
2525 {
2526   START (fma);
2527
2528   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2529   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2530   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2531   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2532   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2533   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2534   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2535   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2536   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2537   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2538   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2539   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2540
2541   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2542   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2543   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2544   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2545
2546   END (fma);
2547 }
2548
2549
2550 static void
2551 fmax_test (void)
2552 {
2553   START (fmax);
2554
2555   TEST_ff_f (fmax, 0, 0, 0);
2556   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2557   TEST_ff_f (fmax, 9, 0, 9);
2558   TEST_ff_f (fmax, 0, 9, 9);
2559   TEST_ff_f (fmax, -9, 0, 0);
2560   TEST_ff_f (fmax, 0, -9, 0);
2561
2562   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2563   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2564   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2565   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2566
2567   TEST_ff_f (fmax, minus_infty, 9, 9);
2568   TEST_ff_f (fmax, minus_infty, -9, -9);
2569   TEST_ff_f (fmax, 9, minus_infty, 9);
2570   TEST_ff_f (fmax, -9, minus_infty, -9);
2571
2572   TEST_ff_f (fmax, 0, nan_value, 0);
2573   TEST_ff_f (fmax, 9, nan_value, 9);
2574   TEST_ff_f (fmax, -9, nan_value, -9);
2575   TEST_ff_f (fmax, nan_value, 0, 0);
2576   TEST_ff_f (fmax, nan_value, 9, 9);
2577   TEST_ff_f (fmax, nan_value, -9, -9);
2578   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2579   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2580   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2581   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2582   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2583
2584   END (fmax);
2585 }
2586
2587
2588 static void
2589 fmin_test (void)
2590 {
2591   START (fmin);
2592
2593   TEST_ff_f (fmin, 0, 0, 0);
2594   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2595   TEST_ff_f (fmin, 9, 0, 0);
2596   TEST_ff_f (fmin, 0, 9, 0);
2597   TEST_ff_f (fmin, -9, 0, -9);
2598   TEST_ff_f (fmin, 0, -9, -9);
2599
2600   TEST_ff_f (fmin, plus_infty, 9, 9);
2601   TEST_ff_f (fmin, 9, plus_infty, 9);
2602   TEST_ff_f (fmin, plus_infty, -9, -9);
2603   TEST_ff_f (fmin, -9, plus_infty, -9);
2604   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2605   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2606   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2607   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2608
2609   TEST_ff_f (fmin, 0, nan_value, 0);
2610   TEST_ff_f (fmin, 9, nan_value, 9);
2611   TEST_ff_f (fmin, -9, nan_value, -9);
2612   TEST_ff_f (fmin, nan_value, 0, 0);
2613   TEST_ff_f (fmin, nan_value, 9, 9);
2614   TEST_ff_f (fmin, nan_value, -9, -9);
2615   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2616   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2617   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2618   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2619   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2620
2621   END (fmin);
2622 }
2623
2624
2625 static void
2626 fmod_test (void)
2627 {
2628   errno = 0;
2629   FUNC(fmod) (6.5, 2.3);
2630   if (errno == ENOSYS)
2631     /* Function not implemented.  */
2632     return;
2633
2634   START (fmod);
2635
2636   /* fmod (+0, y) == +0 for y != 0.  */
2637   TEST_ff_f (fmod, 0, 3, 0);
2638
2639   /* fmod (-0, y) == -0 for y != 0.  */
2640   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2641
2642   /* fmod (+inf, y) == NaN plus invalid exception.  */
2643   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2644   /* fmod (-inf, y) == NaN plus invalid exception.  */
2645   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2646   /* fmod (x, +0) == NaN plus invalid exception.  */
2647   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2648   /* fmod (x, -0) == NaN plus invalid exception.  */
2649   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2650
2651   /* fmod (x, +inf) == x for x not infinite.  */
2652   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2653   /* fmod (x, -inf) == x for x not infinite.  */
2654   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2655
2656   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2657
2658   TEST_ff_f (fmod, 6.5, 2.3, 1.9L);
2659   TEST_ff_f (fmod, -6.5, 2.3, -1.9L);
2660   TEST_ff_f (fmod, 6.5, -2.3, 1.9L);
2661   TEST_ff_f (fmod, -6.5, -2.3, -1.9L);
2662
2663   END (fmod);
2664 }
2665
2666 static void
2667 fpclassify_test (void)
2668 {
2669   START (fpclassify);
2670
2671   TEST_f_i (fpclassify, nan_value, FP_NAN);
2672   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2673   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2674   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2675   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2676   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2677
2678   END (fpclassify);
2679 }
2680
2681
2682 static void
2683 frexp_test (void)
2684 {
2685   int x;
2686
2687   START (frexp);
2688
2689   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2690   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2691   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2692
2693   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2694   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2695
2696   TEST_fI_f1 (frexp, 12.8, 0.8L, 4);
2697   TEST_fI_f1 (frexp, -27.34, -0.854375L, 5);
2698
2699   END (frexp);
2700 }
2701
2702
2703 static void
2704 gamma_test (void)
2705 {
2706   errno = 0;
2707   FUNC(gamma) (1);
2708
2709   if (errno == ENOSYS)
2710     /* Function not implemented.  */
2711     return;
2712   feclearexcept (FE_ALL_EXCEPT);
2713
2714   START (gamma);
2715
2716   TEST_f_f (gamma, plus_infty, plus_infty);
2717   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2718   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2719   TEST_f_f (gamma, minus_infty, plus_infty);
2720   TEST_f_f (gamma, nan_value, nan_value);
2721
2722   TEST_f_f1 (gamma, 1, 0, 1);
2723   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2724
2725   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2726   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2727
2728   END (gamma);
2729 }
2730
2731 static void
2732 hypot_test (void)
2733 {
2734   errno = 0;
2735   FUNC(hypot) (0.7, 12.4);
2736   if (errno == ENOSYS)
2737     /* Function not implemented.  */
2738     return;
2739
2740   START (hypot);
2741
2742   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2743   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2744
2745 #ifndef TEST_INLINE
2746   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2747   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2748   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2749   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2750 #endif
2751
2752   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2753
2754   /* hypot (x,y) == hypot (+-x, +-y)  */
2755   TEST_ff_f (hypot, 0.7, 12.4, 12.41974234837422060118L);
2756   TEST_ff_f (hypot, -0.7, 12.4, 12.41974234837422060118L);
2757   TEST_ff_f (hypot, 0.7, -12.4, 12.41974234837422060118L);
2758   TEST_ff_f (hypot, -0.7, -12.4, 12.41974234837422060118L);
2759   TEST_ff_f (hypot, 12.4, 0.7, 12.41974234837422060118L);
2760   TEST_ff_f (hypot, -12.4, 0.7, 12.41974234837422060118L);
2761   TEST_ff_f (hypot, 12.4, -0.7, 12.41974234837422060118L);
2762   TEST_ff_f (hypot, -12.4, -0.7, 12.41974234837422060118L);
2763
2764   /*  hypot (x,0) == fabs (x)  */
2765   TEST_ff_f (hypot, 0.7, 0, 0.7L);
2766   TEST_ff_f (hypot, -0.7, 0, 0.7L);
2767   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7L);
2768
2769   TEST_ff_f (hypot, 0.7, 1.2, 1.3892443989449804508L);
2770
2771   END (hypot);
2772 }
2773
2774
2775 static void
2776 ilogb_test (void)
2777 {
2778   START (ilogb);
2779
2780   TEST_f_i (ilogb, 1, 0);
2781   TEST_f_i (ilogb, M_El, 1);
2782   TEST_f_i (ilogb, 1024, 10);
2783   TEST_f_i (ilogb, -2000, 10);
2784
2785   /* XXX We have a problem here: the standard does not tell us whether
2786      exceptions are allowed/required.  ignore them for now.  */
2787
2788   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2789   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2790
2791   END (ilogb);
2792 }
2793
2794 static void
2795 isfinite_test (void)
2796 {
2797   START (isfinite);
2798
2799   TEST_f_b (isfinite, 0, 1);
2800   TEST_f_b (isfinite, minus_zero, 1);
2801   TEST_f_b (isfinite, 10, 1);
2802   TEST_f_b (isfinite, plus_infty, 0);
2803   TEST_f_b (isfinite, minus_infty, 0);
2804   TEST_f_b (isfinite, nan_value, 0);
2805
2806   END (isfinite);
2807 }
2808
2809 static void
2810 isnormal_test (void)
2811 {
2812   START (isnormal);
2813
2814   TEST_f_b (isnormal, 0, 0);
2815   TEST_f_b (isnormal, minus_zero, 0);
2816   TEST_f_b (isnormal, 10, 1);
2817   TEST_f_b (isnormal, plus_infty, 0);
2818   TEST_f_b (isnormal, minus_infty, 0);
2819   TEST_f_b (isnormal, nan_value, 0);
2820
2821   END (isnormal);
2822 }
2823
2824 static void
2825 j0_test (void)
2826 {
2827   errno = 0;
2828   FUNC(j0) (0);
2829   if (errno == ENOSYS)
2830     /* Function not implemented.  */
2831     return;
2832
2833   START (j0);
2834
2835   /* j0 is the Bessel function of the first kind of order 0 */
2836   TEST_f_f (j0, nan_value, nan_value);
2837   TEST_f_f (j0, plus_infty, 0);
2838   TEST_f_f (j0, -1.0, 0.76519768655796655145);
2839   TEST_f_f (j0, 0.0, 1.0);
2840   TEST_f_f (j0, 0.1, 0.99750156206604003228);
2841   TEST_f_f (j0, 0.7, 0.88120088860740528084);
2842   TEST_f_f (j0, 1.0, 0.76519768655796655145);
2843   TEST_f_f (j0, 1.5, 0.51182767173591812875);
2844   TEST_f_f (j0, 2.0, 0.22389077914123566805);
2845   TEST_f_f (j0, 8.0, 0.17165080713755390609);
2846   TEST_f_f (j0, 10.0, -0.24593576445134833520);
2847
2848   END (j0);
2849 }
2850
2851
2852 static void
2853 j1_test (void)
2854 {
2855   errno = 0;
2856   FUNC(j1) (0);
2857   if (errno == ENOSYS)
2858     /* Function not implemented.  */
2859     return;
2860
2861   /* j1 is the Bessel function of the first kind of order 1 */
2862
2863   START (j1);
2864
2865   TEST_f_f (j1, nan_value, nan_value);
2866   TEST_f_f (j1, plus_infty, 0);
2867
2868   TEST_f_f (j1, -1.0, -0.44005058574493351596);
2869   TEST_f_f (j1, 0.0, 0.0);
2870   TEST_f_f (j1, 0.1, 0.049937526036241997556);
2871   TEST_f_f (j1, 0.7, 0.32899574154005894785);
2872   TEST_f_f (j1, 1.0, 0.44005058574493351596);
2873   TEST_f_f (j1, 1.5, 0.55793650791009964199);
2874   TEST_f_f (j1, 2.0, 0.57672480775687338720);
2875   TEST_f_f (j1, 8.0, 0.23463634685391462438);
2876   TEST_f_f (j1, 10.0, 0.043472746168861436670);
2877
2878   END (j1);
2879 }
2880
2881 static void
2882 jn_test (void)
2883 {
2884   errno = 0;
2885   FUNC(jn) (1, 1);
2886   if (errno == ENOSYS)
2887     /* Function not implemented.  */
2888     return;
2889
2890   /* jn is the Bessel function of the first kind of order n.  */
2891   START (jn);
2892
2893   /* jn (0, x) == j0 (x)  */
2894   TEST_ff_f (jn, 0, nan_value, nan_value);
2895   TEST_ff_f (jn, 0, plus_infty, 0);
2896   TEST_ff_f (jn, 0, -1.0, 0.76519768655796655145);
2897   TEST_ff_f (jn, 0, 0.0, 1.0);
2898   TEST_ff_f (jn, 0, 0.1, 0.99750156206604003228);
2899   TEST_ff_f (jn, 0, 0.7, 0.88120088860740528084);
2900   TEST_ff_f (jn, 0, 1.0, 0.76519768655796655145);
2901   TEST_ff_f (jn, 0, 1.5, 0.51182767173591812875);
2902   TEST_ff_f (jn, 0, 2.0, 0.22389077914123566805);
2903   TEST_ff_f (jn, 0, 8.0, 0.17165080713755390609);
2904   TEST_ff_f (jn, 0, 10.0, -0.24593576445134833520);
2905
2906   /* jn (1, x) == j1 (x)  */
2907   TEST_ff_f (jn, 1, nan_value, nan_value);
2908   TEST_ff_f (jn, 1, plus_infty, 0);
2909
2910   TEST_ff_f (jn, 1, -1.0, -0.44005058574493351596);
2911   TEST_ff_f (jn, 1, 0.0, 0.0);
2912   TEST_ff_f (jn, 1, 0.1, 0.049937526036241997556);
2913   TEST_ff_f (jn, 1, 0.7, 0.32899574154005894785);
2914   TEST_ff_f (jn, 1, 1.0, 0.44005058574493351596);
2915   TEST_ff_f (jn, 1, 1.5, 0.55793650791009964199);
2916   TEST_ff_f (jn, 1, 2.0, 0.57672480775687338720);
2917   TEST_ff_f (jn, 1, 8.0, 0.23463634685391462438);
2918   TEST_ff_f (jn, 1, 10.0, 0.043472746168861436670);
2919
2920   /* jn (3, x)  */
2921   TEST_ff_f (jn, 3, nan_value, nan_value);
2922   TEST_ff_f (jn, 3, plus_infty, 0);
2923
2924   TEST_ff_f (jn, 3, -1.0, -0.019563353982668405919);
2925   TEST_ff_f (jn, 3, 0.0, 0.0);
2926   TEST_ff_f (jn, 3, 0.1, 0.000020820315754756261429);
2927   TEST_ff_f (jn, 3, 0.7, 0.0069296548267508408077);
2928   TEST_ff_f (jn, 3, 1.0, 0.019563353982668405919);
2929   TEST_ff_f (jn, 3, 2.0, 0.12894324947440205110);
2930   TEST_ff_f (jn, 3, 10.0, 0.058379379305186812343);
2931
2932   /*  jn (10, x)  */
2933   TEST_ff_f (jn, 10, nan_value, nan_value);
2934   TEST_ff_f (jn, 10, plus_infty, 0);
2935
2936   TEST_ff_f (jn, 10, -1.0, 0.26306151236874532070e-9);
2937   TEST_ff_f (jn, 10, 0.0, 0.0);
2938   TEST_ff_f (jn, 10, 0.1, 0.26905328954342155795e-19);
2939   TEST_ff_f (jn, 10, 0.7, 0.75175911502153953928e-11);
2940   TEST_ff_f (jn, 10, 1.0, 0.26306151236874532070e-9);
2941   TEST_ff_f (jn, 10, 2.0, 0.25153862827167367096e-6);
2942   TEST_ff_f (jn, 10, 10.0, 0.20748610663335885770);
2943
2944   END (jn);
2945 }
2946
2947
2948 static void
2949 ldexp_test (void)
2950 {
2951   TEST_ff_f (ldexp, 0, 0, 0);
2952   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
2953
2954   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
2955   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
2956   TEST_ff_f (ldexp, nan_value, 1, nan_value);
2957
2958   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
2959   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
2960
2961   /* ldexp (x, 0) == x.  */
2962   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
2963 }
2964
2965 static void
2966 lgamma_test (void)
2967 {
2968   errno = 0;
2969   FUNC(lgamma) (0);
2970   if (errno == ENOSYS)
2971     /* Function not implemented.  */
2972     return;
2973   feclearexcept (FE_ALL_EXCEPT);
2974
2975   START (lgamma);
2976
2977   TEST_f_f (lgamma, plus_infty, plus_infty);
2978   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2979   TEST_f_f (lgamma, nan_value, nan_value);
2980
2981   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
2982   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2983   TEST_f_f (lgamma, minus_infty, plus_infty);
2984
2985   TEST_f_f1 (lgamma, 1, 0, 1);
2986
2987   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
2988
2989   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
2990   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2991   TEST_f_f1 (lgamma, 0.7, 0.26086724653166651439L, 1);
2992   TEST_f_f1 (lgamma, 1.2, -0.853740900033158497197e-1L, 1);
2993
2994   END (lgamma);
2995 }
2996
2997 static void
2998 lrint_test (void)
2999 {
3000   /* XXX this test is incomplete.  We need to have a way to specifiy
3001      the rounding method and test the critical cases.  So far, only
3002      unproblematic numbers are tested.  */
3003
3004   START (lrint);
3005
3006   TEST_f_l (lrint, 0.0, 0);
3007   TEST_f_l (lrint, minus_zero, 0);
3008   TEST_f_l (lrint, 0.2, 0);
3009   TEST_f_l (lrint, -0.2, 0);
3010
3011   TEST_f_l (lrint, 1.4, 1);
3012   TEST_f_l (lrint, -1.4, -1);
3013
3014   TEST_f_l (lrint, 8388600.3, 8388600);
3015   TEST_f_l (lrint, -8388600.3, -8388600);
3016
3017   END (lrint);
3018 }
3019
3020 static void
3021 llrint_test (void)
3022 {
3023   /* XXX this test is incomplete.  We need to have a way to specifiy
3024      the rounding method and test the critical cases.  So far, only
3025      unproblematic numbers are tested.  */
3026
3027   START (llrint);
3028
3029   TEST_f_L (llrint, 0.0, 0);
3030   TEST_f_L (llrint, minus_zero, 0);
3031   TEST_f_L (llrint, 0.2, 0);
3032   TEST_f_L (llrint, -0.2, 0);
3033
3034   TEST_f_L (llrint, 1.4, 1);
3035   TEST_f_L (llrint, -1.4, -1);
3036
3037   TEST_f_L (llrint, 8388600.3, 8388600);
3038   TEST_f_L (llrint, -8388600.3, -8388600);
3039
3040   /* Test boundary conditions.  */
3041   /* 0x1FFFFF */
3042   TEST_f_L (llrint, 2097151.0,2097151LL);
3043   /* 0x800000 */
3044   TEST_f_L (llrint, 8388608.0, 8388608LL);
3045   /* 0x1000000 */
3046   TEST_f_L (llrint, 16777216.0, 16777216LL);
3047   /* 0x20000000000 */
3048   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3049   /* 0x40000000000 */
3050   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3051   /* 0x10000000000000 */
3052   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3053   /* 0x10000080000000 */
3054   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3055   /* 0x20000000000000 */
3056   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3057   /* 0x80000000000000 */
3058   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3059   /* 0x100000000000000 */
3060   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3061
3062   END (llrint);
3063 }
3064
3065 static void
3066 log_test (void)
3067 {
3068   errno = 0;
3069   FUNC(log) (1);
3070   if (errno == ENOSYS)
3071     /* Function not implemented.  */
3072     return;
3073   START (log);
3074
3075   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3076   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3077
3078   TEST_f_f (log, 1, 0);
3079
3080   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3081   TEST_f_f (log, plus_infty, plus_infty);
3082
3083   TEST_f_f (log, M_El, 1);
3084   TEST_f_f (log, 1.0 / M_El, -1);
3085   TEST_f_f (log, 2, M_LN2l);
3086   TEST_f_f (log, 10, M_LN10l);
3087   TEST_f_f (log, 0.7, -0.35667494393873237891L);
3088
3089   END (log);
3090 }
3091
3092
3093 static void
3094 log10_test (void)
3095 {
3096   errno = 0;
3097   FUNC(log10) (1);
3098   if (errno == ENOSYS)
3099     /* Function not implemented.  */
3100     return;
3101
3102   START (log10);
3103
3104   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3105   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3106
3107   TEST_f_f (log10, 1, 0);
3108
3109   /* log10 (x) == NaN plus invalid exception if x < 0.  */
3110   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3111
3112   TEST_f_f (log10, plus_infty, plus_infty);
3113   TEST_f_f (log10, nan_value, nan_value);
3114
3115   TEST_f_f (log10, 0.1L, -1);
3116   TEST_f_f (log10, 10.0, 1);
3117   TEST_f_f (log10, 100.0, 2);
3118   TEST_f_f (log10, 10000.0, 4);
3119   TEST_f_f (log10, M_El, M_LOG10El);
3120   TEST_f_f (log10, 0.7, -0.15490195998574316929L);
3121
3122   END (log10);
3123 }
3124
3125
3126 static void
3127 log1p_test (void)
3128 {
3129   errno = 0;
3130   FUNC(log1p) (0);
3131   if (errno == ENOSYS)
3132     /* Function not implemented.  */
3133     return;
3134
3135   START (log1p);
3136
3137   TEST_f_f (log1p, 0, 0);
3138   TEST_f_f (log1p, minus_zero, minus_zero);
3139
3140   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3141   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3142
3143   TEST_f_f (log1p, plus_infty, plus_infty);
3144   TEST_f_f (log1p, nan_value, nan_value);
3145
3146   TEST_f_f (log1p, M_El - 1.0, 1);
3147
3148   TEST_f_f (log1p, -0.3, -0.35667494393873237891L);
3149
3150   END (log1p);
3151 }
3152
3153
3154 static void
3155 log2_test (void)
3156 {
3157   errno = 0;
3158   FUNC(log2) (1);
3159   if (errno == ENOSYS)
3160     /* Function not implemented.  */
3161     return;
3162
3163   START (log2);
3164
3165   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3166   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3167
3168   TEST_f_f (log2, 1, 0);
3169
3170   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3171
3172   TEST_f_f (log2, plus_infty, plus_infty);
3173   TEST_f_f (log2, nan_value, nan_value);
3174
3175   TEST_f_f (log2, M_El, M_LOG2El);
3176   TEST_f_f (log2, 2.0, 1);
3177   TEST_f_f (log2, 16.0, 4);
3178   TEST_f_f (log2, 256.0, 8);
3179   TEST_f_f (log2, 0.7, -0.51457317282975824043L);
3180
3181   END (log2);
3182 }
3183
3184
3185 static void
3186 logb_test (void)
3187 {
3188   START (logb);
3189
3190   TEST_f_f (logb, plus_infty, plus_infty);
3191   TEST_f_f (logb, minus_infty, plus_infty);
3192
3193   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3194
3195   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3196   TEST_f_f (logb, nan_value, nan_value);
3197
3198   TEST_f_f (logb, 1, 0);
3199   TEST_f_f (logb, M_El, 1);
3200   TEST_f_f (logb, 1024, 10);
3201   TEST_f_f (logb, -2000, 10);
3202
3203   END (logb);
3204 }
3205
3206 static void
3207 lround_test (void)
3208 {
3209   START (lround);
3210
3211   TEST_f_l (lround, 0, 0);
3212   TEST_f_l (lround, minus_zero, 0);
3213   TEST_f_l (lround, 0.2, 0.0);
3214   TEST_f_l (lround, -0.2, 0);
3215   TEST_f_l (lround, 0.5, 1);
3216   TEST_f_l (lround, -0.5, -1);
3217   TEST_f_l (lround, 0.8, 1);
3218   TEST_f_l (lround, -0.8, -1);
3219   TEST_f_l (lround, 1.5, 2);
3220   TEST_f_l (lround, -1.5, -2);
3221   TEST_f_l (lround, 22514.5, 22515);
3222   TEST_f_l (lround, -22514.5, -22515);
3223 #ifndef TEST_FLOAT
3224   TEST_f_l (lround, 2097152.5, 2097153);
3225   TEST_f_l (lround, -2097152.5, -2097153);
3226 #endif
3227   END (lround);
3228 }
3229
3230
3231 static void
3232 llround_test (void)
3233 {
3234   START (llround);
3235
3236   TEST_f_L (llround, 0, 0);
3237   TEST_f_L (llround, minus_zero, 0);
3238   TEST_f_L (llround, 0.2, 0.0);
3239   TEST_f_L (llround, -0.2, 0);
3240   TEST_f_L (llround, 0.5, 1);
3241   TEST_f_L (llround, -0.5, -1);
3242   TEST_f_L (llround, 0.8, 1);
3243   TEST_f_L (llround, -0.8, -1);
3244   TEST_f_L (llround, 1.5, 2);
3245   TEST_f_L (llround, -1.5, -2);
3246   TEST_f_L (llround, 22514.5, 22515);
3247   TEST_f_L (llround, -22514.5, -22515);
3248 #ifndef TEST_FLOAT
3249   TEST_f_L (llround, 2097152.5, 2097153);
3250   TEST_f_L (llround, -2097152.5, -2097153);
3251   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3252   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3253 #endif
3254
3255   /* Test boundary conditions.  */
3256   /* 0x1FFFFF */
3257   TEST_f_L (llround, 2097151.0, 2097151LL);
3258   /* 0x800000 */
3259   TEST_f_L (llround, 8388608.0, 8388608LL);
3260   /* 0x1000000 */
3261   TEST_f_L (llround, 16777216.0, 16777216LL);
3262   /* 0x20000000000 */
3263   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3264   /* 0x40000000000 */
3265   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3266   /* 0x10000000000000 */
3267   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3268   /* 0x10000080000000 */
3269   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3270   /* 0x20000000000000 */
3271   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3272   /* 0x80000000000000 */
3273   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3274   /* 0x100000000000000 */
3275   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3276
3277   END (llround);
3278 }
3279
3280 static void
3281 modf_test (void)
3282 {
3283   FLOAT x;
3284
3285   START (modf);
3286
3287   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3288   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3289   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3290   TEST_fF_f1 (modf, 0, 0, 0);
3291   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3292   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3293   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3294   TEST_fF_f1 (modf, 20, 0, 20);
3295   TEST_fF_f1 (modf, 21, 0, 21);
3296   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3297
3298   END (modf);
3299 }
3300
3301
3302 static void
3303 nearbyint_test (void)
3304 {
3305   START (nearbyint);
3306
3307   TEST_f_f (nearbyint, 0.0, 0.0);
3308   TEST_f_f (nearbyint, minus_zero, minus_zero);
3309   TEST_f_f (nearbyint, plus_infty, plus_infty);
3310   TEST_f_f (nearbyint, minus_infty, minus_infty);
3311   TEST_f_f (nearbyint, nan_value, nan_value);
3312
3313   /* Default rounding mode is round to nearest.  */
3314   TEST_f_f (nearbyint, 0.5, 0.0);
3315   TEST_f_f (nearbyint, 1.5, 2.0);
3316   TEST_f_f (nearbyint, -0.5, minus_zero);
3317   TEST_f_f (nearbyint, -1.5, -2.0);
3318
3319   END (nearbyint);
3320 }
3321
3322 static void
3323 nextafter_test (void)
3324 {
3325
3326   START (nextafter);
3327
3328   TEST_ff_f (nextafter, 0, 0, 0);
3329   TEST_ff_f (nextafter, minus_zero, 0, 0);
3330   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3331   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3332
3333   TEST_ff_f (nextafter, 9, 9, 9);
3334   TEST_ff_f (nextafter, -9, -9, -9);
3335   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3336   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3337
3338   TEST_ff_f (nextafter, nan_value, 1.1, nan_value);
3339   TEST_ff_f (nextafter, 1.1, nan_value, nan_value);
3340   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3341
3342   /* XXX We need the hexadecimal FP number representation here for further
3343      tests.  */
3344
3345   END (nextafter);
3346 }
3347
3348
3349 static void
3350 nexttoward_test (void)
3351 {
3352   START (nexttoward);
3353   TEST_ff_f (nexttoward, 0, 0, 0);
3354   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3355   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3356   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3357
3358   TEST_ff_f (nexttoward, 9, 9, 9);
3359   TEST_ff_f (nexttoward, -9, -9, -9);
3360   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3361   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3362
3363   TEST_ff_f (nexttoward, nan_value, 1.1, nan_value);
3364   TEST_ff_f (nexttoward, 1.1, nan_value, nan_value);
3365   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3366
3367   /* XXX We need the hexadecimal FP number representation here for further
3368      tests.  */
3369
3370   END (nexttoward);
3371 }
3372
3373
3374 static void
3375 pow_test (void)
3376 {
3377
3378   errno = 0;
3379   FUNC(pow) (0, 0);
3380   if (errno == ENOSYS)
3381     /* Function not implemented.  */
3382     return;
3383
3384   START (pow);
3385
3386   TEST_ff_f (pow, 0, 0, 1);
3387   TEST_ff_f (pow, 0, minus_zero, 1);
3388   TEST_ff_f (pow, minus_zero, 0, 1);
3389   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3390
3391   TEST_ff_f (pow, 10, 0, 1);
3392   TEST_ff_f (pow, 10, minus_zero, 1);
3393   TEST_ff_f (pow, -10, 0, 1);
3394   TEST_ff_f (pow, -10, minus_zero, 1);
3395
3396   TEST_ff_f (pow, nan_value, 0, 1);
3397   TEST_ff_f (pow, nan_value, minus_zero, 1);
3398
3399
3400 #ifndef TEST_INLINE
3401   TEST_ff_f (pow, 1.1, plus_infty, plus_infty);
3402   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3403   TEST_ff_f (pow, -1.1, plus_infty, plus_infty);
3404   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3405
3406   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3407   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3408   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3409   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3410
3411   TEST_ff_f (pow, 1.1, minus_infty, 0);
3412   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3413   TEST_ff_f (pow, -1.1, minus_infty, 0);
3414   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3415
3416   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3417   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3418   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3419   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3420
3421   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3422   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3423   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3424
3425   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3426   TEST_ff_f (pow, plus_infty, -1, 0);
3427   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3428
3429   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3430   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3431   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3432
3433   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3434   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3435   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3436   TEST_ff_f (pow, minus_infty, 0.1, plus_infty);
3437   TEST_ff_f (pow, minus_infty, 1.1, plus_infty);
3438   TEST_ff_f (pow, minus_infty, 11.1, plus_infty);
3439   TEST_ff_f (pow, minus_infty, 1001.1, plus_infty);
3440
3441   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3442   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3443   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3444
3445   TEST_ff_f (pow, minus_infty, -2, 0);
3446   TEST_ff_f (pow, minus_infty, -12, 0);
3447   TEST_ff_f (pow, minus_infty, -1002, 0);
3448   TEST_ff_f (pow, minus_infty, -0.1, 0);
3449   TEST_ff_f (pow, minus_infty, -1.1, 0);
3450   TEST_ff_f (pow, minus_infty, -11.1, 0);
3451   TEST_ff_f (pow, minus_infty, -1001.1, 0);
3452 #endif
3453
3454   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3455   TEST_ff_f (pow, 0, nan_value, nan_value);
3456   TEST_ff_f (pow, 1, nan_value, nan_value);
3457   TEST_ff_f (pow, -1, nan_value, nan_value);
3458   TEST_ff_f (pow, nan_value, 1, nan_value);
3459   TEST_ff_f (pow, nan_value, -1, nan_value);
3460
3461   /* pow (x, NaN) == NaN.  */
3462   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3463
3464   TEST_ff_f (pow, 1, plus_infty, nan_value, INVALID_EXCEPTION);
3465   TEST_ff_f (pow, -1, plus_infty, nan_value, INVALID_EXCEPTION);
3466   TEST_ff_f (pow, 1, minus_infty, nan_value, INVALID_EXCEPTION);
3467   TEST_ff_f (pow, -1, minus_infty, nan_value, INVALID_EXCEPTION);
3468
3469   TEST_ff_f (pow, -0.1, 1.1, nan_value, INVALID_EXCEPTION);
3470   TEST_ff_f (pow, -0.1, -1.1, nan_value, INVALID_EXCEPTION);
3471   TEST_ff_f (pow, -10.1, 1.1, nan_value, INVALID_EXCEPTION);
3472   TEST_ff_f (pow, -10.1, -1.1, nan_value, INVALID_EXCEPTION);
3473
3474   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3475   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3476   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3477   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3478
3479   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3480   TEST_ff_f (pow, 0, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3481   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3482   TEST_ff_f (pow, minus_zero, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3483
3484
3485   TEST_ff_f (pow, 0, 1, 0);
3486   TEST_ff_f (pow, 0, 11, 0);
3487
3488   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3489   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3490
3491
3492   TEST_ff_f (pow, 0, 2, 0);
3493   TEST_ff_f (pow, 0, 11.1, 0);
3494
3495
3496   TEST_ff_f (pow, minus_zero, 2, 0);
3497   TEST_ff_f (pow, minus_zero, 11.1, 0);
3498
3499 #ifndef TEST_INLINE
3500   /* pow (x, +inf) == +inf for |x| > 1.  */
3501   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3502
3503   /* pow (x, +inf) == +0 for |x| < 1.  */
3504   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3505
3506   /* pow (x, -inf) == +0 for |x| > 1.  */
3507   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3508
3509   /* pow (x, -inf) == +inf for |x| < 1.  */
3510   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3511 #endif
3512
3513   /* pow (+inf, y) == +inf for y > 0.  */
3514   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3515
3516   /* pow (+inf, y) == +0 for y < 0.  */
3517   TEST_ff_f (pow, plus_infty, -1, 0.0);
3518
3519   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3520   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3521
3522   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3523   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3524
3525   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3526   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3527   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3528   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3529
3530   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3531   TEST_ff_f (pow, 0.0, 27, 0.0);
3532
3533   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3534   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3535
3536   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3537   TEST_ff_f (pow, 0.0, 4, 0.0);
3538
3539   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3540   TEST_ff_f (pow, minus_zero, 4, 0.0);
3541
3542   TEST_ff_f (pow, 0.7, 1.2, 0.65180494056638638188L);
3543
3544 #ifdef TEST_DOUBLE
3545   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3546 #endif
3547
3548   END (pow);
3549 }
3550
3551 static void
3552 remainder_test (void)
3553 {
3554   errno = 0;
3555   FUNC(remainder) (1.625, 1.0);
3556   if (errno == ENOSYS)
3557     /* Function not implemented.  */
3558     return;
3559
3560   START (remainder);
3561
3562   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3563   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3564   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3565   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3566   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3567
3568   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3569   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3570   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3571   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3572   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3573   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3574
3575   END (remainder);
3576 }
3577
3578 static void
3579 remquo_test (void)
3580 {
3581   /* x is needed.  */
3582   int x;
3583
3584   errno = 0;
3585   FUNC(remquo) (1.625, 1.0, &x);
3586   if (errno == ENOSYS)
3587     /* Function not implemented.  */
3588     return;
3589
3590   START (remquo);
3591
3592   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3593   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3594   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3595   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3596   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3597
3598   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3599   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3600   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3601   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3602
3603   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3604   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3605
3606   END (remquo);
3607 }
3608
3609 static void
3610 rint_test (void)
3611 {
3612   START (rint);
3613
3614   TEST_f_f (rint, 0.0, 0.0);
3615   TEST_f_f (rint, minus_zero, minus_zero);
3616   TEST_f_f (rint, plus_infty, plus_infty);
3617   TEST_f_f (rint, minus_infty, minus_infty);
3618
3619   /* Default rounding mode is round to nearest.  */
3620   TEST_f_f (rint, 0.5, 0.0);
3621   TEST_f_f (rint, 1.5, 2.0);
3622   TEST_f_f (rint, -0.5, -0.0);
3623   TEST_f_f (rint, -1.5, -2.0);
3624
3625   END (rint);
3626 }
3627
3628 static void
3629 round_test (void)
3630 {
3631   START (round);
3632
3633   TEST_f_f (round, 0, 0);
3634   TEST_f_f (round, minus_zero, minus_zero);
3635   TEST_f_f (round, 0.2, 0.0);
3636   TEST_f_f (round, -0.2, minus_zero);
3637   TEST_f_f (round, 0.5, 1.0);
3638   TEST_f_f (round, -0.5, -1.0);
3639   TEST_f_f (round, 0.8, 1.0);
3640   TEST_f_f (round, -0.8, -1.0);
3641   TEST_f_f (round, 1.5, 2.0);
3642   TEST_f_f (round, -1.5, -2.0);
3643   TEST_f_f (round, 2097152.5, 2097153);
3644   TEST_f_f (round, -2097152.5, -2097153);
3645
3646   END (round);
3647 }
3648
3649
3650 static void
3651 scalb_test (void)
3652 {
3653
3654   START (scalb);
3655
3656   TEST_ff_f (scalb, 2.0, 0.5, nan_value);
3657   TEST_ff_f (scalb, 3.0, -2.5, nan_value);
3658
3659   TEST_ff_f (scalb, 0, nan_value, nan_value);
3660   TEST_ff_f (scalb, 1, nan_value, nan_value);
3661
3662   TEST_ff_f (scalb, 1, 0, 1);
3663   TEST_ff_f (scalb, -1, 0, -1);
3664
3665   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3666   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3667
3668   TEST_ff_f (scalb, 0, 2, 0);
3669   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3670   TEST_ff_f (scalb, 0, 0, 0);
3671   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3672   TEST_ff_f (scalb, 0, -1, 0);
3673   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3674   TEST_ff_f (scalb, 0, minus_infty, 0);
3675   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3676
3677   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3678   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3679   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3680   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3681   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3682   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3683
3684   TEST_ff_f (scalb, 0.1, minus_infty, 0.0);
3685   TEST_ff_f (scalb, -0.1, minus_infty, minus_zero);
3686
3687   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3688   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3689   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3690   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3691
3692   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value);
3693   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value);
3694
3695   TEST_ff_f (scalb, nan_value, 1, nan_value);
3696   TEST_ff_f (scalb, 1, nan_value, nan_value);
3697   TEST_ff_f (scalb, nan_value, 0, nan_value);
3698   TEST_ff_f (scalb, 0, nan_value, nan_value);
3699   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3700   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3701   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3702
3703   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3704   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3705
3706   END (scalb);
3707 }
3708
3709
3710 static void
3711 scalbn_test (void)
3712 {
3713
3714   START (scalbn);
3715
3716   TEST_fi_f (scalbn, 0, 0, 0);
3717   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3718
3719   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
3720   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
3721   TEST_fi_f (scalbn, nan_value, 1, nan_value);
3722
3723   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
3724   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
3725
3726   TEST_fi_f (scalbn, 1, 0L, 1);
3727
3728   END (scalbn);
3729 }
3730
3731 static void
3732 scalbln_test (void)
3733 {
3734
3735   START (scalbln);
3736
3737   TEST_fl_f (scalbln, 0, 0, 0);
3738   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
3739
3740   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
3741   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
3742   TEST_fl_f (scalbln, nan_value, 1, nan_value);
3743
3744   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
3745   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
3746
3747   TEST_fl_f (scalbln, 1, 0L, 1);
3748
3749   END (scalbn);
3750 }
3751
3752 static void
3753 signbit_test (void)
3754 {
3755
3756   START (signbit);
3757
3758   TEST_f_b (signbit, 0, 0);
3759   TEST_f_b (signbit, minus_zero, 1);
3760   TEST_f_b (signbit, plus_infty, 0);
3761   TEST_f_b (signbit, minus_infty, 1);
3762
3763   /* signbit (x) != 0 for x < 0.  */
3764   TEST_f_b (signbit, -1, 1);
3765   /* signbit (x) == 0 for x >= 0.  */
3766   TEST_f_b (signbit, 1, 0);
3767
3768   END (signbit);
3769 }
3770
3771 static void
3772 sin_test (void)
3773 {
3774   errno = 0;
3775   FUNC(sin) (0);
3776   if (errno == ENOSYS)
3777     /* Function not implemented.  */
3778     return;
3779
3780   START (sin);
3781
3782   TEST_f_f (sin, 0, 0);
3783   TEST_f_f (sin, minus_zero, minus_zero);
3784   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
3785   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
3786   TEST_f_f (sin, nan_value, nan_value);
3787
3788   TEST_f_f (sin, M_PI_6l, 0.5);
3789   TEST_f_f (sin, -M_PI_6l, -0.5);
3790   TEST_f_f (sin, M_PI_2l, 1);
3791   TEST_f_f (sin, -M_PI_2l, -1);
3792   TEST_f_f (sin, 0.7, 0.64421768723769105367L);
3793
3794   END (sin);
3795
3796 }
3797
3798 static void
3799 sincos_test (void)
3800 {
3801   FLOAT sin_res, cos_res;
3802
3803   errno = 0;
3804  &nb