(lrint_test): Add new test.
[kopensolaris-gnu/glibc.git] / math / libm-test.inc
1 /* Copyright (C) 1997-2002, 2003, 2004 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   TEST_f_l (lrint, 1071930.0008, 1071930);
3105 #ifndef TEST_FLOAT
3106   TEST_f_l (lrint, 1073741824.01, 1073741824);
3107 # if LONG_MAX > 281474976710656
3108   TEST_f_l (lrint, 281474976710656.025, 281474976710656);
3109 # endif
3110 #endif
3111
3112   END (lrint);
3113 }
3114
3115
3116 static void
3117 llrint_test (void)
3118 {
3119   /* XXX this test is incomplete.  We need to have a way to specifiy
3120      the rounding method and test the critical cases.  So far, only
3121      unproblematic numbers are tested.  */
3122
3123   START (llrint);
3124
3125   TEST_f_L (llrint, 0.0, 0);
3126   TEST_f_L (llrint, minus_zero, 0);
3127   TEST_f_L (llrint, 0.2L, 0);
3128   TEST_f_L (llrint, -0.2L, 0);
3129
3130   TEST_f_L (llrint, 1.4L, 1);
3131   TEST_f_L (llrint, -1.4L, -1);
3132
3133   TEST_f_L (llrint, 8388600.3L, 8388600);
3134   TEST_f_L (llrint, -8388600.3L, -8388600);
3135
3136   TEST_f_l (llrint, 1071930.0008, 1071930);
3137
3138   /* Test boundary conditions.  */
3139   /* 0x1FFFFF */
3140   TEST_f_L (llrint, 2097151.0,2097151LL);
3141   /* 0x800000 */
3142   TEST_f_L (llrint, 8388608.0, 8388608LL);
3143   /* 0x1000000 */
3144   TEST_f_L (llrint, 16777216.0, 16777216LL);
3145   /* 0x20000000000 */
3146   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
3147   /* 0x40000000000 */
3148   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
3149   /* 0x1000000000000 */
3150   TEST_f_L (llrint, 281474976710656.0, 281474976710656LL);
3151   /* 0x10000000000000 */
3152   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
3153   /* 0x10000080000000 */
3154   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3155   /* 0x20000000000000 */
3156   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
3157   /* 0x80000000000000 */
3158   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
3159   /* 0x100000000000000 */
3160   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
3161
3162   END (llrint);
3163 }
3164
3165
3166 static void
3167 log_test (void)
3168 {
3169   errno = 0;
3170   FUNC(log) (1);
3171   if (errno == ENOSYS)
3172     /* Function not implemented.  */
3173     return;
3174   START (log);
3175
3176   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3177   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3178
3179   TEST_f_f (log, 1, 0);
3180
3181   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
3182   TEST_f_f (log, plus_infty, plus_infty);
3183
3184   TEST_f_f (log, M_El, 1);
3185   TEST_f_f (log, 1.0 / M_El, -1);
3186   TEST_f_f (log, 2, M_LN2l);
3187   TEST_f_f (log, 10, M_LN10l);
3188   TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L);
3189
3190   END (log);
3191 }
3192
3193
3194 static void
3195 log10_test (void)
3196 {
3197   errno = 0;
3198   FUNC(log10) (1);
3199   if (errno == ENOSYS)
3200     /* Function not implemented.  */
3201     return;
3202
3203   START (log10);
3204
3205   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3206   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3207
3208   TEST_f_f (log10, 1, 0);
3209
3210   /* log10 (x) == NaN plus invalid exception if x < 0.  */
3211   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
3212
3213   TEST_f_f (log10, plus_infty, plus_infty);
3214   TEST_f_f (log10, nan_value, nan_value);
3215
3216   TEST_f_f (log10, 0.1L, -1);
3217   TEST_f_f (log10, 10.0, 1);
3218   TEST_f_f (log10, 100.0, 2);
3219   TEST_f_f (log10, 10000.0, 4);
3220   TEST_f_f (log10, M_El, M_LOG10El);
3221   TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L);
3222
3223   END (log10);
3224 }
3225
3226
3227 static void
3228 log1p_test (void)
3229 {
3230   errno = 0;
3231   FUNC(log1p) (0);
3232   if (errno == ENOSYS)
3233     /* Function not implemented.  */
3234     return;
3235
3236   START (log1p);
3237
3238   TEST_f_f (log1p, 0, 0);
3239   TEST_f_f (log1p, minus_zero, minus_zero);
3240
3241   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3242   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
3243
3244   TEST_f_f (log1p, plus_infty, plus_infty);
3245   TEST_f_f (log1p, nan_value, nan_value);
3246
3247   TEST_f_f (log1p, M_El - 1.0, 1);
3248
3249   TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L);
3250   TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L);
3251
3252   END (log1p);
3253 }
3254
3255
3256 static void
3257 log2_test (void)
3258 {
3259   errno = 0;
3260   FUNC(log2) (1);
3261   if (errno == ENOSYS)
3262     /* Function not implemented.  */
3263     return;
3264
3265   START (log2);
3266
3267   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3268   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3269
3270   TEST_f_f (log2, 1, 0);
3271
3272   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
3273
3274   TEST_f_f (log2, plus_infty, plus_infty);
3275   TEST_f_f (log2, nan_value, nan_value);
3276
3277   TEST_f_f (log2, M_El, M_LOG2El);
3278   TEST_f_f (log2, 2.0, 1);
3279   TEST_f_f (log2, 16.0, 4);
3280   TEST_f_f (log2, 256.0, 8);
3281   TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L);
3282
3283   END (log2);
3284 }
3285
3286
3287 static void
3288 logb_test (void)
3289 {
3290   START (logb);
3291
3292   TEST_f_f (logb, plus_infty, plus_infty);
3293   TEST_f_f (logb, minus_infty, plus_infty);
3294
3295   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3296
3297   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3298   TEST_f_f (logb, nan_value, nan_value);
3299
3300   TEST_f_f (logb, 1, 0);
3301   TEST_f_f (logb, M_El, 1);
3302   TEST_f_f (logb, 1024, 10);
3303   TEST_f_f (logb, -2000, 10);
3304
3305   END (logb);
3306 }
3307
3308
3309 static void
3310 lround_test (void)
3311 {
3312   START (lround);
3313
3314   TEST_f_l (lround, 0, 0);
3315   TEST_f_l (lround, minus_zero, 0);
3316   TEST_f_l (lround, 0.2L, 0.0);
3317   TEST_f_l (lround, -0.2L, 0);
3318   TEST_f_l (lround, 0.5, 1);
3319   TEST_f_l (lround, -0.5, -1);
3320   TEST_f_l (lround, 0.8L, 1);
3321   TEST_f_l (lround, -0.8L, -1);
3322   TEST_f_l (lround, 1.5, 2);
3323   TEST_f_l (lround, -1.5, -2);
3324   TEST_f_l (lround, 22514.5, 22515);
3325   TEST_f_l (lround, -22514.5, -22515);
3326   TEST_f_l (lround, 1071930.0008, 1071930);
3327 #ifndef TEST_FLOAT
3328   TEST_f_l (lround, 1073741824.01, 1073741824);
3329 # if LONG_MAX > 281474976710656
3330   TEST_f_l (lround, 281474976710656.025, 281474976710656);
3331 # endif
3332   TEST_f_l (lround, 2097152.5, 2097153);
3333   TEST_f_l (lround, -2097152.5, -2097153);
3334 #endif
3335   END (lround);
3336 }
3337
3338
3339 static void
3340 llround_test (void)
3341 {
3342   START (llround);
3343
3344   TEST_f_L (llround, 0, 0);
3345   TEST_f_L (llround, minus_zero, 0);
3346   TEST_f_L (llround, 0.2L, 0.0);
3347   TEST_f_L (llround, -0.2L, 0);
3348   TEST_f_L (llround, 0.5, 1);
3349   TEST_f_L (llround, -0.5, -1);
3350   TEST_f_L (llround, 0.8L, 1);
3351   TEST_f_L (llround, -0.8L, -1);
3352   TEST_f_L (llround, 1.5, 2);
3353   TEST_f_L (llround, -1.5, -2);
3354   TEST_f_L (llround, 22514.5, 22515);
3355   TEST_f_L (llround, -22514.5, -22515);
3356   TEST_f_l (llround, 1071930.0008, 1071930);
3357 #ifndef TEST_FLOAT
3358   TEST_f_L (llround, 2097152.5, 2097153);
3359   TEST_f_L (llround, -2097152.5, -2097153);
3360   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3361   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3362 #endif
3363
3364   /* Test boundary conditions.  */
3365   /* 0x1FFFFF */
3366   TEST_f_L (llround, 2097151.0, 2097151LL);
3367   /* 0x800000 */
3368   TEST_f_L (llround, 8388608.0, 8388608LL);
3369   /* 0x1000000 */
3370   TEST_f_L (llround, 16777216.0, 16777216LL);
3371   /* 0x20000000000 */
3372   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3373   /* 0x40000000000 */
3374   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3375   /* 0x1000000000000 */
3376   TEST_f_L (llround, 281474976710656.0, 281474976710656LL);
3377   /* 0x10000000000000 */
3378   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3379   /* 0x10000080000000 */
3380   TEST_f_L (llround, 4503601774854144.0, 4503601774854144LL);
3381   /* 0x20000000000000 */
3382   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3383   /* 0x80000000000000 */
3384   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3385   /* 0x100000000000000 */
3386   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3387
3388 #ifndef TEST_FLOAT
3389   /* 0x100000000 */
3390   TEST_f_L (llround, 4294967295.5, 4294967296LL);
3391   /* 0x200000000 */
3392   TEST_f_L (llround, 8589934591.5, 8589934592LL);
3393 #endif
3394
3395   END (llround);
3396 }
3397
3398 static void
3399 modf_test (void)
3400 {
3401   FLOAT x;
3402
3403   START (modf);
3404
3405   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3406   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3407   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3408   TEST_fF_f1 (modf, 0, 0, 0);
3409   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3410   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3411   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3412   TEST_fF_f1 (modf, 20, 0, 20);
3413   TEST_fF_f1 (modf, 21, 0, 21);
3414   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3415
3416   END (modf);
3417 }
3418
3419
3420 static void
3421 nearbyint_test (void)
3422 {
3423   START (nearbyint);
3424
3425   TEST_f_f (nearbyint, 0.0, 0.0);
3426   TEST_f_f (nearbyint, minus_zero, minus_zero);
3427   TEST_f_f (nearbyint, plus_infty, plus_infty);
3428   TEST_f_f (nearbyint, minus_infty, minus_infty);
3429   TEST_f_f (nearbyint, nan_value, nan_value);
3430
3431   /* Default rounding mode is round to nearest.  */
3432   TEST_f_f (nearbyint, 0.5, 0.0);
3433   TEST_f_f (nearbyint, 1.5, 2.0);
3434   TEST_f_f (nearbyint, -0.5, minus_zero);
3435   TEST_f_f (nearbyint, -1.5, -2.0);
3436
3437   END (nearbyint);
3438 }
3439
3440 static void
3441 nextafter_test (void)
3442 {
3443
3444   START (nextafter);
3445
3446   TEST_ff_f (nextafter, 0, 0, 0);
3447   TEST_ff_f (nextafter, minus_zero, 0, 0);
3448   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3449   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3450
3451   TEST_ff_f (nextafter, 9, 9, 9);
3452   TEST_ff_f (nextafter, -9, -9, -9);
3453   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3454   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3455
3456   TEST_ff_f (nextafter, nan_value, 1.1L, nan_value);
3457   TEST_ff_f (nextafter, 1.1L, nan_value, nan_value);
3458   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3459
3460   FLOAT fltmax = CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX,
3461                          LDBL_MAX, DBL_MAX, FLT_MAX);
3462   TEST_ff_f (nextafter, fltmax, plus_infty, plus_infty);
3463   TEST_ff_f (nextafter, -fltmax, minus_infty, minus_infty);
3464
3465 #ifdef TEST_LDOUBLE
3466   // XXX Enable once gcc is fixed.
3467   //TEST_ff_f (nextafter, 0x0.00000040000000000000p-16385L, -0.1L, 0x0.0000003ffffffff00000p-16385L);
3468 #endif
3469
3470   /* XXX We need the hexadecimal FP number representation here for further
3471      tests.  */
3472
3473   END (nextafter);
3474 }
3475
3476
3477 static void
3478 nexttoward_test (void)
3479 {
3480   START (nexttoward);
3481   TEST_ff_f (nexttoward, 0, 0, 0);
3482   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3483   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3484   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3485
3486   TEST_ff_f (nexttoward, 9, 9, 9);
3487   TEST_ff_f (nexttoward, -9, -9, -9);
3488   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3489   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3490
3491   TEST_ff_f (nexttoward, nan_value, 1.1L, nan_value);
3492   TEST_ff_f (nexttoward, 1.1L, nan_value, nan_value);
3493   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3494
3495   /* XXX We need the hexadecimal FP number representation here for further
3496      tests.  */
3497
3498   END (nexttoward);
3499 }
3500
3501
3502 static void
3503 pow_test (void)
3504 {
3505
3506   errno = 0;
3507   FUNC(pow) (0, 0);
3508   if (errno == ENOSYS)
3509     /* Function not implemented.  */
3510     return;
3511
3512   START (pow);
3513
3514   TEST_ff_f (pow, 0, 0, 1);
3515   TEST_ff_f (pow, 0, minus_zero, 1);
3516   TEST_ff_f (pow, minus_zero, 0, 1);
3517   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3518
3519   TEST_ff_f (pow, 10, 0, 1);
3520   TEST_ff_f (pow, 10, minus_zero, 1);
3521   TEST_ff_f (pow, -10, 0, 1);
3522   TEST_ff_f (pow, -10, minus_zero, 1);
3523
3524   TEST_ff_f (pow, nan_value, 0, 1);
3525   TEST_ff_f (pow, nan_value, minus_zero, 1);
3526
3527
3528 #ifndef TEST_INLINE
3529   TEST_ff_f (pow, 1.1L, plus_infty, plus_infty);
3530   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3531   TEST_ff_f (pow, -1.1L, plus_infty, plus_infty);
3532   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3533
3534   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3535   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3536   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3537   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3538
3539   TEST_ff_f (pow, 1.1L, minus_infty, 0);
3540   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3541   TEST_ff_f (pow, -1.1L, minus_infty, 0);
3542   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3543
3544   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3545   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3546   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3547   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3548
3549   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3550   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3551   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3552
3553   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3554   TEST_ff_f (pow, plus_infty, -1, 0);
3555   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3556
3557   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3558   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3559   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3560
3561   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3562   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3563   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3564   TEST_ff_f (pow, minus_infty, 0.1L, plus_infty);
3565   TEST_ff_f (pow, minus_infty, 1.1L, plus_infty);
3566   TEST_ff_f (pow, minus_infty, 11.1L, plus_infty);
3567   TEST_ff_f (pow, minus_infty, 1001.1L, plus_infty);
3568
3569   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3570   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3571   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3572
3573   TEST_ff_f (pow, minus_infty, -2, 0);
3574   TEST_ff_f (pow, minus_infty, -12, 0);
3575   TEST_ff_f (pow, minus_infty, -1002, 0);
3576   TEST_ff_f (pow, minus_infty, -0.1L, 0);
3577   TEST_ff_f (pow, minus_infty, -1.1L, 0);
3578   TEST_ff_f (pow, minus_infty, -11.1L, 0);
3579   TEST_ff_f (pow, minus_infty, -1001.1L, 0);
3580 #endif
3581
3582   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3583   TEST_ff_f (pow, 0, nan_value, nan_value);
3584   TEST_ff_f (pow, 1, nan_value, 1);
3585   TEST_ff_f (pow, -1, nan_value, nan_value);
3586   TEST_ff_f (pow, nan_value, 1, nan_value);
3587   TEST_ff_f (pow, nan_value, -1, nan_value);
3588
3589   /* pow (x, NaN) == NaN.  */
3590   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3591
3592   TEST_ff_f (pow, 1, plus_infty, 1);
3593   TEST_ff_f (pow, -1, plus_infty, 1);
3594   TEST_ff_f (pow, 1, minus_infty, 1);
3595   TEST_ff_f (pow, -1, minus_infty, 1);
3596
3597   TEST_ff_f (pow, -0.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3598   TEST_ff_f (pow, -0.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3599   TEST_ff_f (pow, -10.1L, 1.1L, nan_value, INVALID_EXCEPTION);
3600   TEST_ff_f (pow, -10.1L, -1.1L, nan_value, INVALID_EXCEPTION);
3601
3602   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3603   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3604   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3605   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3606
3607   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3608   TEST_ff_f (pow, 0, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3609   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3610   TEST_ff_f (pow, minus_zero, -11.1L, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3611
3612
3613   TEST_ff_f (pow, 0, 1, 0);
3614   TEST_ff_f (pow, 0, 11, 0);
3615
3616   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3617   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3618
3619
3620   TEST_ff_f (pow, 0, 2, 0);
3621   TEST_ff_f (pow, 0, 11.1L, 0);
3622
3623
3624   TEST_ff_f (pow, minus_zero, 2, 0);
3625   TEST_ff_f (pow, minus_zero, 11.1L, 0);
3626
3627 #ifndef TEST_INLINE
3628   /* pow (x, +inf) == +inf for |x| > 1.  */
3629   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3630
3631   /* pow (x, +inf) == +0 for |x| < 1.  */
3632   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3633
3634   /* pow (x, -inf) == +0 for |x| > 1.  */
3635   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3636
3637   /* pow (x, -inf) == +inf for |x| < 1.  */
3638   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3639 #endif
3640
3641   /* pow (+inf, y) == +inf for y > 0.  */
3642   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3643
3644   /* pow (+inf, y) == +0 for y < 0.  */
3645   TEST_ff_f (pow, plus_infty, -1, 0.0);
3646
3647   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3648   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3649
3650   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3651   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3652
3653   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3654   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3655   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3656   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3657
3658   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3659   TEST_ff_f (pow, 0.0, 27, 0.0);
3660
3661   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3662   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3663
3664   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3665   TEST_ff_f (pow, 0.0, 4, 0.0);
3666
3667   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3668   TEST_ff_f (pow, minus_zero, 4, 0.0);
3669
3670   TEST_ff_f (pow, 0.75L, 1.25L, 0.697953644326574699205914060237425566L);
3671
3672 #if defined TEST_DOUBLE || defined TEST_LDOUBLE
3673   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3674 #endif
3675
3676   END (pow);
3677 }
3678
3679 static void
3680 remainder_test (void)
3681 {
3682   errno = 0;
3683   FUNC(remainder) (1.625, 1.0);
3684   if (errno == ENOSYS)
3685     /* Function not implemented.  */
3686     return;
3687
3688   START (remainder);
3689
3690   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3691   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3692   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3693   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3694   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3695
3696   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3697   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3698   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3699   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3700   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3701   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3702
3703   END (remainder);
3704 }
3705
3706 static void
3707 remquo_test (void)
3708 {
3709   /* x is needed.  */
3710   int x;
3711
3712   errno = 0;
3713   FUNC(remquo) (1.625, 1.0, &x);
3714   if (errno == ENOSYS)
3715     /* Function not implemented.  */
3716     return;
3717
3718   START (remquo);
3719
3720   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3721   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3722   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3723   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3724   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3725
3726   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3727   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3728   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3729   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3730
3731   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3732   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3733
3734   END (remquo);
3735 }
3736
3737 static void
3738 rint_test (void)
3739 {
3740   START (rint);
3741
3742   TEST_f_f (rint, 0.0, 0.0);
3743   TEST_f_f (rint, minus_zero, minus_zero);
3744   TEST_f_f (rint, plus_infty, plus_infty);
3745   TEST_f_f (rint, minus_infty, minus_infty);
3746
3747   /* Default rounding mode is round to even.  */
3748   TEST_f_f (rint, 0.5, 0.0);
3749   TEST_f_f (rint, 1.5, 2.0);
3750   TEST_f_f (rint, 2.5, 2.0);
3751   TEST_f_f (rint, 3.5, 4.0);
3752   TEST_f_f (rint, 4.5, 4.0);
3753   TEST_f_f (rint, -0.5, -0.0);
3754   TEST_f_f (rint, -1.5, -2.0);
3755   TEST_f_f (rint, -2.5, -2.0);
3756   TEST_f_f (rint, -3.5, -4.0);
3757   TEST_f_f (rint, -4.5, -4.0);
3758
3759   END (rint);
3760 }
3761
3762 static void
3763 round_test (void)
3764 {
3765   START (round);
3766
3767   TEST_f_f (round, 0, 0);
3768   TEST_f_f (round, minus_zero, minus_zero);
3769   TEST_f_f (round, 0.2L, 0.0);
3770   TEST_f_f (round, -0.2L, minus_zero);
3771   TEST_f_f (round, 0.5, 1.0);
3772   TEST_f_f (round, -0.5, -1.0);
3773   TEST_f_f (round, 0.8L, 1.0);
3774   TEST_f_f (round, -0.8L, -1.0);
3775   TEST_f_f (round, 1.5, 2.0);
3776   TEST_f_f (round, -1.5, -2.0);
3777   TEST_f_f (round, 2097152.5, 2097153);
3778   TEST_f_f (round, -2097152.5, -2097153);
3779
3780   END (round);
3781 }
3782
3783
3784 static void
3785 scalb_test (void)
3786 {
3787
3788   START (scalb);
3789
3790   TEST_ff_f (scalb, 2.0, 0.5, nan_value, INVALID_EXCEPTION);
3791   TEST_ff_f (scalb, 3.0, -2.5, nan_value, INVALID_EXCEPTION);
3792
3793   TEST_ff_f (scalb, 0, nan_value, nan_value);
3794   TEST_ff_f (scalb, 1, nan_value, nan_value);
3795
3796   TEST_ff_f (scalb, 1, 0, 1);
3797   TEST_ff_f (scalb, -1, 0, -1);
3798
3799   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3800   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3801
3802   TEST_ff_f (scalb, 0, 2, 0);
3803   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3804   TEST_ff_f (scalb, 0, 0, 0);
3805   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3806   TEST_ff_f (scalb, 0, -1, 0);
3807   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3808   TEST_ff_f (scalb, 0, minus_infty, 0);
3809   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3810
3811   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3812   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3813   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3814   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3815   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3816   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3817
3818   TEST_ff_f (scalb, 0.1L, minus_infty, 0.0);
3819   TEST_ff_f (scalb, -0.1L, minus_infty, minus_zero);
3820
3821   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3822   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3823   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3824   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3825
3826   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3827   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
3828
3829   TEST_ff_f (scalb, nan_value, 1, nan_value);
3830   TEST_ff_f (scalb, 1, nan_value, nan_value);
3831   TEST_ff_f (scalb, nan_value, 0, nan_value);
3832   TEST_ff_f (scalb, 0, nan_value, nan_value);
3833   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3834   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3835   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3836
3837   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3838   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3839
3840   END (scalb);
3841 }
3842
3843
3844 static void
3845 scalbn_test (void)
3846 {
3847
3848   START (scalbn);
3849
3850   TEST_fi_f (scalbn, 0, 0, 0);
3851   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3852
3853   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
3854   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
3855   TEST_fi_f (scalbn, nan_value, 1, nan_value);
3856
3857   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
3858   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
3859
3860   TEST_fi_f (scalbn, 1, 0L, 1);
3861
3862   END (scalbn);
3863 }
3864
3865
3866 static void
3867 scalbln_test (void)
3868 {
3869
3870   START (scalbln);
3871
3872   TEST_fl_f (scalbln, 0, 0, 0);
3873   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
3874
3875   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
3876   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
3877   TEST_fl_f (scalbln, nan_value, 1, nan_value);
3878
3879   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
3880   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
3881
3882   TEST_fl_f (scalbln, 1, 0L, 1);
3883
3884   END (scalbn);
3885 }
3886
3887
3888 static void
3889 signbit_test (void)
3890 {
3891
3892   START (signbit);
3893
3894   TEST_f_b (signbit, 0, 0);
3895   TEST_f_b (signbit, minus_zero, 1);
3896   TEST_f_b (signbit, plus_infty, 0);
3897   TEST_f_b (signbit, minus_infty, 1);
3898
3899   /* signbit (x) != 0 for x < 0.  */
3900   TEST_f_b (signbit, -1, 1);
3901   /* signbit (x) == 0 for x >= 0.  */
3902   TEST_f_b (signbit, 1, 0);
3903
3904   END (signbit);
3905 }
3906
3907
3908 static void
3909 sin_test (void)
3910 {
3911   errno = 0;
3912   FUNC(sin) (0);
3913   if (errno == ENOSYS)
3914     /* Function not implemented.  */
3915     return;
3916
3917   START (sin);
3918
3919   TEST_f_f (sin, 0, 0);
3920   TEST_f_f (sin, minus_zero, minus_zero);
3921   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
3922   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
3923   TEST_f_f (sin, nan_value, nan_value);
3924
3925   TEST_f_f (sin, M_PI_6l, 0.5);
3926   TEST_f_f (sin, -M_PI_6l, -0.5);
3927   TEST_f_f (sin, M_PI_2l, 1);
3928   TEST_f_f (sin, -M_PI_2l, -1);
3929   TEST_f_f (sin, 0.75L, 0.681638760023334166733241952779893935L);
3930
3931 #ifdef TEST_DOUBLE
3932   TEST_f_f (sin, 0.80190127184058835, 0.71867942238767868);
3933 #endif
3934
3935   END (sin);
3936
3937 }
3938
3939
3940 static void
3941 sincos_test (void)
3942 {
3943   FLOAT sin_res, cos_res;
3944
3945   errno = 0;
3946   FUNC(sincos) (0, &sin_res, &cos_res);
3947   if (errno == ENOSYS)
3948     /* Function not implemented.  */
3949     return;
3950
3951   START (sincos);
3952
3953   /* sincos is treated differently because it returns void.  */
3954   TEST_extra (sincos, 0, 0, 1);
3955
3956   TEST_extra (sincos, minus_zero, minus_zero, 1);
3957   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3958   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3959   TEST_extra (sincos, nan_value, nan_value, nan_value);
3960
3961   TEST_extra (sincos, M_PI_2l, 1, 0);
3962   TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L);
3963   TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5);
3964   TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L);
3965
3966 #ifdef TEST_DOUBLE
3967   TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473);
3968 #endif
3969
3970   END (sincos);
3971 }
3972
3973 static void
3974 sinh_test (void)
3975 {
3976   errno = 0;
3977   FUNC(sinh) (0.7L);
3978   if (errno == ENOSYS)
3979     /* Function not implemented.  */
3980     return;
3981
3982   START (sinh);
3983   TEST_f_f (sinh, 0, 0);
3984   TEST_f_f (sinh, minus_zero, minus_zero);
3985
3986 #ifndef TEST_INLINE
3987   TEST_f_f (sinh, plus_infty, plus_infty);
3988   TEST_f_f (sinh, minus_infty, minus_infty);
3989 #endif
3990   TEST_f_f (sinh, nan_value, nan_value);
3991
3992   TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L);
3993   TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L);
3994
3995   END (sinh);
3996 }
3997
3998 static void
3999 sqrt_test (void)
4000 {
4001   errno = 0;
4002   FUNC(sqrt) (1);
4003   if (errno == ENOSYS)
4004     /* Function not implemented.  */
4005     return;
4006
4007   START (sqrt);
4008
4009   TEST_f_f (sqrt, 0, 0);
4010   TEST_f_f (sqrt, nan_value, nan_value);
4011   TEST_f_f (sqrt, plus_infty, plus_infty);
4012
4013   TEST_f_f (sqrt, minus_zero, minus_zero);
4014
4015   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
4016   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
4017   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
4018   TEST_f_f (sqrt, nan_value, nan_value);
4019
4020   TEST_f_f (sqrt, 2209, 47);
4021   TEST_f_f (sqrt, 4, 2);
4022   TEST_f_f (sqrt, 2, M_SQRT2l);
4023   TEST_f_f (sqrt, 0.25, 0.5);
4024   TEST_f_f (sqrt, 6642.25, 81.5);
4025   TEST_f_f (sqrt, 15190.5625L, 123.25L);
4026   TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L);
4027
4028   END (sqrt);
4029 }
4030
4031
4032 static void
4033 tan_test (void)
4034 {
4035   errno = 0;
4036   FUNC(tan) (0);
4037   if (errno == ENOSYS)
4038     /* Function not implemented.  */
4039     return;
4040
4041   START (tan);
4042
4043   TEST_f_f (tan, 0, 0);
4044   TEST_f_f (tan, minus_zero, minus_zero);
4045   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
4046   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
4047   TEST_f_f (tan, nan_value, nan_value);
4048
4049   TEST_f_f (tan, M_PI_4l, 1);
4050   TEST_f_f (tan, 0.75L, 0.931596459944072461165202756573936428L);
4051
4052   END (tan);
4053 }
4054
4055 static void
4056 tanh_test (void)
4057 {
4058   errno = 0;
4059   FUNC(tanh) (0.7L);
4060   if (errno == ENOSYS)
4061     /* Function not implemented.  */
4062     return;
4063
4064   START (tanh);
4065
4066   TEST_f_f (tanh, 0, 0);
4067   TEST_f_f (tanh, minus_zero, minus_zero);
4068
4069 #ifndef TEST_INLINE
4070   TEST_f_f (tanh, plus_infty, 1);
4071   TEST_f_f (tanh, minus_infty, -1);
4072 #endif
4073   TEST_f_f (tanh, nan_value, nan_value);
4074
4075   TEST_f_f (tanh, 0.75L, 0.635148952387287319214434357312496495L);
4076   TEST_f_f (tanh, -0.75L, -0.635148952387287319214434357312496495L);
4077
4078   TEST_f_f (tanh, 1.0L, 0.7615941559557648881194582826047935904L);
4079   TEST_f_f (tanh, -1.0L, -0.7615941559557648881194582826047935904L);
4080
4081   /* 2^-57  */
4082   TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L);
4083
4084   END (tanh);
4085 }
4086
4087 static void
4088 tgamma_test (void)
4089 {
4090   errno = 0;
4091   FUNC(tgamma) (1);
4092   if (errno == ENOSYS)
4093     /* Function not implemented.  */
4094     return;
4095   feclearexcept (FE_ALL_EXCEPT);
4096
4097   START (tgamma);
4098
4099   TEST_f_f (tgamma, plus_infty, plus_infty);
4100   TEST_f_f (tgamma, 0, nan_value, INVALID_EXCEPTION);
4101   TEST_f_f (tgamma, minus_zero, nan_value, INVALID_EXCEPTION);
4102   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
4103   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
4104   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
4105   TEST_f_f (tgamma, nan_value, nan_value);
4106
4107   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
4108   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
4109
4110   TEST_f_f (tgamma, 1, 1);
4111   TEST_f_f (tgamma, 4, 6);
4112
4113   TEST_f_f (tgamma, 0.7L, 1.29805533264755778568117117915281162L);
4114   TEST_f_f (tgamma, 1.2L, 0.918168742399760610640951655185830401L);
4115
4116   END (tgamma);
4117 }
4118
4119
4120 static void
4121 trunc_test (void)
4122 {
4123   START (trunc);
4124
4125   TEST_f_f (trunc, plus_infty, plus_infty);
4126   TEST_f_f (trunc, minus_infty, minus_infty);
4127   TEST_f_f (trunc, nan_value, nan_value);
4128
4129   TEST_f_f (trunc, 0, 0);
4130   TEST_f_f (trunc, minus_zero, minus_zero);
4131   TEST_f_f (trunc, 0.625, 0);
4132   TEST_f_f (trunc, -0.625, minus_zero);
4133   TEST_f_f (trunc, 1, 1);
4134   TEST_f_f (trunc, -1, -1);
4135   TEST_f_f (trunc, 1.625, 1);
4136   TEST_f_f (trunc, -1.625, -1);
4137
4138   TEST_f_f (trunc, 1048580.625L, 1048580L);
4139   TEST_f_f (trunc, -1048580.625L, -1048580L);
4140
4141   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
4142   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
4143
4144   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
4145   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
4146
4147
4148   END (trunc);
4149 }
4150
4151 static void
4152 y0_test (void)
4153 {
4154   FLOAT s, c;
4155   errno = 0;
4156   FUNC (sincos) (0, &s, &c);
4157   if (errno == ENOSYS)
4158     /* Required function not implemented.  */
4159     return;
4160   FUNC(y0) (1);
4161   if (errno == ENOSYS)
4162     /* Function not implemented.  */
4163     return;
4164
4165   /* y0 is the Bessel function of the second kind of order 0 */
4166   START (y0);
4167
4168   TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION);
4169   TEST_f_f (y0, 0.0, minus_infty);
4170   TEST_f_f (y0, nan_value, nan_value);
4171   TEST_f_f (y0, plus_infty, 0);
4172
4173   TEST_f_f (y0, 0.125L, -1.38968062514384052915582277745018693L);
4174   TEST_f_f (y0, 0.75L, -0.137172769385772397522814379396581855L);
4175   TEST_f_f (y0, 1.0, 0.0882569642156769579829267660235151628L);
4176   TEST_f_f (y0, 1.5, 0.382448923797758843955068554978089862L);
4177   TEST_f_f (y0, 2.0, 0.510375672649745119596606592727157873L);
4178   TEST_f_f (y0, 8.0, 0.223521489387566220527323400498620359L);
4179   TEST_f_f (y0, 10.0, 0.0556711672835993914244598774101900481L);
4180
4181   END (y0);
4182 }
4183
4184
4185 static void
4186 y1_test (void)
4187 {
4188   FLOAT s, c;
4189   errno = 0;
4190   FUNC (sincos) (0, &s, &c);
4191   if (errno == ENOSYS)
4192     /* Required function not implemented.  */
4193     return;
4194   FUNC(y1) (1);
4195   if (errno == ENOSYS)
4196     /* Function not implemented.  */
4197     return;
4198
4199   /* y1 is the Bessel function of the second kind of order 1 */
4200   START (y1);
4201
4202   TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION);
4203   TEST_f_f (y1, 0.0, minus_infty);
4204   TEST_f_f (y1, plus_infty, 0);
4205   TEST_f_f (y1, nan_value, nan_value);
4206
4207   TEST_f_f (y1, 0.125L, -5.19993611253477499595928744876579921L);
4208   TEST_f_f (y1, 0.75L, -1.03759455076928541973767132140642198L);
4209   TEST_f_f (y1, 1.0, -0.781212821300288716547150000047964821L);
4210   TEST_f_f (y1, 1.5, -0.412308626973911295952829820633445323L);
4211   TEST_f_f (y1, 2.0, -0.107032431540937546888370772277476637L);
4212   TEST_f_f (y1, 8.0, -0.158060461731247494255555266187483550L);
4213   TEST_f_f (y1, 10.0, 0.249015424206953883923283474663222803L);
4214
4215   END (y1);
4216 }
4217
4218
4219 static void
4220 yn_test (void)
4221 {
4222   FLOAT s, c;
4223   errno = 0;
4224   FUNC (sincos) (0, &s, &c);
4225   if (errno == ENOSYS)
4226     /* Required function not implemented.  */
4227     return;
4228   FUNC(yn) (1, 1);
4229   if (errno == ENOSYS)
4230     /* Function not implemented.  */
4231     return;
4232
4233   /* yn is the Bessel function of the second kind of order n */
4234   START (yn);
4235
4236   /* yn (0, x) == y0 (x)  */
4237   TEST_ff_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION);
4238   TEST_ff_f (yn, 0, 0.0, minus_infty);
4239   TEST_ff_f (yn, 0, nan_value, nan_value);
4240   TEST_ff_f (yn, 0, plus_infty, 0);
4241
4242   TEST_ff_f (yn, 0, 0.125L, -1.38968062514384052915582277745018693L);
4243   TEST_ff_f (yn, 0, 0.75L, -0.137172769385772397522814379396581855L);
4244   TEST_ff_f (yn, 0, 1.0, 0.0882569642156769579829267660235151628L);
4245   TEST_ff_f (yn, 0, 1.5, 0.382448923797758843955068554978089862L);
4246   TEST_ff_f (yn, 0, 2.0, 0.510375672649745119596606592727157873L);
4247   TEST_ff_f (yn, 0, 8.0, 0.223521489387566220527323400498620359L);
4248   TEST_ff_f (yn, 0, 10.0, 0.0556711672835993914244598774101900481L);
4249
4250   /* yn (1, x) == y1 (x)  */
4251   TEST_ff_f (yn, 1, -1.0, minus_infty, INVALID_EXCEPTION);
4252   TEST_ff_f (yn, 1, 0.0, minus_infty);
4253   TEST_ff_f (yn, 1, plus_infty, 0);
4254   TEST_ff_f (yn, 1, nan_value, nan_value);
4255
4256   TEST_ff_f (yn, 1, 0.125L, -5.19993611253477499595928744876579921L);
4257   TEST_ff_f (yn, 1, 0.75L, -1.03759455076928541973767132140642198L);
4258   TEST_ff_f (yn, 1, 1.0, -0.781212821300288716547150000047964821L);
4259   TEST_ff_f (yn, 1, 1.5, -0.412308626973911295952829820633445323L);
4260   TEST_ff_f (yn, 1, 2.0, -0.107032431540937546888370772277476637L);
4261   TEST_ff_f (yn, 1, 8.0, -0.158060461731247494255555266187483550L);
4262   TEST_ff_f (yn, 1, 10.0, 0.249015424206953883923283474663222803L);
4263
4264   /* yn (3, x)  */
4265   TEST_ff_f (yn, 3, plus_infty, 0);
4266   TEST_ff_f (yn, 3, nan_value, nan_value);
4267
4268   TEST_ff_f (yn, 3, 0.125L, -2612.69757350066712600220955744091741L);
4269   TEST_ff_f (yn, 3, 0.75L, -12.9877176234475433186319774484809207L);
4270   TEST_ff_f (yn, 3, 1.0, -5.82151760596472884776175706442981440L);
4271   TEST_ff_f (yn, 3, 2.0, -1.12778377684042778608158395773179238L);
4272   TEST_ff_f (yn, 3, 10.0, -0.251362657183837329779204747654240998L);
4273
4274   /* yn (10, x)  */
4275   TEST_ff_f (yn, 10, plus_infty, 0);
4276   TEST_ff_f (yn, 10, nan_value, nan_value);
4277
4278   TEST_ff_f (yn, 10, 0.125L, -127057845771019398.252538486899753195L);
4279   TEST_ff_f (yn, 10, 0.75L, -2133501638.90573424452445412893839236L);
4280   TEST_ff_f (yn, 10, 1.0, -121618014.278689189288130426667971145L);
4281   TEST_ff_f (yn, 10, 2.0, -129184.542208039282635913145923304214L);
4282   TEST_ff_f (yn, 10, 10.0, -0.359814152183402722051986577343560609L);
4283
4284   END (yn);
4285
4286 }
4287
4288
4289 static void
4290 significand_test (void)
4291 {
4292   /* significand returns the mantissa of the exponential representation.  */
4293   START (significand);
4294
4295   TEST_f_f (significand, 4.0, 1.0);
4296   TEST_f_f (significand, 6.0, 1.5);
4297   TEST_f_f (significand, 8.0, 1.0);
4298
4299   END (significand);
4300 }
4301
4302
4303 static void
4304 initialize (void)
4305 {
4306   fpstack_test ("start *init*");
4307   plus_zero = 0.0;
4308   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
4309
4310   minus_zero = FUNC(copysign) (0.0, -1.0);
4311   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF,
4312                        HUGE_VALL, HUGE_VAL, HUGE_VALF);
4313   minus_infty = CHOOSE (-HUGE_VALL, -HUGE_VAL, -HUGE_VALF,
4314                         -HUGE_VALL, -HUGE_VAL, -HUGE_VALF);
4315
4316   (void) &plus_zero;
4317   (void) &nan_value;
4318   (void) &minus_zero;
4319   (void) &plus_infty;
4320   (void) &minus_infty;
4321
4322   /* Clear all exceptions.  From now on we must not get random exceptions.  */
4323   feclearexcept (FE_ALL_EXCEPT);
4324
4325   /* Test to make sure we start correctly.  */
4326   fpstack_test ("end *init*");
4327 }
4328
4329 /* Definitions of arguments for argp functions.  */
4330 static const struct argp_option options[] =
4331 {
4332   { "verbose", 'v', "NUMBER", 0, "Level of verbosity (0..3)"},
4333   { "ulps-file", 'u', NULL, 0, "Output ulps to file ULPs"},
4334   { "no-max-error", 'f', NULL, 0,
4335     "Don't output maximal errors of functions"},
4336   { "no-points", 'p', NULL, 0,
4337     "Don't output results of functions invocations"},
4338   { "ignore-max-ulp", 'i', "yes/no", 0,
4339     "Ignore given maximal errors"},
4340   { NULL, 0, NULL, 0, NULL }
4341 };
4342
4343 /* Short description of program.  */
4344 static const char doc[] = "Math test suite: " TEST_MSG ;
4345
4346 /* Prototype for option handler.  */
4347 static error_t parse_opt (int key, char *arg, struct argp_state *state);
4348
4349 /* Data structure to communicate with argp functions.  */
4350 static struct argp argp =
4351 {
4352   options, parse_opt, NULL, doc,
4353 };
4354
4355
4356 /* Handle program arguments.  */
4357 static error_t
4358 parse_opt (int key, char *arg, struct argp_state *state)
4359 {
4360   switch (key)
4361     {
4362     case 'f':
4363       output_max_error = 0;
4364       break;
4365     case 'i':
4366       if (strcmp (arg, "yes") == 0)
4367         ignore_max_ulp = 1;
4368       else if (strcmp (arg, "no") == 0)
4369         ignore_max_ulp = 0;
4370       break;
4371     case 'p':
4372       output_points = 0;
4373       break;
4374     case 'u':
4375       output_ulps = 1;
4376       break;
4377     case 'v':
4378       if (optarg)
4379         verbose = (unsigned int) strtoul (optarg, NULL, 0);
4380       else
4381         verbose = 3;
4382       break;
4383     default:
4384       return ARGP_ERR_UNKNOWN;
4385     }
4386   return 0;
4387 }
4388
4389 #if 0
4390 /* function to check our ulp calculation.  */
4391 void
4392 check_ulp (void)
4393 {
4394   int i;
4395
4396   FLOAT u, diff, ulp;
4397   /* This gives one ulp.  */
4398   u = FUNC(nextafter) (10, 20);
4399   check_equal (10.0, u, 1, &diff, &ulp);
4400   printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp);
4401
4402   /* This gives one more ulp.  */
4403   u = FUNC(nextafter) (u, 20);
4404   check_equal (10.0, u, 2, &diff, &ulp);
4405   printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp);
4406
4407   /* And now calculate 100 ulp.  */
4408   for (i = 2; i < 100; i++)
4409     u = FUNC(nextafter) (u, 20);
4410   check_equal (10.0, u, 100, &diff, &ulp);
4411   printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp);
4412 }
4413 #endif
4414
4415 int
4416 main (int argc, char **argv)
4417 {
4418
4419   int remaining;
4420
4421   verbose = 1;
4422   output_ulps = 0;
4423   output_max_error = 1;
4424   output_points = 1;
4425   /* XXX set to 0 for releases.  */
4426   ignore_max_ulp = 0;
4427
4428   /* Parse and process arguments.  */
4429   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
4430
4431   if (remaining != argc)
4432     {
4433       fprintf (stderr, "wrong number of arguments");
4434       argp_help (&argp, stdout, ARGP_HELP_SEE, program_invocation_short_name);
4435       exit (EXIT_FAILURE);
4436     }
4437
4438   if (output_ulps)
4439     {
4440       ulps_file = fopen ("ULPs", "a");
4441       if (ulps_file == NULL)
4442         {
4443           perror ("can't open file `ULPs' for writing: ");
4444           exit (1);
4445         }
4446     }
4447
4448
4449   initialize ();
4450   printf (TEST_MSG);
4451
4452 #if 0
4453   check_ulp ();
4454 #endif
4455
4456   /* Keep the tests a wee bit ordered (according to ISO C99).  */
4457   /* Classification macros:  */
4458   fpclassify_test ();
4459   isfinite_test ();
4460   isnormal_test ();
4461   signbit_test ();
4462
4463   /* Trigonometric functions:  */
4464   acos_test ();
4465   asin_test ();
4466   atan_test ();
4467   atan2_test ();
4468   cos_test ();
4469   sin_test ();
4470   sincos_test ();
4471   tan_test ();
4472
4473   /* Hyperbolic functions:  */
4474   acosh_test ();
4475   asinh_test ();
4476   atanh_test ();
4477   cosh_test ();
4478   sinh_test ();
4479   tanh_test ();
4480
4481   /* Exponential and logarithmic functions:  */
4482   exp_test ();
4483   exp10_test ();
4484   exp2_test ();
4485   expm1_test ();
4486   frexp_test ();
4487   ldexp_test ();
4488   log_test ();
4489   log10_test ();
4490   log1p_test ();
4491   log2_test ();
4492   logb_test ();
4493   modf_test ();
4494   ilogb_test ();
4495   scalb_test ();
4496   scalbn_test ();
4497   scalbln_test ();
4498   significand_test ();
4499
4500   /* Power and absolute value functions:  */
4501   cbrt_test ();
4502   fabs_test ();
4503   hypot_test ();
4504   pow_test ();
4505   sqrt_test ();
4506
4507   /* Error and gamma functions:  */
4508   erf_test ();
4509   erfc_test ();
4510   gamma_test ();
4511   lgamma_test ();
4512   tgamma_test ();
4513
4514   /* Nearest integer functions:  */
4515   ceil_test ();
4516   floor_test ();