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