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