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