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