71a846f94f559fc7e4874e9f81114b7a0ee4948f
[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         ok = 0;
480       else if (ulp <= max_ulp)
481         ok = 1;
482       else
483         {
484           ok = 0;
485           print_ulps (test_name, ulp);
486         }
487
488     }
489   if (print_screen (ok, xfail))
490     {
491       if (!ok)
492         printf ("Failure: ");
493       printf ("Test: %s\n", test_name);
494       printf ("Result:\n");
495       printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
496               computed, computed);
497       printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
498               expected, expected);
499       if (print_diff)
500         {
501           printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
502                   "\n", diff, diff);
503           printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);
504           printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);
505         }
506     }
507   update_stats (ok, xfail);
508
509   fpstack_test (test_name);
510 }
511
512
513 static void
514 check_float (const char *test_name, FLOAT computed, FLOAT expected,
515              FLOAT max_ulp, int xfail, int exceptions)
516 {
517   check_float_internal (test_name, computed, expected, max_ulp, xfail,
518                         exceptions, &max_error);
519 }
520
521
522 static void
523 check_complex (const char *test_name, __complex__ FLOAT computed,
524                __complex__ FLOAT expected,
525                __complex__ FLOAT max_ulp, __complex__ int xfail,
526                int exception)
527 {
528   FLOAT part_comp, part_exp, part_max_ulp;
529   int part_xfail;
530   char str[200];
531
532   sprintf (str, "Real part of: %s", test_name);
533   part_comp = __real__ computed;
534   part_exp = __real__ expected;
535   part_max_ulp = __real__ max_ulp;
536   part_xfail = __real__ xfail;
537
538   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
539                         exception, &real_max_error);
540
541   sprintf (str, "Imaginary part of: %s", test_name);
542   part_comp = __imag__ computed;
543   part_exp = __imag__ expected;
544   part_max_ulp = __imag__ max_ulp;
545   part_xfail = __imag__ xfail;
546
547   /* Don't check again for exceptions, just pass through the
548      zero/inf sign test.  */
549   check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,
550                         exception & IGNORE_ZERO_INF_SIGN,
551                         &imag_max_error);
552 }
553
554
555 /* Check that computed and expected values are equal (int values).  */
556 static void
557 check_int (const char *test_name, int computed, int expected, int max_ulp,
558            int xfail, int exceptions)
559 {
560   int diff = computed - expected;
561   int ok = 0;
562
563   test_exceptions (test_name, exceptions);
564   noTests++;
565   if (abs (diff) <= max_ulp)
566     ok = 1;
567
568   if (!ok)
569     print_ulps (test_name, diff);
570
571   if (print_screen (ok, xfail))
572     {
573       if (!ok)
574         printf ("Failure: ");
575       printf ("Test: %s\n", test_name);
576       printf ("Result:\n");
577       printf (" is:         %d\n", computed);
578       printf (" should be:  %d\n", expected);
579     }
580
581   update_stats (ok, xfail);
582   fpstack_test (test_name);
583 }
584
585
586 /* Check that computed and expected values are equal (long int values).  */
587 static void
588 check_long (const char *test_name, long int computed, long int expected,
589             long int max_ulp, int xfail, int exceptions)
590 {
591   long int diff = computed - expected;
592   int ok = 0;
593
594   test_exceptions (test_name, exceptions);
595   noTests++;
596   if (labs (diff) <= max_ulp)
597     ok = 1;
598
599   if (!ok)
600     print_ulps (test_name, diff);
601
602   if (print_screen (ok, xfail))
603     {
604       if (!ok)
605         printf ("Failure: ");
606       printf ("Test: %s\n", test_name);
607       printf ("Result:\n");
608       printf (" is:         %ld\n", computed);
609       printf (" should be:  %ld\n", expected);
610     }
611
612   update_stats (ok, xfail);
613   fpstack_test (test_name);
614 }
615
616
617 /* Check that computed value is true/false.  */
618 static void
619 check_bool (const char *test_name, int computed, int expected,
620             long int max_ulp, int xfail, int exceptions)
621 {
622   int ok = 0;
623
624   test_exceptions (test_name, exceptions);
625   noTests++;
626   if ((computed == 0) == (expected == 0))
627     ok = 1;
628
629   if (print_screen (ok, xfail))
630     {
631       if (!ok)
632         printf ("Failure: ");
633       printf ("Test: %s\n", test_name);
634       printf ("Result:\n");
635       printf (" is:         %d\n", computed);
636       printf (" should be:  %d\n", expected);
637     }
638
639   update_stats (ok, xfail);
640   fpstack_test (test_name);
641 }
642
643
644 /* check that computed and expected values are equal (long int values) */
645 static void
646 check_longlong (const char *test_name, long long int computed,
647                 long long int expected,
648                 long long int max_ulp, int xfail,
649                 int exceptions)
650 {
651   long long int diff = computed - expected;
652   int ok = 0;
653
654   test_exceptions (test_name, exceptions);
655   noTests++;
656   if (llabs (diff) <= max_ulp)
657     ok = 1;
658
659   if (!ok)
660     print_ulps (test_name, diff);
661
662   if (print_screen (ok, xfail))
663     {
664       if (!ok)
665         printf ("Failure:");
666       printf ("Test: %s\n", test_name);
667       printf ("Result:\n");
668       printf (" is:         %lld\n", computed);
669       printf (" should be:  %lld\n", expected);
670     }
671
672   update_stats (ok, xfail);
673   fpstack_test (test_name);
674 }
675
676
677
678 /* This is to prevent messages from the SVID libm emulation.  */
679 int
680 matherr (struct exception *x __attribute__ ((unused)))
681 {
682   return 1;
683 }
684
685
686 /****************************************************************************
687   Tests for single functions of libm.
688   Please keep them alphabetically sorted!
689 ****************************************************************************/
690
691 static void
692 acos_test (void)
693 {
694   START (acos);
695
696   TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);
697   TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);
698   TEST_f_f (acos, nan_value, nan_value);
699
700   /* |x| > 1: */
701   TEST_f_f (acos, 1.1, nan_value, INVALID_EXCEPTION);
702   TEST_f_f (acos, -1.1, nan_value, INVALID_EXCEPTION);
703
704   TEST_f_f (acos, 0, M_PI_2l);
705   TEST_f_f (acos, minus_zero, M_PI_2l);
706   TEST_f_f (acos, 1, 0);
707   TEST_f_f (acos, -1, M_PIl);
708   TEST_f_f (acos, 0.5, M_PI_6l*2.0);
709   TEST_f_f (acos, -0.5, M_PI_6l*4.0);
710   TEST_f_f (acos, 0.7, 0.7953988301841435554L);
711
712   END (acos);
713 }
714
715 static void
716 acosh_test (void)
717 {
718   START (acosh);
719
720   TEST_f_f (acosh, plus_infty, plus_infty);
721   TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);
722
723   /* x < 1:  */
724   TEST_f_f (acosh, -1.1, nan_value, INVALID_EXCEPTION);
725
726   TEST_f_f (acosh, 1, 0);
727   TEST_f_f (acosh, 7, 2.6339157938496334172L);
728
729   END (acosh);
730 }
731
732 static void
733 asin_test (void)
734 {
735
736   START (asin);
737
738   TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);
739   TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);
740   TEST_f_f (asin, nan_value, nan_value);
741
742   /* asin x == NaN plus invalid exception for |x| > 1.  */
743   TEST_f_f (asin, 1.1, nan_value, INVALID_EXCEPTION);
744   TEST_f_f (asin, -1.1, nan_value, INVALID_EXCEPTION);
745
746   TEST_f_f (asin, 0, 0);
747   TEST_f_f (asin, minus_zero, minus_zero);
748   TEST_f_f (asin, 0.5, M_PI_6l);
749   TEST_f_f (asin, -0.5, -M_PI_6l);
750   TEST_f_f (asin, 1.0, M_PI_2l);
751   TEST_f_f (asin, -1.0, -M_PI_2l);
752   TEST_f_f (asin, 0.7, 0.7753974966107530637L);
753
754   END (asin);
755 }
756
757 static void
758 asinh_test (void)
759 {
760   START (asinh);
761
762   TEST_f_f (asinh, 0, 0);
763   TEST_f_f (asinh, minus_zero, minus_zero);
764 #ifndef TEST_INLINE
765   TEST_f_f (asinh, plus_infty, plus_infty);
766   TEST_f_f (asinh, minus_infty, minus_infty);
767 #endif
768   TEST_f_f (asinh, nan_value, nan_value);
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   TEST_f_f (atan, nan_value, nan_value);
786
787   TEST_f_f (atan, 1, M_PI_4l);
788   TEST_f_f (atan, -1, -M_PI_4l);
789
790   TEST_f_f (atan, 0.7, 0.6107259643892086165L);
791
792   END (atan);
793 }
794
795
796
797 static void
798 atanh_test (void)
799 {
800
801   START (atanh);
802
803
804   TEST_f_f (atanh, 0, 0);
805   TEST_f_f (atanh, minus_zero, minus_zero);
806
807   TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
808   TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
809   TEST_f_f (atanh, nan_value, nan_value);
810
811   /* atanh (x) == NaN plus invalid exception if |x| > 1.  */
812   TEST_f_f (atanh, 1.1, nan_value, INVALID_EXCEPTION);
813   TEST_f_f (atanh, -1.1, nan_value, INVALID_EXCEPTION);
814
815   TEST_f_f (atanh, 0.7, 0.8673005276940531944L);
816
817   END (atanh);
818 }
819
820 static void
821 atan2_test (void)
822 {
823   START (atan2);
824
825   /* atan2 (0,x) == 0 for x > 0.  */
826   TEST_ff_f (atan2, 0, 1, 0);
827
828   /* atan2 (-0,x) == -0 for x > 0.  */
829   TEST_ff_f (atan2, minus_zero, 1, minus_zero);
830
831   TEST_ff_f (atan2, 0, 0, 0);
832   TEST_ff_f (atan2, minus_zero, 0, minus_zero);
833
834   /* atan2 (+0,x) == +pi for x < 0.  */
835   TEST_ff_f (atan2, 0, -1, M_PIl);
836
837   /* atan2 (-0,x) == -pi for x < 0.  */
838   TEST_ff_f (atan2, minus_zero, -1, -M_PIl);
839
840   TEST_ff_f (atan2, 0, minus_zero, M_PIl);
841   TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);
842
843   /* atan2 (y,+0) == pi/2 for y > 0.  */
844   TEST_ff_f (atan2, 1, 0, M_PI_2l);
845
846   /* atan2 (y,-0) == pi/2 for y > 0.  */
847   TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);
848
849   /* atan2 (y,+0) == -pi/2 for y < 0.  */
850   TEST_ff_f (atan2, -1, 0, -M_PI_2l);
851
852   /* atan2 (y,-0) == -pi/2 for y < 0.  */
853   TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);
854
855   /* atan2 (y,inf) == +0 for finite y > 0.  */
856   TEST_ff_f (atan2, 1, plus_infty, 0);
857
858   /* atan2 (y,inf) == -0 for finite y < 0.  */
859   TEST_ff_f (atan2, -1, plus_infty, minus_zero);
860
861   /* atan2(+inf, x) == pi/2 for finite x.  */
862   TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);
863
864   /* atan2(-inf, x) == -pi/2 for finite x.  */
865   TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);
866
867   /* atan2 (y,-inf) == +pi for finite y > 0.  */
868   TEST_ff_f (atan2, 1, minus_infty, M_PIl);
869
870   /* atan2 (y,-inf) == -pi for finite y < 0.  */
871   TEST_ff_f (atan2, -1, minus_infty, -M_PIl);
872
873   TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);
874   TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);
875   TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);
876   TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);
877   TEST_ff_f (atan2, nan_value, nan_value, nan_value);
878
879   TEST_ff_f (atan2, 0.7, 1, 0.6107259643892086165L);
880   TEST_ff_f (atan2, 0.4, 0.0003, 1.5700463269355215718L);
881
882   END (atan2);
883 }
884
885
886 static void
887 cabs_test (void)
888 {
889   START (cabs);
890
891   /* cabs (x + iy) is specified as hypot (x,y) */
892
893   /* cabs (+inf + i x) == +inf.  */
894   TEST_c_f (cabs, plus_infty, 1.0, plus_infty);
895   /* cabs (-inf + i x) == +inf.  */
896   TEST_c_f (cabs, minus_infty, 1.0, plus_infty);
897
898   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
899   TEST_c_f (cabs, minus_infty, nan_value, plus_infty);
900
901   TEST_c_f (cabs, nan_value, nan_value, nan_value);
902
903   /* cabs (x,y) == cabs (y,x).  */
904   TEST_c_f (cabs, 0.7L, 12.4L, 12.41974234837422060118L);
905   /* cabs (x,y) == cabs (-x,y).  */
906   TEST_c_f (cabs, -12.4L, 0.7L, 12.41974234837422060118L);
907   /* cabs (x,y) == cabs (-y,x).  */
908   TEST_c_f (cabs, -0.7L, 12.4L, 12.41974234837422060118L);
909   /* cabs (x,y) == cabs (-x,-y).  */
910   TEST_c_f (cabs, -12.4L, -0.7L, 12.41974234837422060118L);
911   /* cabs (x,y) == cabs (-y,-x).  */
912   TEST_c_f (cabs, -0.7L, -12.4L, 12.41974234837422060118L);
913   /* cabs (x,0) == fabs (x).  */
914   TEST_c_f (cabs, -0.7L, 0, 0.7L);
915   TEST_c_f (cabs, 0.7L, 0, 0.7L);
916   TEST_c_f (cabs, -1.0L, 0, 1.0L);
917   TEST_c_f (cabs, 1.0L, 0, 1.0L);
918   TEST_c_f (cabs, -5.7e7L, 0, 5.7e7L);
919   TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L);
920
921   TEST_c_f (cabs, 0.7, 1.2, 1.3892443989449804508L);
922
923   END (cabs);
924 }
925
926 static void
927 cacos_test (void)
928 {
929   START (cacos);
930
931
932   TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero);
933   TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero);
934   TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0);
935   TEST_c_c (cacos, 0, minus_zero, M_PI_2l, 0.0);
936
937   TEST_c_c (cacos, minus_infty, plus_infty, M_PI_34l, minus_infty);
938   TEST_c_c (cacos, minus_infty, minus_infty, M_PI_34l, plus_infty);
939
940   TEST_c_c (cacos, plus_infty, plus_infty, M_PI_4l, minus_infty);
941   TEST_c_c (cacos, plus_infty, minus_infty, M_PI_4l, plus_infty);
942
943   TEST_c_c (cacos, -10.0, plus_infty, M_PI_2l, minus_infty);
944   TEST_c_c (cacos, -10.0, minus_infty, M_PI_2l, plus_infty);
945   TEST_c_c (cacos, 0, plus_infty, M_PI_2l, minus_infty);
946   TEST_c_c (cacos, 0, minus_infty, M_PI_2l, plus_infty);
947   TEST_c_c (cacos, 0.1, plus_infty, M_PI_2l, minus_infty);
948   TEST_c_c (cacos, 0.1, minus_infty, M_PI_2l, plus_infty);
949
950   TEST_c_c (cacos, minus_infty, 0, M_PIl, minus_infty);
951   TEST_c_c (cacos, minus_infty, minus_zero, M_PIl, plus_infty);
952   TEST_c_c (cacos, minus_infty, 100, M_PIl, minus_infty);
953   TEST_c_c (cacos, minus_infty, -100, M_PIl, plus_infty);
954
955   TEST_c_c (cacos, plus_infty, 0, 0.0, minus_infty);
956   TEST_c_c (cacos, plus_infty, minus_zero, 0.0, plus_infty);
957   TEST_c_c (cacos, plus_infty, 0.5, 0.0, minus_infty);
958   TEST_c_c (cacos, plus_infty, -0.5, 0.0, plus_infty);
959
960   TEST_c_c (cacos, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
961   TEST_c_c (cacos, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
962
963   TEST_c_c (cacos, 0, nan_value, M_PI_2l, nan_value);
964   TEST_c_c (cacos, minus_zero, nan_value, M_PI_2l, nan_value);
965
966   TEST_c_c (cacos, nan_value, plus_infty, nan_value, minus_infty);
967   TEST_c_c (cacos, nan_value, minus_infty, nan_value, plus_infty);
968
969   TEST_c_c (cacos, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
970   TEST_c_c (cacos, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
971
972   TEST_c_c (cacos, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
973   TEST_c_c (cacos, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
974
975   TEST_c_c (cacos, nan_value, nan_value, nan_value, nan_value);
976
977   TEST_c_c (cacos, 0.7, 1.2, 1.1351827477151551089L, -1.0927647857577371459L);
978   TEST_c_c (cacos, -2, -3, 2.1414491111159960199L, 1.9833870299165354323L);
979
980   END (cacos, complex);
981 }
982
983
984 static void
985 cacosh_test (void)
986 {
987   START (cacosh);
988
989
990   TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l);
991   TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l);
992   TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l);
993   TEST_c_c (cacosh, minus_zero, minus_zero, 0.0, -M_PI_2l);
994   TEST_c_c (cacosh, minus_infty, plus_infty, plus_infty, M_PI_34l);
995   TEST_c_c (cacosh, minus_infty, minus_infty, plus_infty, -M_PI_34l);
996
997   TEST_c_c (cacosh, plus_infty, plus_infty, plus_infty, M_PI_4l);
998   TEST_c_c (cacosh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
999
1000   TEST_c_c (cacosh, -10.0, plus_infty, plus_infty, M_PI_2l);
1001   TEST_c_c (cacosh, -10.0, minus_infty, plus_infty, -M_PI_2l);
1002   TEST_c_c (cacosh, 0, plus_infty, plus_infty, M_PI_2l);
1003   TEST_c_c (cacosh, 0, minus_infty, plus_infty, -M_PI_2l);
1004   TEST_c_c (cacosh, 0.1, plus_infty, plus_infty, M_PI_2l);
1005   TEST_c_c (cacosh, 0.1, minus_infty, plus_infty, -M_PI_2l);
1006
1007   TEST_c_c (cacosh, minus_infty, 0, plus_infty, M_PIl);
1008   TEST_c_c (cacosh, minus_infty, minus_zero, plus_infty, -M_PIl);
1009   TEST_c_c (cacosh, minus_infty, 100, plus_infty, M_PIl);
1010   TEST_c_c (cacosh, minus_infty, -100, plus_infty, -M_PIl);
1011
1012   TEST_c_c (cacosh, plus_infty, 0, plus_infty, 0.0);
1013   TEST_c_c (cacosh, plus_infty, minus_zero, plus_infty, minus_zero);
1014   TEST_c_c (cacosh, plus_infty, 0.5, plus_infty, 0.0);
1015   TEST_c_c (cacosh, plus_infty, -0.5, plus_infty, minus_zero);
1016
1017   TEST_c_c (cacosh, plus_infty, nan_value, plus_infty, nan_value);
1018   TEST_c_c (cacosh, minus_infty, nan_value, plus_infty, nan_value);
1019
1020   TEST_c_c (cacosh, 0, nan_value, nan_value, nan_value);
1021   TEST_c_c (cacosh, minus_zero, nan_value, nan_value, nan_value);
1022
1023   TEST_c_c (cacosh, nan_value, plus_infty, plus_infty, nan_value);
1024   TEST_c_c (cacosh, nan_value, minus_infty, plus_infty, nan_value);
1025
1026   TEST_c_c (cacosh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1027   TEST_c_c (cacosh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1028
1029   TEST_c_c (cacosh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1030   TEST_c_c (cacosh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1031
1032   TEST_c_c (cacosh, nan_value, nan_value, nan_value, nan_value);
1033
1034   TEST_c_c (cacosh, 0.7, 1.2, 1.0927647857577371459L, 1.1351827477151551089L);
1035   TEST_c_c (cacosh, -2, -3, -1.9833870299165354323L, 2.1414491111159960199L);
1036
1037   END (cacosh, complex);
1038 }
1039
1040 static void
1041 carg_test (void)
1042 {
1043   START (carg);
1044
1045   /* carg (x + iy) is specified as atan2 (y, x) */
1046
1047   /* carg (x + i 0) == 0 for x > 0.  */
1048   TEST_c_f (carg, 2.0, 0, 0);
1049   /* carg (x - i 0) == -0 for x > 0.  */
1050   TEST_c_f (carg, 2.0, minus_zero, minus_zero);
1051
1052   TEST_c_f (carg, 0, 0, 0);
1053   TEST_c_f (carg, 0, minus_zero, minus_zero);
1054
1055   /* carg (x + i 0) == +pi for x < 0.  */
1056   TEST_c_f (carg, -2.0, 0, M_PIl);
1057
1058   /* carg (x - i 0) == -pi for x < 0.  */
1059   TEST_c_f (carg, -2.0, minus_zero, -M_PIl);
1060
1061   TEST_c_f (carg, minus_zero, 0, M_PIl);
1062   TEST_c_f (carg, minus_zero, minus_zero, -M_PIl);
1063
1064   /* carg (+0 + i y) == pi/2 for y > 0.  */
1065   TEST_c_f (carg, 0, 2.0, M_PI_2l);
1066
1067   /* carg (-0 + i y) == pi/2 for y > 0.  */
1068   TEST_c_f (carg, minus_zero, 2.0, M_PI_2l);
1069
1070   /* carg (+0 + i y) == -pi/2 for y < 0.  */
1071   TEST_c_f (carg, 0, -2.0, -M_PI_2l);
1072
1073   /* carg (-0 + i y) == -pi/2 for y < 0.  */
1074   TEST_c_f (carg, minus_zero, -2.0, -M_PI_2l);
1075
1076   /* carg (inf + i y) == +0 for finite y > 0.  */
1077   TEST_c_f (carg, plus_infty, 2.0, 0);
1078
1079   /* carg (inf + i y) == -0 for finite y < 0.  */
1080   TEST_c_f (carg, plus_infty, -2.0, minus_zero);
1081
1082   /* carg(x + i inf) == pi/2 for finite x.  */
1083   TEST_c_f (carg, 10.0, plus_infty, M_PI_2l);
1084
1085   /* carg(x - i inf) == -pi/2 for finite x.  */
1086   TEST_c_f (carg, 10.0, minus_infty, -M_PI_2l);
1087
1088   /* carg (-inf + i y) == +pi for finite y > 0.  */
1089   TEST_c_f (carg, minus_infty, 10.0, M_PIl);
1090
1091   /* carg (-inf + i y) == -pi for finite y < 0.  */
1092   TEST_c_f (carg, minus_infty, -10.0, -M_PIl);
1093
1094   TEST_c_f (carg, plus_infty, plus_infty, M_PI_4l);
1095
1096   TEST_c_f (carg, plus_infty, minus_infty, -M_PI_4l);
1097
1098   TEST_c_f (carg, minus_infty, plus_infty, 3 * M_PI_4l);
1099
1100   TEST_c_f (carg, minus_infty, minus_infty, -3 * M_PI_4l);
1101
1102   TEST_c_f (carg, nan_value, nan_value, nan_value);
1103
1104   END (carg);
1105 }
1106
1107 static void
1108 casin_test (void)
1109 {
1110   START (casin);
1111
1112   TEST_c_c (casin, 0, 0, 0.0, 0.0);
1113   TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0);
1114   TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero);
1115   TEST_c_c (casin, minus_zero, minus_zero, minus_zero, minus_zero);
1116
1117   TEST_c_c (casin, plus_infty, plus_infty, M_PI_4l, plus_infty);
1118   TEST_c_c (casin, plus_infty, minus_infty, M_PI_4l, minus_infty);
1119   TEST_c_c (casin, minus_infty, plus_infty, -M_PI_4l, plus_infty);
1120   TEST_c_c (casin, minus_infty, minus_infty, -M_PI_4l, minus_infty);
1121
1122   TEST_c_c (casin, -10.0, plus_infty, minus_zero, plus_infty);
1123   TEST_c_c (casin, -10.0, minus_infty, minus_zero, minus_infty);
1124   TEST_c_c (casin, 0, plus_infty, 0.0, plus_infty);
1125   TEST_c_c (casin, 0, minus_infty, 0.0, minus_infty);
1126   TEST_c_c (casin, minus_zero, plus_infty, minus_zero, plus_infty);
1127   TEST_c_c (casin, minus_zero, minus_infty, minus_zero, minus_infty);
1128   TEST_c_c (casin, 0.1, plus_infty, 0.0, plus_infty);
1129   TEST_c_c (casin, 0.1, minus_infty, 0.0, minus_infty);
1130
1131   TEST_c_c (casin, minus_infty, 0, -M_PI_2l, plus_infty);
1132   TEST_c_c (casin, minus_infty, minus_zero, -M_PI_2l, minus_infty);
1133   TEST_c_c (casin, minus_infty, 100, -M_PI_2l, plus_infty);
1134   TEST_c_c (casin, minus_infty, -100, -M_PI_2l, minus_infty);
1135
1136   TEST_c_c (casin, plus_infty, 0, M_PI_2l, plus_infty);
1137   TEST_c_c (casin, plus_infty, minus_zero, M_PI_2l, minus_infty);
1138   TEST_c_c (casin, plus_infty, 0.5, M_PI_2l, plus_infty);
1139   TEST_c_c (casin, plus_infty, -0.5, M_PI_2l, minus_infty);
1140
1141   TEST_c_c (casin, nan_value, plus_infty, nan_value, plus_infty);
1142   TEST_c_c (casin, nan_value, minus_infty, nan_value, minus_infty);
1143
1144   TEST_c_c (casin, 0.0, nan_value, 0.0, nan_value);
1145   TEST_c_c (casin, minus_zero, nan_value, minus_zero, nan_value);
1146
1147   TEST_c_c (casin, plus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1148   TEST_c_c (casin, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1149
1150   TEST_c_c (casin, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1151   TEST_c_c (casin, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1152
1153   TEST_c_c (casin, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1154   TEST_c_c (casin, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1155
1156   TEST_c_c (casin, nan_value, nan_value, nan_value, nan_value);
1157
1158   TEST_c_c (casin, 0.7, 1.2, 0.4356135790797415103L, 1.0927647857577371459L);
1159   TEST_c_c (casin, -2, -3, -0.5706527843210994007L, -1.9833870299165354323L);
1160
1161   END (casin, complex);
1162 }
1163
1164
1165 static void
1166 casinh_test (void)
1167 {
1168   START (casinh);
1169
1170   TEST_c_c (casinh, 0, 0, 0.0, 0.0);
1171   TEST_c_c (casinh, minus_zero, 0, minus_zero, 0);
1172   TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero);
1173   TEST_c_c (casinh, minus_zero, minus_zero, minus_zero, minus_zero);
1174
1175   TEST_c_c (casinh, plus_infty, plus_infty, plus_infty, M_PI_4l);
1176   TEST_c_c (casinh, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1177   TEST_c_c (casinh, minus_infty, plus_infty, minus_infty, M_PI_4l);
1178   TEST_c_c (casinh, minus_infty, minus_infty, minus_infty, -M_PI_4l);
1179
1180   TEST_c_c (casinh, -10.0, plus_infty, minus_infty, M_PI_2l);
1181   TEST_c_c (casinh, -10.0, minus_infty, minus_infty, -M_PI_2l);
1182   TEST_c_c (casinh, 0, plus_infty, plus_infty, M_PI_2l);
1183   TEST_c_c (casinh, 0, minus_infty, plus_infty, -M_PI_2l);
1184   TEST_c_c (casinh, minus_zero, plus_infty, minus_infty, M_PI_2l);
1185   TEST_c_c (casinh, minus_zero, minus_infty, minus_infty, -M_PI_2l);
1186   TEST_c_c (casinh, 0.1, plus_infty, plus_infty, M_PI_2l);
1187   TEST_c_c (casinh, 0.1, minus_infty, plus_infty, -M_PI_2l);
1188
1189   TEST_c_c (casinh, minus_infty, 0, minus_infty, 0.0);
1190   TEST_c_c (casinh, minus_infty, minus_zero, minus_infty, minus_zero);
1191   TEST_c_c (casinh, minus_infty, 100, minus_infty, 0.0);
1192   TEST_c_c (casinh, minus_infty, -100, minus_infty, minus_zero);
1193
1194   TEST_c_c (casinh, plus_infty, 0, plus_infty, 0.0);
1195   TEST_c_c (casinh, plus_infty, minus_zero, plus_infty, minus_zero);
1196   TEST_c_c (casinh, plus_infty, 0.5, plus_infty, 0.0);
1197   TEST_c_c (casinh, plus_infty, -0.5, plus_infty, minus_zero);
1198
1199   TEST_c_c (casinh, plus_infty, nan_value, plus_infty, nan_value);
1200   TEST_c_c (casinh, minus_infty, nan_value, minus_infty, nan_value);
1201
1202   TEST_c_c (casinh, nan_value, 0, nan_value, 0.0);
1203   TEST_c_c (casinh, nan_value, minus_zero, nan_value, minus_zero);
1204
1205   TEST_c_c (casinh, nan_value, plus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1206   TEST_c_c (casinh, nan_value, minus_infty, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1207
1208   TEST_c_c (casinh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1209   TEST_c_c (casinh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1210
1211   TEST_c_c (casinh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1212   TEST_c_c (casinh, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1213
1214   TEST_c_c (casinh, nan_value, nan_value, nan_value, nan_value);
1215
1216   TEST_c_c (casinh, 0.7, 1.2, 0.9786545955936738768L, 0.9113541895315601156L);
1217   TEST_c_c (casinh, -2, -3, -1.9686379257930962917L, -0.9646585044076027920L);
1218
1219   END (casinh, complex);
1220 }
1221
1222
1223 static void
1224 catan_test (void)
1225 {
1226   START (catan);
1227
1228   TEST_c_c (catan, 0, 0, 0, 0);
1229   TEST_c_c (catan, minus_zero, 0, minus_zero, 0);
1230   TEST_c_c (catan, 0, minus_zero, 0, minus_zero);
1231   TEST_c_c (catan, minus_zero, minus_zero, minus_zero, minus_zero);
1232
1233   TEST_c_c (catan, plus_infty, plus_infty, M_PI_2l, 0);
1234   TEST_c_c (catan, plus_infty, minus_infty, M_PI_2l, minus_zero);
1235   TEST_c_c (catan, minus_infty, plus_infty, -M_PI_2l, 0);
1236   TEST_c_c (catan, minus_infty, minus_infty, -M_PI_2l, minus_zero);
1237
1238
1239   TEST_c_c (catan, plus_infty, -10.0, M_PI_2l, minus_zero);
1240   TEST_c_c (catan, minus_infty, -10.0, -M_PI_2l, minus_zero);
1241   TEST_c_c (catan, plus_infty, minus_zero, M_PI_2l, minus_zero);
1242   TEST_c_c (catan, minus_infty, minus_zero, -M_PI_2l, minus_zero);
1243   TEST_c_c (catan, plus_infty, 0.0, M_PI_2l, 0);
1244   TEST_c_c (catan, minus_infty, 0.0, -M_PI_2l, 0);
1245   TEST_c_c (catan, plus_infty, 0.1, M_PI_2l, 0);
1246   TEST_c_c (catan, minus_infty, 0.1, -M_PI_2l, 0);
1247
1248   TEST_c_c (catan, 0.0, minus_infty, M_PI_2l, minus_zero);
1249   TEST_c_c (catan, minus_zero, minus_infty, -M_PI_2l, minus_zero);
1250   TEST_c_c (catan, 100.0, minus_infty, M_PI_2l, minus_zero);
1251   TEST_c_c (catan, -100.0, minus_infty, -M_PI_2l, minus_zero);
1252
1253   TEST_c_c (catan, 0.0, plus_infty, M_PI_2l, 0);
1254   TEST_c_c (catan, minus_zero, plus_infty, -M_PI_2l, 0);
1255   TEST_c_c (catan, 0.5, plus_infty, M_PI_2l, 0);
1256   TEST_c_c (catan, -0.5, plus_infty, -M_PI_2l, 0);
1257
1258   TEST_c_c (catan, nan_value, 0.0, nan_value, 0);
1259   TEST_c_c (catan, nan_value, minus_zero, nan_value, minus_zero);
1260
1261   TEST_c_c (catan, nan_value, plus_infty, nan_value, 0);
1262   TEST_c_c (catan, nan_value, minus_infty, nan_value, minus_zero);
1263
1264   TEST_c_c (catan, 0.0, nan_value, nan_value, nan_value);
1265   TEST_c_c (catan, minus_zero, nan_value, nan_value, nan_value);
1266
1267   TEST_c_c (catan, plus_infty, nan_value, M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1268   TEST_c_c (catan, minus_infty, nan_value, -M_PI_2l, 0, IGNORE_ZERO_INF_SIGN);
1269
1270   TEST_c_c (catan, nan_value, 10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1271   TEST_c_c (catan, nan_value, -10.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1272
1273   TEST_c_c (catan, 0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1274   TEST_c_c (catan, -0.75, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1275
1276   TEST_c_c (catan, nan_value, nan_value, nan_value, nan_value);
1277
1278   TEST_c_c (catan, 0.7, 1.2, 1.0785743834118921877L, 0.5770573776534306764L);
1279
1280   TEST_c_c (catan, -2, -3, -1.4099210495965755225L, -0.2290726829685387662L);
1281
1282   END (catan, complex);
1283 }
1284
1285 static void
1286 catanh_test (void)
1287 {
1288   START (catanh);
1289
1290   TEST_c_c (catanh, 0, 0, 0.0, 0.0);
1291   TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0);
1292   TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero);
1293   TEST_c_c (catanh, minus_zero, minus_zero, minus_zero, minus_zero);
1294
1295   TEST_c_c (catanh, plus_infty, plus_infty, 0.0, M_PI_2l);
1296   TEST_c_c (catanh, plus_infty, minus_infty, 0.0, -M_PI_2l);
1297   TEST_c_c (catanh, minus_infty, plus_infty, minus_zero, M_PI_2l);
1298   TEST_c_c (catanh, minus_infty, minus_infty, minus_zero, -M_PI_2l);
1299
1300   TEST_c_c (catanh, -10.0, plus_infty, minus_zero, M_PI_2l);
1301   TEST_c_c (catanh, -10.0, minus_infty, minus_zero, -M_PI_2l);
1302   TEST_c_c (catanh, minus_zero, plus_infty, minus_zero, M_PI_2l);
1303   TEST_c_c (catanh, minus_zero, minus_infty, minus_zero, -M_PI_2l);
1304   TEST_c_c (catanh, 0, plus_infty, 0.0, M_PI_2l);
1305   TEST_c_c (catanh, 0, minus_infty, 0.0, -M_PI_2l);
1306   TEST_c_c (catanh, 0.1, plus_infty, 0.0, M_PI_2l);
1307   TEST_c_c (catanh, 0.1, minus_infty, 0.0, -M_PI_2l);
1308
1309   TEST_c_c (catanh, minus_infty, 0, minus_zero, M_PI_2l);
1310   TEST_c_c (catanh, minus_infty, minus_zero, minus_zero, -M_PI_2l);
1311   TEST_c_c (catanh, minus_infty, 100, minus_zero, M_PI_2l);
1312   TEST_c_c (catanh, minus_infty, -100, minus_zero, -M_PI_2l);
1313
1314   TEST_c_c (catanh, plus_infty, 0, 0.0, M_PI_2l);
1315   TEST_c_c (catanh, plus_infty, minus_zero, 0.0, -M_PI_2l);
1316   TEST_c_c (catanh, plus_infty, 0.5, 0.0, M_PI_2l);
1317   TEST_c_c (catanh, plus_infty, -0.5, 0.0, -M_PI_2l);
1318
1319   TEST_c_c (catanh, 0, nan_value, 0.0, nan_value);
1320   TEST_c_c (catanh, minus_zero, nan_value, minus_zero, nan_value);
1321
1322   TEST_c_c (catanh, plus_infty, nan_value, 0.0, nan_value);
1323   TEST_c_c (catanh, minus_infty, nan_value, minus_zero, nan_value);
1324
1325   TEST_c_c (catanh, nan_value, 0, nan_value, nan_value);
1326   TEST_c_c (catanh, nan_value, minus_zero, nan_value, nan_value);
1327
1328   TEST_c_c (catanh, nan_value, plus_infty, 0.0, M_PI_2l, IGNORE_ZERO_INF_SIGN);
1329   TEST_c_c (catanh, nan_value, minus_infty, 0.0, -M_PI_2l, IGNORE_ZERO_INF_SIGN);
1330
1331   TEST_c_c (catanh, 10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1332   TEST_c_c (catanh, -10.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1333
1334   TEST_c_c (catanh, nan_value, 0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1335   TEST_c_c (catanh, nan_value, -0.75, nan_value, nan_value, INVALID_EXCEPTION_OK);
1336
1337   TEST_c_c (catanh, nan_value, nan_value, nan_value, nan_value);
1338
1339   TEST_c_c (catanh, 0.7, 1.2, 0.2600749516525135959L, 0.9702403077950989849L);
1340   TEST_c_c (catanh, -2, -3, -0.1469466662255297520L, -1.3389725222944935611L);
1341
1342   END (catanh, complex);
1343 }
1344
1345 static void
1346 cbrt_test (void)
1347 {
1348   START (cbrt);
1349
1350   TEST_f_f (cbrt, 0.0, 0.0);
1351   TEST_f_f (cbrt, minus_zero, minus_zero);
1352
1353   TEST_f_f (cbrt, plus_infty, plus_infty);
1354   TEST_f_f (cbrt, minus_infty, minus_infty);
1355   TEST_f_f (cbrt, nan_value, nan_value);
1356
1357   TEST_f_f (cbrt, -0.001, -0.1);
1358   TEST_f_f (cbrt, 8, 2);
1359   TEST_f_f (cbrt, -27.0, -3.0);
1360   TEST_f_f (cbrt, 0.970299, 0.99);
1361   TEST_f_f (cbrt, 0.7, 0.8879040017426007084L);
1362
1363   END (cbrt);
1364 }
1365
1366 static void
1367 ccos_test (void)
1368 {
1369
1370   START (ccos);
1371
1372   TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero);
1373   TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0);
1374   TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0);
1375   TEST_c_c (ccos, minus_zero, minus_zero, 1.0, minus_zero);
1376
1377   TEST_c_c (ccos, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1378   TEST_c_c (ccos, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1379   TEST_c_c (ccos, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1380   TEST_c_c (ccos, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1381
1382   TEST_c_c (ccos, 0.0, plus_infty, plus_infty, minus_zero);
1383   TEST_c_c (ccos, 0.0, minus_infty, plus_infty, 0.0);
1384   TEST_c_c (ccos, minus_zero, plus_infty, plus_infty, 0.0);
1385   TEST_c_c (ccos, minus_zero, minus_infty, plus_infty, minus_zero);
1386
1387   TEST_c_c (ccos, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1388   TEST_c_c (ccos, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1389   TEST_c_c (ccos, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1390   TEST_c_c (ccos, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1391
1392   TEST_c_c (ccos, 4.625, plus_infty, minus_infty, plus_infty);
1393   TEST_c_c (ccos, 4.625, minus_infty, minus_infty, minus_infty);
1394   TEST_c_c (ccos, -4.625, plus_infty, minus_infty, minus_infty);
1395   TEST_c_c (ccos, -4.625, minus_infty, minus_infty, plus_infty);
1396
1397   TEST_c_c (ccos, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1398   TEST_c_c (ccos, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1399   TEST_c_c (ccos, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1400   TEST_c_c (ccos, minus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1401
1402   TEST_c_c (ccos, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1403   TEST_c_c (ccos, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1404
1405   TEST_c_c (ccos, nan_value, plus_infty, plus_infty, nan_value);
1406   TEST_c_c (ccos, nan_value, minus_infty, plus_infty, nan_value);
1407
1408   TEST_c_c (ccos, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1409   TEST_c_c (ccos, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1410
1411   TEST_c_c (ccos, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1412   TEST_c_c (ccos, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1413
1414   TEST_c_c (ccos, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1415   TEST_c_c (ccos, -10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1416
1417   TEST_c_c (ccos, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1418   TEST_c_c (ccos, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1419
1420   TEST_c_c (ccos, nan_value, nan_value, nan_value, nan_value);
1421
1422   TEST_c_c (ccos, 0.7, 1.2, 1.3848657645312111080L, -0.97242170335830028619L);
1423
1424   TEST_c_c (ccos, -2, -3, -4.1896256909688072301L, -9.1092278937553365979L);
1425
1426   END (ccos, complex);
1427 }
1428
1429
1430 static void
1431 ccosh_test (void)
1432 {
1433
1434   START (ccosh);
1435
1436   TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0);
1437   TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero);
1438   TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero);
1439   TEST_c_c (ccosh, minus_zero, minus_zero, 1.0, 0.0);
1440
1441   TEST_c_c (ccosh, 0.0, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1442   TEST_c_c (ccosh, minus_zero, plus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1443   TEST_c_c (ccosh, 0.0, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1444   TEST_c_c (ccosh, minus_zero, minus_infty, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1445
1446   TEST_c_c (ccosh, plus_infty, 0.0, plus_infty, 0.0);
1447   TEST_c_c (ccosh, minus_infty, 0.0, plus_infty, minus_zero);
1448   TEST_c_c (ccosh, plus_infty, minus_zero, plus_infty, minus_zero);
1449   TEST_c_c (ccosh, minus_infty, minus_zero, plus_infty, 0.0);
1450
1451   TEST_c_c (ccosh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1452   TEST_c_c (ccosh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1453   TEST_c_c (ccosh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1454   TEST_c_c (ccosh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
1455
1456   TEST_c_c (ccosh, plus_infty, 4.625, minus_infty, minus_infty);
1457   TEST_c_c (ccosh, minus_infty, 4.625, minus_infty, plus_infty);
1458   TEST_c_c (ccosh, plus_infty, -4.625, minus_infty, plus_infty);
1459   TEST_c_c (ccosh, minus_infty, -4.625, minus_infty, minus_infty);
1460
1461   TEST_c_c (ccosh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1462   TEST_c_c (ccosh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1463   TEST_c_c (ccosh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1464   TEST_c_c (ccosh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1465
1466   TEST_c_c (ccosh, 0.0, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1467   TEST_c_c (ccosh, minus_zero, nan_value, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1468
1469   TEST_c_c (ccosh, plus_infty, nan_value, plus_infty, nan_value);
1470   TEST_c_c (ccosh, minus_infty, nan_value, plus_infty, nan_value);
1471
1472   TEST_c_c (ccosh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1473   TEST_c_c (ccosh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1474
1475   TEST_c_c (ccosh, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1476   TEST_c_c (ccosh, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1477
1478   TEST_c_c (ccosh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1479   TEST_c_c (ccosh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1480
1481   TEST_c_c (ccosh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1482   TEST_c_c (ccosh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1483
1484   TEST_c_c (ccosh, nan_value, nan_value, nan_value, nan_value);
1485
1486   TEST_c_c (ccosh, 0.7, 1.2, 0.4548202223691477654L, 0.7070296600921537682L);
1487
1488   TEST_c_c (ccosh, -2, -3, -3.7245455049153225654L, 0.5118225699873846088L);
1489
1490   END (ccosh, complex);
1491 }
1492
1493
1494 static void
1495 ceil_test (void)
1496 {
1497   START (ceil);
1498
1499   TEST_f_f (ceil, 0.0, 0.0);
1500   TEST_f_f (ceil, minus_zero, minus_zero);
1501   TEST_f_f (ceil, plus_infty, plus_infty);
1502   TEST_f_f (ceil, minus_infty, minus_infty);
1503   TEST_f_f (ceil, nan_value, nan_value);
1504
1505   TEST_f_f (ceil, M_PIl, 4.0);
1506   TEST_f_f (ceil, -M_PIl, -3.0);
1507
1508   END (ceil);
1509 }
1510
1511
1512 static void
1513 cexp_test (void)
1514 {
1515   START (cexp);
1516
1517   TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0);
1518   TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0);
1519   TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero);
1520   TEST_c_c (cexp, minus_zero, minus_zero, 1, minus_zero);
1521
1522   TEST_c_c (cexp, plus_infty, plus_zero, plus_infty, 0.0);
1523   TEST_c_c (cexp, plus_infty, minus_zero, plus_infty, minus_zero);
1524
1525   TEST_c_c (cexp, minus_infty, plus_zero, 0.0, 0.0);
1526   TEST_c_c (cexp, minus_infty, minus_zero, 0.0, minus_zero);
1527
1528   TEST_c_c (cexp, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1529   TEST_c_c (cexp, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1530
1531   TEST_c_c (cexp, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1532   TEST_c_c (cexp, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1533
1534   TEST_c_c (cexp, 100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1535   TEST_c_c (cexp, -100.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1536
1537   TEST_c_c (cexp, 100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1538   TEST_c_c (cexp, -100.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1539
1540   TEST_c_c (cexp, minus_infty, 2.0, minus_zero, 0.0);
1541   TEST_c_c (cexp, minus_infty, 4.0, minus_zero, minus_zero);
1542   TEST_c_c (cexp, plus_infty, 2.0, minus_infty, plus_infty);
1543   TEST_c_c (cexp, plus_infty, 4.0, minus_infty, minus_infty);
1544
1545   TEST_c_c (cexp, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1546   TEST_c_c (cexp, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1547
1548   TEST_c_c (cexp, minus_infty, plus_infty, 0.0, 0.0, IGNORE_ZERO_INF_SIGN);
1549   TEST_c_c (cexp, minus_infty, minus_infty, 0.0, minus_zero, IGNORE_ZERO_INF_SIGN);
1550
1551   TEST_c_c (cexp, minus_infty, nan_value, 0, 0, IGNORE_ZERO_INF_SIGN);
1552
1553   TEST_c_c (cexp, plus_infty, nan_value, plus_infty, nan_value);
1554
1555   TEST_c_c (cexp, nan_value, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1556   TEST_c_c (cexp, nan_value, 1.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1557
1558   TEST_c_c (cexp, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1559   TEST_c_c (cexp, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1560   TEST_c_c (cexp, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1561   TEST_c_c (cexp, nan_value, nan_value, nan_value, nan_value);
1562
1563   TEST_c_c (cexp, 0.7, 1.2, 0.7296989091503236012L, 1.8768962328348102821L);
1564   TEST_c_c (cexp, -2.0, -3.0, -0.1339809149295426134L, -0.0190985162611351964L);
1565
1566   END (cexp, complex);
1567 }
1568
1569 static void
1570 cimag_test (void)
1571 {
1572   START (cimag);
1573   TEST_c_f (cimag, 1.0, 0.0, 0.0);
1574   TEST_c_f (cimag, 1.0, minus_zero, minus_zero);
1575   TEST_c_f (cimag, 1.0, nan_value, nan_value);
1576   TEST_c_f (cimag, nan_value, nan_value, nan_value);
1577   TEST_c_f (cimag, 1.0, plus_infty, plus_infty);
1578   TEST_c_f (cimag, 1.0, minus_infty, minus_infty);
1579   TEST_c_f (cimag, 2.0, 3.0, 3.0);
1580
1581   END (cimag);
1582 }
1583
1584 static void
1585 clog_test (void)
1586 {
1587   START (clog);
1588
1589   TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1590   TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1591
1592   TEST_c_c (clog, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1593   TEST_c_c (clog, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1594
1595   TEST_c_c (clog, minus_infty, plus_infty, plus_infty, M_PI_34l);
1596   TEST_c_c (clog, minus_infty, minus_infty, plus_infty, -M_PI_34l);
1597
1598   TEST_c_c (clog, plus_infty, plus_infty, plus_infty, M_PI_4l);
1599   TEST_c_c (clog, plus_infty, minus_infty, plus_infty, -M_PI_4l);
1600
1601   TEST_c_c (clog, 0, plus_infty, plus_infty, M_PI_2l);
1602   TEST_c_c (clog, 3, plus_infty, plus_infty, M_PI_2l);
1603   TEST_c_c (clog, minus_zero, plus_infty, plus_infty, M_PI_2l);
1604   TEST_c_c (clog, -3, plus_infty, plus_infty, M_PI_2l);
1605   TEST_c_c (clog, 0, minus_infty, plus_infty, -M_PI_2l);
1606   TEST_c_c (clog, 3, minus_infty, plus_infty, -M_PI_2l);
1607   TEST_c_c (clog, minus_zero, minus_infty, plus_infty, -M_PI_2l);
1608   TEST_c_c (clog, -3, minus_infty, plus_infty, -M_PI_2l);
1609
1610   TEST_c_c (clog, minus_infty, 0, plus_infty, M_PIl);
1611   TEST_c_c (clog, minus_infty, 1, plus_infty, M_PIl);
1612   TEST_c_c (clog, minus_infty, minus_zero, plus_infty, -M_PIl);
1613   TEST_c_c (clog, minus_infty, -1, plus_infty, -M_PIl);
1614
1615   TEST_c_c (clog, plus_infty, 0, plus_infty, 0.0);
1616   TEST_c_c (clog, plus_infty, 1, plus_infty, 0.0);
1617   TEST_c_c (clog, plus_infty, minus_zero, plus_infty, minus_zero);
1618   TEST_c_c (clog, plus_infty, -1, plus_infty, minus_zero);
1619
1620   TEST_c_c (clog, plus_infty, nan_value, plus_infty, nan_value);
1621   TEST_c_c (clog, minus_infty, nan_value, plus_infty, nan_value);
1622
1623   TEST_c_c (clog, nan_value, plus_infty, plus_infty, nan_value);
1624   TEST_c_c (clog, nan_value, minus_infty, plus_infty, nan_value);
1625
1626   TEST_c_c (clog, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1627   TEST_c_c (clog, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1628   TEST_c_c (clog, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1629   TEST_c_c (clog, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1630
1631   TEST_c_c (clog, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1632   TEST_c_c (clog, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1633   TEST_c_c (clog, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1634   TEST_c_c (clog, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1635
1636   TEST_c_c (clog, nan_value, nan_value, nan_value, nan_value);
1637   TEST_c_c (clog, -2, -3, 1.2824746787307683680L, -2.1587989303424641704L);
1638
1639   END (clog, complex);
1640 }
1641
1642
1643 static void
1644 clog10_test (void)
1645 {
1646   START (clog10);
1647
1648   TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1649   TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION);
1650
1651   TEST_c_c (clog10, 0, 0, minus_infty, 0.0, DIVIDE_BY_ZERO_EXCEPTION);
1652   TEST_c_c (clog10, 0, minus_zero, minus_infty, minus_zero, DIVIDE_BY_ZERO_EXCEPTION);
1653
1654   TEST_c_c (clog10, minus_infty, plus_infty, plus_infty, M_PI_34_LOG10El);
1655
1656   TEST_c_c (clog10, plus_infty, plus_infty, plus_infty, M_PI4_LOG10El);
1657   TEST_c_c (clog10, plus_infty, minus_infty, plus_infty, -M_PI4_LOG10El);
1658
1659   TEST_c_c (clog10, 0, plus_infty, plus_infty, M_PI2_LOG10El);
1660   TEST_c_c (clog10, 3, plus_infty, plus_infty, M_PI2_LOG10El);
1661   TEST_c_c (clog10, minus_zero, plus_infty, plus_infty, M_PI2_LOG10El);
1662   TEST_c_c (clog10, -3, plus_infty, plus_infty, M_PI2_LOG10El);
1663   TEST_c_c (clog10, 0, minus_infty, plus_infty, -M_PI2_LOG10El);
1664   TEST_c_c (clog10, 3, minus_infty, plus_infty, -M_PI2_LOG10El);
1665   TEST_c_c (clog10, minus_zero, minus_infty, plus_infty, -M_PI2_LOG10El);
1666   TEST_c_c (clog10, -3, minus_infty, plus_infty, -M_PI2_LOG10El);
1667
1668   TEST_c_c (clog10, minus_infty, 0, plus_infty, M_PI_LOG10El);
1669   TEST_c_c (clog10, minus_infty, 1, plus_infty, M_PI_LOG10El);
1670   TEST_c_c (clog10, minus_infty, minus_zero, plus_infty, -M_PI_LOG10El);
1671   TEST_c_c (clog10, minus_infty, -1, plus_infty, -M_PI_LOG10El);
1672
1673   TEST_c_c (clog10, plus_infty, 0, plus_infty, 0.0);
1674   TEST_c_c (clog10, plus_infty, 1, plus_infty, 0.0);
1675   TEST_c_c (clog10, plus_infty, minus_zero, plus_infty, minus_zero);
1676   TEST_c_c (clog10, plus_infty, -1, plus_infty, minus_zero);
1677
1678   TEST_c_c (clog10, plus_infty, nan_value, plus_infty, nan_value);
1679   TEST_c_c (clog10, minus_infty, nan_value, plus_infty, nan_value);
1680
1681   TEST_c_c (clog10, nan_value, plus_infty, plus_infty, nan_value);
1682   TEST_c_c (clog10, nan_value, minus_infty, plus_infty, nan_value);
1683
1684   TEST_c_c (clog10, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1685   TEST_c_c (clog10, 3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1686   TEST_c_c (clog10, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1687   TEST_c_c (clog10, -3, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1688
1689   TEST_c_c (clog10, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1690   TEST_c_c (clog10, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1691   TEST_c_c (clog10, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
1692   TEST_c_c (clog10, nan_value, -5, nan_value, nan_value, INVALID_EXCEPTION_OK);
1693
1694   TEST_c_c (clog10, nan_value, nan_value, nan_value, nan_value);
1695
1696   TEST_c_c (clog10, 0.7, 1.2, 0.1427786545038868803L, 0.4528483579352493248L);
1697   TEST_c_c (clog10, -2, -3, 0.5569716761534183846L, -0.9375544629863747085L);
1698
1699   END (clog10, complex);
1700 }
1701
1702 static void
1703 conj_test (void)
1704 {
1705   START (conj);
1706   TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero);
1707   TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0);
1708   TEST_c_c (conj, nan_value, nan_value, nan_value, nan_value);
1709   TEST_c_c (conj, plus_infty, minus_infty, plus_infty, plus_infty);
1710   TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty);
1711   TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0);
1712   TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0);
1713
1714   END (conj, complex);
1715 }
1716
1717
1718 static void
1719 copysign_test (void)
1720 {
1721   START (copysign);
1722
1723   TEST_ff_f (copysign, 0, 4, 0);
1724   TEST_ff_f (copysign, 0, -4, minus_zero);
1725   TEST_ff_f (copysign, minus_zero, 4, 0);
1726   TEST_ff_f (copysign, minus_zero, -4, minus_zero);
1727
1728   TEST_ff_f (copysign, plus_infty, 0, plus_infty);
1729   TEST_ff_f (copysign, plus_infty, minus_zero, minus_infty);
1730   TEST_ff_f (copysign, minus_infty, 0, plus_infty);
1731   TEST_ff_f (copysign, minus_infty, minus_zero, minus_infty);
1732
1733   TEST_ff_f (copysign, 0, plus_infty, 0);
1734   TEST_ff_f (copysign, 0, minus_zero, minus_zero);
1735   TEST_ff_f (copysign, minus_zero, plus_infty, 0);
1736   TEST_ff_f (copysign, minus_zero, minus_zero, minus_zero);
1737
1738   /* XXX More correctly we would have to check the sign of the NaN.  */
1739   TEST_ff_f (copysign, nan_value, 0, nan_value);
1740   TEST_ff_f (copysign, nan_value, minus_zero, nan_value);
1741   TEST_ff_f (copysign, -nan_value, 0, nan_value);
1742   TEST_ff_f (copysign, -nan_value, minus_zero, nan_value);
1743
1744   END (copysign);
1745 }
1746
1747 static void
1748 cos_test (void)
1749 {
1750   START (cos);
1751
1752   TEST_f_f (cos, 0, 1);
1753   TEST_f_f (cos, minus_zero, 1);
1754   TEST_f_f (cos, plus_infty, nan_value, INVALID_EXCEPTION);
1755   TEST_f_f (cos, minus_infty, nan_value, INVALID_EXCEPTION);
1756   TEST_f_f (cos, nan_value, nan_value);
1757
1758   TEST_f_f (cos, M_PI_6l * 2.0, 0.5);
1759   TEST_f_f (cos, M_PI_6l * 4.0, -0.5);
1760   TEST_f_f (cos, M_PI_2l, 0);
1761
1762   TEST_f_f (cos, 0.7, 0.7648421872844884262L);
1763
1764   END (cos);
1765 }
1766
1767 static void
1768 cosh_test (void)
1769 {
1770   START (cosh);
1771   TEST_f_f (cosh, 0, 1);
1772   TEST_f_f (cosh, minus_zero, 1);
1773
1774 #ifndef TEST_INLINE
1775   TEST_f_f (cosh, plus_infty, plus_infty);
1776   TEST_f_f (cosh, minus_infty, plus_infty);
1777 #endif
1778   TEST_f_f (cosh, nan_value, nan_value);
1779
1780   TEST_f_f (cosh, 0.7, 1.255169005630943018L);
1781   END (cosh);
1782 }
1783
1784
1785 static void
1786 cpow_test (void)
1787 {
1788   START (cpow);
1789
1790   TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0);
1791   TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0);
1792
1793   TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0);
1794   TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0);
1795
1796   TEST_cc_c (cpow, nan_value, nan_value, nan_value, nan_value, nan_value, nan_value);
1797
1798   END (cpow, complex);
1799 }
1800
1801 static void
1802 cproj_test (void)
1803 {
1804   START (cproj);
1805   TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0);
1806   TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero);
1807   TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero);
1808   TEST_c_c (cproj, minus_zero, 0.0, minus_zero, 0.0);
1809
1810   TEST_c_c (cproj, nan_value, nan_value, nan_value, nan_value);
1811
1812   TEST_c_c (cproj, plus_infty, plus_infty, plus_infty, 0.0);
1813   TEST_c_c (cproj, plus_infty, minus_infty, plus_infty, minus_zero);
1814   TEST_c_c (cproj, minus_infty, plus_infty, plus_infty, 0.0);
1815   TEST_c_c (cproj, minus_infty, minus_infty, plus_infty, minus_zero);
1816
1817   TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0);
1818   TEST_c_c (cproj, 2.0, 3.0, 0.28571428571428571429L, .42857142857142857143L);
1819
1820   END (cproj, complex);
1821 }
1822
1823 static void
1824 creal_test (void)
1825 {
1826   START (creal);
1827   TEST_c_f (creal, 0.0, 1.0, 0.0);
1828   TEST_c_f (creal, minus_zero, 1.0, minus_zero);
1829   TEST_c_f (creal, nan_value, 1.0, nan_value);
1830   TEST_c_f (creal, nan_value, nan_value, nan_value);
1831   TEST_c_f (creal, plus_infty, 1.0, plus_infty);
1832   TEST_c_f (creal, minus_infty, 1.0, minus_infty);
1833   TEST_c_f (creal, 2.0, 3.0, 2.0);
1834
1835   END (creal);
1836 }
1837
1838 static void
1839 csin_test (void)
1840 {
1841
1842   START (csin);
1843
1844   TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0);
1845   TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0);
1846   TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero);
1847   TEST_c_c (csin, minus_zero, minus_zero, minus_zero, minus_zero);
1848
1849   TEST_c_c (csin, 0.0, plus_infty, 0.0, plus_infty);
1850   TEST_c_c (csin, minus_zero, plus_infty, minus_zero, plus_infty);
1851   TEST_c_c (csin, 0.0, minus_infty, 0.0, minus_infty);
1852   TEST_c_c (csin, minus_zero, minus_infty, minus_zero, minus_infty);
1853
1854   TEST_c_c (csin, plus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1855   TEST_c_c (csin, minus_infty, 0.0, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1856   TEST_c_c (csin, plus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1857   TEST_c_c (csin, minus_infty, minus_zero, nan_value, 0.0, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1858
1859   TEST_c_c (csin, plus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1860   TEST_c_c (csin, minus_infty, plus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1861   TEST_c_c (csin, plus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1862   TEST_c_c (csin, minus_infty, minus_infty, nan_value, plus_infty, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1863
1864   TEST_c_c (csin, plus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1865   TEST_c_c (csin, plus_infty, -6.75, nan_value, nan_value, INVALID_EXCEPTION);
1866   TEST_c_c (csin, minus_infty, 6.75, nan_value, nan_value, INVALID_EXCEPTION);
1867   TEST_c_c (csin, minus_infty, -6.75,  nan_value, nan_value, INVALID_EXCEPTION);
1868
1869   TEST_c_c (csin, 4.625, plus_infty, minus_infty, minus_infty);
1870   TEST_c_c (csin, 4.625, minus_infty, minus_infty, plus_infty);
1871   TEST_c_c (csin, -4.625, plus_infty, plus_infty, minus_infty);
1872   TEST_c_c (csin, -4.625, minus_infty, plus_infty, plus_infty);
1873
1874   TEST_c_c (csin, nan_value, 0.0, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1875   TEST_c_c (csin, nan_value, minus_zero, nan_value, 0.0, IGNORE_ZERO_INF_SIGN);
1876
1877   TEST_c_c (csin, nan_value, plus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1878   TEST_c_c (csin, nan_value, minus_infty, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1879
1880   TEST_c_c (csin, nan_value, 9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1881   TEST_c_c (csin, nan_value, -9.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1882
1883   TEST_c_c (csin, 0.0, nan_value, 0.0, nan_value);
1884   TEST_c_c (csin, minus_zero, nan_value, minus_zero, nan_value);
1885
1886   TEST_c_c (csin, 10.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1887   TEST_c_c (csin, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1888
1889   TEST_c_c (csin, plus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1890   TEST_c_c (csin, minus_infty, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
1891
1892   TEST_c_c (csin, nan_value, nan_value, nan_value, nan_value);
1893
1894   TEST_c_c (csin, 0.7, 1.2, 1.1664563419657581376L, 1.1544997246948547371L);
1895
1896   TEST_c_c (csin, -2, -3, -9.1544991469114295734L, 4.1689069599665643507L);
1897
1898   END (csin, complex);
1899 }
1900
1901
1902 static void
1903 csinh_test (void)
1904 {
1905
1906   START (csinh);
1907
1908   TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0);
1909   TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0);
1910   TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero);
1911   TEST_c_c (csinh, minus_zero, minus_zero, minus_zero, minus_zero);
1912
1913   TEST_c_c (csinh, 0.0, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1914   TEST_c_c (csinh, minus_zero, plus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1915   TEST_c_c (csinh, 0.0, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1916   TEST_c_c (csinh, minus_zero, minus_infty, 0.0, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1917
1918   TEST_c_c (csinh, plus_infty, 0.0, plus_infty, 0.0);
1919   TEST_c_c (csinh, minus_infty, 0.0, minus_infty, 0.0);
1920   TEST_c_c (csinh, plus_infty, minus_zero, plus_infty, minus_zero);
1921   TEST_c_c (csinh, minus_infty, minus_zero, minus_infty, minus_zero);
1922
1923   TEST_c_c (csinh, plus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1924   TEST_c_c (csinh, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1925   TEST_c_c (csinh, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1926   TEST_c_c (csinh, minus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION|IGNORE_ZERO_INF_SIGN);
1927
1928   TEST_c_c (csinh, plus_infty, 4.625, minus_infty, minus_infty);
1929   TEST_c_c (csinh, minus_infty, 4.625, plus_infty, minus_infty);
1930   TEST_c_c (csinh, plus_infty, -4.625, minus_infty, plus_infty);
1931   TEST_c_c (csinh, minus_infty, -4.625, plus_infty, plus_infty);
1932
1933   TEST_c_c (csinh, 6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1934   TEST_c_c (csinh, -6.75, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1935   TEST_c_c (csinh, 6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1936   TEST_c_c (csinh, -6.75, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
1937
1938   TEST_c_c (csinh, 0.0, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
1939   TEST_c_c (csinh, minus_zero, nan_value, 0.0, nan_value, IGNORE_ZERO_INF_SIGN);
1940
1941   TEST_c_c (csinh, plus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1942   TEST_c_c (csinh, minus_infty, nan_value, plus_infty, nan_value, IGNORE_ZERO_INF_SIGN);
1943
1944   TEST_c_c (csinh, 9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
1945   TEST_c_c (csinh, -9.0, nan_value, nan_value, nan_value, INVALID_EXCEPTION);
1946
1947   TEST_c_c (csinh, nan_value, 0.0, nan_value, 0.0);
1948   TEST_c_c (csinh, nan_value, minus_zero, nan_value, minus_zero);
1949
1950   TEST_c_c (csinh, nan_value, 10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1951   TEST_c_c (csinh, nan_value, -10.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
1952
1953   TEST_c_c (csinh, nan_value, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1954   TEST_c_c (csinh, nan_value, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
1955
1956   TEST_c_c (csinh, nan_value, nan_value, nan_value, nan_value);
1957
1958   TEST_c_c (csinh, 0.7, 1.2, 0.27487868678117583582L, 1.1698665727426565139L);
1959   TEST_c_c (csinh, -2, -3, 3.5905645899857799520L, -0.5309210862485198052L);
1960
1961   END (csinh, complex);
1962 }
1963
1964 static void
1965 csqrt_test (void)
1966 {
1967   START (csqrt);
1968
1969   TEST_c_c (csqrt, 0, 0, 0.0, 0.0);
1970   TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero);
1971   TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0);
1972   TEST_c_c (csqrt, minus_zero, minus_zero, 0.0, minus_zero);
1973
1974   TEST_c_c (csqrt, minus_infty, 0, 0.0, plus_infty);
1975   TEST_c_c (csqrt, minus_infty, 6, 0.0, plus_infty);
1976   TEST_c_c (csqrt, minus_infty, minus_zero, 0.0, minus_infty);
1977   TEST_c_c (csqrt, minus_infty, -6, 0.0, minus_infty);
1978
1979   TEST_c_c (csqrt, plus_infty, 0, plus_infty, 0.0);
1980   TEST_c_c (csqrt, plus_infty, 6, plus_infty, 0.0);
1981   TEST_c_c (csqrt, plus_infty, minus_zero, plus_infty, minus_zero);
1982   TEST_c_c (csqrt, plus_infty, -6, plus_infty, minus_zero);
1983
1984   TEST_c_c (csqrt, 0, plus_infty, plus_infty, plus_infty);
1985   TEST_c_c (csqrt, 4, plus_infty, plus_infty, plus_infty);
1986   TEST_c_c (csqrt, plus_infty, plus_infty, plus_infty, plus_infty);
1987   TEST_c_c (csqrt, minus_zero, plus_infty, plus_infty, plus_infty);
1988   TEST_c_c (csqrt, -4, plus_infty, plus_infty, plus_infty);
1989   TEST_c_c (csqrt, minus_infty, plus_infty, plus_infty, plus_infty);
1990   TEST_c_c (csqrt, 0, minus_infty, plus_infty, minus_infty);
1991   TEST_c_c (csqrt, 4, minus_infty, plus_infty, minus_infty);
1992   TEST_c_c (csqrt, plus_infty, minus_infty, plus_infty, minus_infty);
1993   TEST_c_c (csqrt, minus_zero, minus_infty, plus_infty, minus_infty);
1994   TEST_c_c (csqrt, -4, minus_infty, plus_infty, minus_infty);
1995   TEST_c_c (csqrt, minus_infty, minus_infty, plus_infty, minus_infty);
1996
1997   TEST_c_c (csqrt, minus_infty, nan_value, nan_value, plus_infty, IGNORE_ZERO_INF_SIGN);
1998
1999   TEST_c_c (csqrt, plus_infty, nan_value, plus_infty, nan_value);
2000
2001   TEST_c_c (csqrt, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2002   TEST_c_c (csqrt, 1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2003   TEST_c_c (csqrt, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2004   TEST_c_c (csqrt, -1, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2005
2006   TEST_c_c (csqrt, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2007   TEST_c_c (csqrt, nan_value, 8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2008   TEST_c_c (csqrt, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2009   TEST_c_c (csqrt, nan_value, -8, nan_value, nan_value, INVALID_EXCEPTION_OK);
2010
2011   TEST_c_c (csqrt, nan_value, nan_value, nan_value, nan_value);
2012
2013   TEST_c_c (csqrt, 16.0, -30.0, 5.0, -3.0);
2014   TEST_c_c (csqrt, -1, 0, 0.0, 1.0);
2015   TEST_c_c (csqrt, 0, 2, 1.0, 1.0);
2016   TEST_c_c (csqrt, 119, 120, 12.0, 5.0);
2017   TEST_c_c (csqrt, 0.7, 1.2, 1.0220676100300264507L, 0.5870453129635652115L);
2018   TEST_c_c (csqrt, -2, -3, 0.8959774761298381247L, -1.6741492280355400404L);
2019   TEST_c_c (csqrt, -2, 3, 0.8959774761298381247L, 1.6741492280355400404L);
2020
2021   END (csqrt, complex);
2022 }
2023
2024 static void
2025 ctan_test (void)
2026 {
2027   START (ctan);
2028
2029   TEST_c_c (ctan, 0, 0, 0.0, 0.0);
2030   TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero);
2031   TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0);
2032   TEST_c_c (ctan, minus_zero, minus_zero, minus_zero, minus_zero);
2033
2034   TEST_c_c (ctan, 0, plus_infty, 0.0, 1.0);
2035   TEST_c_c (ctan, 1, plus_infty, 0.0, 1.0);
2036   TEST_c_c (ctan, minus_zero, plus_infty, minus_zero, 1.0);
2037   TEST_c_c (ctan, -1, plus_infty, minus_zero, 1.0);
2038
2039   TEST_c_c (ctan, 0, minus_infty, 0.0, -1.0);
2040   TEST_c_c (ctan, 1, minus_infty, 0.0, -1.0);
2041   TEST_c_c (ctan, minus_zero, minus_infty, minus_zero, -1.0);
2042   TEST_c_c (ctan, -1, minus_infty, minus_zero, -1.0);
2043
2044   TEST_c_c (ctan, plus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2045   TEST_c_c (ctan, plus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2046   TEST_c_c (ctan, minus_infty, 0, nan_value, nan_value, INVALID_EXCEPTION);
2047   TEST_c_c (ctan, minus_infty, 2, nan_value, nan_value, INVALID_EXCEPTION);
2048   TEST_c_c (ctan, plus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2049   TEST_c_c (ctan, plus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2050   TEST_c_c (ctan, minus_infty, minus_zero, nan_value, nan_value, INVALID_EXCEPTION);
2051   TEST_c_c (ctan, minus_infty, -2, nan_value, nan_value, INVALID_EXCEPTION);
2052
2053   TEST_c_c (ctan, nan_value, plus_infty, 0.0, 1.0, IGNORE_ZERO_INF_SIGN);
2054   TEST_c_c (ctan, nan_value, minus_infty, 0.0, -1.0, IGNORE_ZERO_INF_SIGN);
2055
2056   TEST_c_c (ctan, 0, nan_value, 0.0, nan_value);
2057   TEST_c_c (ctan, minus_zero, nan_value, minus_zero, nan_value);
2058
2059   TEST_c_c (ctan, 0.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2060   TEST_c_c (ctan, -4.5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2061
2062   TEST_c_c (ctan, nan_value, 0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2063   TEST_c_c (ctan, nan_value, 5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2064   TEST_c_c (ctan, nan_value, minus_zero, nan_value, nan_value, INVALID_EXCEPTION_OK);
2065   TEST_c_c (ctan, nan_value, -0.25, nan_value, nan_value, INVALID_EXCEPTION_OK);
2066
2067   TEST_c_c (ctan, nan_value, nan_value, nan_value, nan_value);
2068
2069   TEST_c_c (ctan, 0.7, 1.2, 0.1720734197630349001L, 0.9544807059989405538L);
2070   TEST_c_c (ctan, -2, -3, 0.0037640256415042482L, -1.0032386273536098014L);
2071
2072   END (ctan, complex);
2073 }
2074
2075
2076 static void
2077 ctanh_test (void)
2078 {
2079   START (ctanh);
2080
2081   TEST_c_c (ctanh, 0, 0, 0.0, 0.0);
2082   TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero);
2083   TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0);
2084   TEST_c_c (ctanh, minus_zero, minus_zero, minus_zero, minus_zero);
2085
2086   TEST_c_c (ctanh, plus_infty, 0, 1.0, 0.0);
2087   TEST_c_c (ctanh, plus_infty, 1, 1.0, 0.0);
2088   TEST_c_c (ctanh, plus_infty, minus_zero, 1.0, minus_zero);
2089   TEST_c_c (ctanh, plus_infty, -1, 1.0, minus_zero);
2090   TEST_c_c (ctanh, minus_infty, 0, -1.0, 0.0);
2091   TEST_c_c (ctanh, minus_infty, 1, -1.0, 0.0);
2092   TEST_c_c (ctanh, minus_infty, minus_zero, -1.0, minus_zero);
2093   TEST_c_c (ctanh, minus_infty, -1, -1.0, minus_zero);
2094
2095   TEST_c_c (ctanh, 0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2096   TEST_c_c (ctanh, 2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2097   TEST_c_c (ctanh, 0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2098   TEST_c_c (ctanh, 2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2099   TEST_c_c (ctanh, minus_zero, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2100   TEST_c_c (ctanh, -2, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2101   TEST_c_c (ctanh, minus_zero, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2102   TEST_c_c (ctanh, -2, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
2103
2104   TEST_c_c (ctanh, plus_infty, nan_value, 1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2105   TEST_c_c (ctanh, minus_infty, nan_value, -1.0, 0.0, IGNORE_ZERO_INF_SIGN);
2106
2107   TEST_c_c (ctanh, nan_value, 0, nan_value, 0.0);
2108   TEST_c_c (ctanh, nan_value, minus_zero, nan_value, minus_zero);
2109
2110   TEST_c_c (ctanh, nan_value, 0.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2111   TEST_c_c (ctanh, nan_value, -4.5, nan_value, nan_value, INVALID_EXCEPTION_OK);
2112
2113   TEST_c_c (ctanh, 0, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2114   TEST_c_c (ctanh, 5, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2115   TEST_c_c (ctanh, minus_zero, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2116   TEST_c_c (ctanh, -0.25, nan_value, nan_value, nan_value, INVALID_EXCEPTION_OK);
2117
2118   TEST_c_c (ctanh, nan_value, nan_value, nan_value, nan_value);
2119
2120   TEST_c_c (ctanh, 0, M_PI_4l, 0.0, 1.0);
2121
2122   TEST_c_c (ctanh, 0.7, 1.2, 1.3472197399061191630L, 0.4778641038326365540L);
2123   TEST_c_c (ctanh, -2, -3, -0.9653858790221331242L, 0.0098843750383224937L);
2124
2125   END (ctanh, complex);
2126 }
2127
2128 static void
2129 erf_test (void)
2130 {
2131   errno = 0;
2132   FUNC(erf) (0);
2133   if (errno == ENOSYS)
2134     /* Function not implemented.  */
2135     return;
2136
2137   START (erf);
2138
2139   TEST_f_f (erf, 0, 0);
2140   TEST_f_f (erf, minus_zero, minus_zero);
2141   TEST_f_f (erf, plus_infty, 1);
2142   TEST_f_f (erf, minus_infty, -1);
2143   TEST_f_f (erf, nan_value, nan_value);
2144
2145   TEST_f_f (erf, 0.7, 0.67780119383741847297L);
2146
2147   TEST_f_f (erf, 1.2, 0.91031397822963538024L);
2148   TEST_f_f (erf, 2.0, 0.99532226501895273416L);
2149   TEST_f_f (erf, 4.1, 0.99999999329997234592L);
2150   TEST_f_f (erf, 27, 1.0L);
2151
2152   END (erf);
2153 }
2154
2155
2156 static void
2157 erfc_test (void)
2158 {
2159   errno = 0;
2160   FUNC(erfc) (0);
2161   if (errno == ENOSYS)
2162     /* Function not implemented.  */
2163     return;
2164
2165   START (erfc);
2166
2167   TEST_f_f (erfc, plus_infty, 0.0);
2168   TEST_f_f (erfc, minus_infty, 2.0);
2169   TEST_f_f (erfc, 0.0, 1.0);
2170   TEST_f_f (erfc, minus_zero, 1.0);
2171   TEST_f_f (erfc, nan_value, nan_value);
2172
2173   TEST_f_f (erfc, 0.7, 0.32219880616258152702L);
2174
2175   TEST_f_f (erfc, 1.2, 0.089686021770364619762L);
2176   TEST_f_f (erfc, 2.0, 0.0046777349810472658379L);
2177   TEST_f_f (erfc, 4.1, 0.67000276540848983727e-8L);
2178   TEST_f_f (erfc, 9, 0.41370317465138102381e-36L);
2179
2180   END (erfc);
2181 }
2182
2183 static void
2184 exp_test (void)
2185 {
2186   START (exp);
2187
2188   TEST_f_f (exp, 0, 1);
2189   TEST_f_f (exp, minus_zero, 1);
2190
2191 #ifndef TEST_INLINE
2192   TEST_f_f (exp, plus_infty, plus_infty);
2193   TEST_f_f (exp, minus_infty, 0);
2194 #endif
2195   TEST_f_f (exp, nan_value, nan_value);
2196   TEST_f_f (exp, 1, M_El);
2197
2198   TEST_f_f (exp, 2, M_E2l);
2199   TEST_f_f (exp, 3, M_E3l);
2200   TEST_f_f (exp, 0.7, 2.0137527074704765216L);
2201
2202   END (exp);
2203 }
2204
2205
2206 static void
2207 exp10_test (void)
2208 {
2209   errno = 0;
2210   FUNC(exp10) (0);
2211   if (errno == ENOSYS)
2212     /* Function not implemented.  */
2213     return;
2214
2215   START (exp10);
2216
2217   TEST_f_f (exp10, 0, 1);
2218   TEST_f_f (exp10, minus_zero, 1);
2219
2220   TEST_f_f (exp10, plus_infty, plus_infty);
2221   TEST_f_f (exp10, minus_infty, 0);
2222   TEST_f_f (exp10, nan_value, nan_value);
2223   TEST_f_f (exp10, 3, 1000);
2224   TEST_f_f (exp10, -1, 0.1);
2225   TEST_f_f (exp10, 1e6, plus_infty);
2226   TEST_f_f (exp10, -1e6, 0);
2227   TEST_f_f (exp10, 0.7, 5.0118723362727228500L);
2228
2229   END (exp10);
2230 }
2231
2232 static void
2233 exp2_test (void)
2234 {
2235   errno = 0;
2236   FUNC(exp2) (0);
2237   if (errno == ENOSYS)
2238     /* Function not implemented.  */
2239     return;
2240
2241   START (exp2);
2242
2243   TEST_f_f (exp2, 0, 1);
2244   TEST_f_f (exp2, minus_zero, 1);
2245   TEST_f_f (exp2, plus_infty, plus_infty);
2246   TEST_f_f (exp2, minus_infty, 0);
2247   TEST_f_f (exp2, nan_value, nan_value);
2248
2249   TEST_f_f (exp2, 10, 1024);
2250   TEST_f_f (exp2, -1, 0.5);
2251   TEST_f_f (exp2, 1e6, plus_infty);
2252   TEST_f_f (exp2, -1e6, 0);
2253   TEST_f_f (exp2, 0.7, 1.6245047927124710452L);
2254
2255   END (exp2);
2256 }
2257
2258 static void
2259 expm1_test (void)
2260 {
2261   START (expm1);
2262
2263   TEST_f_f (expm1, 0, 0);
2264   TEST_f_f (expm1, minus_zero, minus_zero);
2265
2266 #ifndef TEST_INLINE
2267   TEST_f_f (expm1, plus_infty, plus_infty);
2268   TEST_f_f (expm1, minus_infty, -1);
2269 #endif
2270   TEST_f_f (expm1, nan_value, nan_value);
2271
2272   TEST_f_f (expm1, 1, M_El - 1.0);
2273   TEST_f_f (expm1, 0.7, 1.0137527074704765216L);
2274
2275   END (expm1);
2276 }
2277
2278 static void
2279 fabs_test (void)
2280 {
2281   START (fabs);
2282
2283   TEST_f_f (fabs, 0, 0);
2284   TEST_f_f (fabs, minus_zero, 0);
2285
2286   TEST_f_f (fabs, plus_infty, plus_infty);
2287   TEST_f_f (fabs, minus_infty, plus_infty);
2288   TEST_f_f (fabs, nan_value, nan_value);
2289
2290   TEST_f_f (fabs, 38.0, 38.0);
2291   TEST_f_f (fabs, -M_El, M_El);
2292
2293   END (fabs);
2294 }
2295
2296 static void
2297 fdim_test (void)
2298 {
2299   START (fdim);
2300
2301   TEST_ff_f (fdim, 0, 0, 0);
2302   TEST_ff_f (fdim, 9, 0, 9);
2303   TEST_ff_f (fdim, 0, 9, 0);
2304   TEST_ff_f (fdim, -9, 0, 0);
2305   TEST_ff_f (fdim, 0, -9, 9);
2306
2307   TEST_ff_f (fdim, plus_infty, 9, plus_infty);
2308   TEST_ff_f (fdim, plus_infty, -9, plus_infty);
2309   TEST_ff_f (fdim, minus_infty, 9, 0);
2310   TEST_ff_f (fdim, minus_infty, -9, 0);
2311   TEST_ff_f (fdim, 9, minus_infty, plus_infty);
2312   TEST_ff_f (fdim, -9, minus_infty, plus_infty);
2313   TEST_ff_f (fdim, 9, plus_infty, 0);
2314   TEST_ff_f (fdim, -9, plus_infty, 0);
2315
2316   TEST_ff_f (fdim, 0, nan_value, nan_value);
2317   TEST_ff_f (fdim, 9, nan_value, nan_value);
2318   TEST_ff_f (fdim, -9, nan_value, nan_value);
2319   TEST_ff_f (fdim, nan_value, 9, nan_value);
2320   TEST_ff_f (fdim, nan_value, -9, nan_value);
2321   TEST_ff_f (fdim, plus_infty, nan_value, nan_value);
2322   TEST_ff_f (fdim, minus_infty, nan_value, nan_value);
2323   TEST_ff_f (fdim, nan_value, plus_infty, nan_value);
2324   TEST_ff_f (fdim, nan_value, minus_infty, nan_value);
2325   TEST_ff_f (fdim, nan_value, nan_value, nan_value);
2326
2327   END (fdim);
2328 }
2329
2330 static void
2331 floor_test (void)
2332 {
2333   START (floor);
2334
2335   TEST_f_f (floor, 0.0, 0.0);
2336   TEST_f_f (floor, minus_zero, minus_zero);
2337   TEST_f_f (floor, plus_infty, plus_infty);
2338   TEST_f_f (floor, minus_infty, minus_infty);
2339   TEST_f_f (floor, nan_value, nan_value);
2340
2341   TEST_f_f (floor, M_PIl, 3.0);
2342   TEST_f_f (floor, -M_PIl, -4.0);
2343
2344   END (floor);
2345 }
2346
2347 static void
2348 fma_test (void)
2349 {
2350   START (fma);
2351
2352   TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0);
2353   TEST_fff_f (fma, nan_value, 2.0, 3.0, nan_value);
2354   TEST_fff_f (fma, 1.0, nan_value, 3.0, nan_value);
2355   TEST_fff_f (fma, 1.0, 2.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2356   TEST_fff_f (fma, plus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2357   TEST_fff_f (fma, minus_infty, 0.0, nan_value, nan_value, INVALID_EXCEPTION_OK);
2358   TEST_fff_f (fma, 0.0, plus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2359   TEST_fff_f (fma, 0.0, minus_infty, nan_value, nan_value, INVALID_EXCEPTION_OK);
2360   TEST_fff_f (fma, plus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2361   TEST_fff_f (fma, minus_infty, 0.0, 1.0, nan_value, INVALID_EXCEPTION);
2362   TEST_fff_f (fma, 0.0, plus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2363   TEST_fff_f (fma, 0.0, minus_infty, 1.0, nan_value, INVALID_EXCEPTION);
2364
2365   TEST_fff_f (fma, plus_infty, plus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2366   TEST_fff_f (fma, minus_infty, plus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2367   TEST_fff_f (fma, plus_infty, minus_infty, plus_infty, nan_value, INVALID_EXCEPTION);
2368   TEST_fff_f (fma, minus_infty, minus_infty, minus_infty, nan_value, INVALID_EXCEPTION);
2369
2370   END (fma);
2371 }
2372
2373
2374 static void
2375 fmax_test (void)
2376 {
2377   START (fmax);
2378
2379   TEST_ff_f (fmax, 0, 0, 0);
2380   TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero);
2381   TEST_ff_f (fmax, 9, 0, 9);
2382   TEST_ff_f (fmax, 0, 9, 9);
2383   TEST_ff_f (fmax, -9, 0, 0);
2384   TEST_ff_f (fmax, 0, -9, 0);
2385
2386   TEST_ff_f (fmax, plus_infty, 9, plus_infty);
2387   TEST_ff_f (fmax, 0, plus_infty, plus_infty);
2388   TEST_ff_f (fmax, -9, plus_infty, plus_infty);
2389   TEST_ff_f (fmax, plus_infty, -9, plus_infty);
2390
2391   TEST_ff_f (fmax, minus_infty, 9, 9);
2392   TEST_ff_f (fmax, minus_infty, -9, -9);
2393   TEST_ff_f (fmax, 9, minus_infty, 9);
2394   TEST_ff_f (fmax, -9, minus_infty, -9);
2395
2396   TEST_ff_f (fmax, 0, nan_value, 0);
2397   TEST_ff_f (fmax, 9, nan_value, 9);
2398   TEST_ff_f (fmax, -9, nan_value, -9);
2399   TEST_ff_f (fmax, nan_value, 0, 0);
2400   TEST_ff_f (fmax, nan_value, 9, 9);
2401   TEST_ff_f (fmax, nan_value, -9, -9);
2402   TEST_ff_f (fmax, plus_infty, nan_value, plus_infty);
2403   TEST_ff_f (fmax, minus_infty, nan_value, minus_infty);
2404   TEST_ff_f (fmax, nan_value, plus_infty, plus_infty);
2405   TEST_ff_f (fmax, nan_value, minus_infty, minus_infty);
2406   TEST_ff_f (fmax, nan_value, nan_value, nan_value);
2407
2408   END (fmax);
2409 }
2410
2411
2412 static void
2413 fmin_test (void)
2414 {
2415   START (fmin);
2416
2417   TEST_ff_f (fmin, 0, 0, 0);
2418   TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero);
2419   TEST_ff_f (fmin, 9, 0, 0);
2420   TEST_ff_f (fmin, 0, 9, 0);
2421   TEST_ff_f (fmin, -9, 0, -9);
2422   TEST_ff_f (fmin, 0, -9, -9);
2423
2424   TEST_ff_f (fmin, plus_infty, 9, 9);
2425   TEST_ff_f (fmin, 9, plus_infty, 9);
2426   TEST_ff_f (fmin, plus_infty, -9, -9);
2427   TEST_ff_f (fmin, -9, plus_infty, -9);
2428   TEST_ff_f (fmin, minus_infty, 9, minus_infty);
2429   TEST_ff_f (fmin, minus_infty, -9, minus_infty);
2430   TEST_ff_f (fmin, 9, minus_infty, minus_infty);
2431   TEST_ff_f (fmin, -9, minus_infty, minus_infty);
2432
2433   TEST_ff_f (fmin, 0, nan_value, 0);
2434   TEST_ff_f (fmin, 9, nan_value, 9);
2435   TEST_ff_f (fmin, -9, nan_value, -9);
2436   TEST_ff_f (fmin, nan_value, 0, 0);
2437   TEST_ff_f (fmin, nan_value, 9, 9);
2438   TEST_ff_f (fmin, nan_value, -9, -9);
2439   TEST_ff_f (fmin, plus_infty, nan_value, plus_infty);
2440   TEST_ff_f (fmin, minus_infty, nan_value, minus_infty);
2441   TEST_ff_f (fmin, nan_value, plus_infty, plus_infty);
2442   TEST_ff_f (fmin, nan_value, minus_infty, minus_infty);
2443   TEST_ff_f (fmin, nan_value, nan_value, nan_value);
2444
2445   END (fmin);
2446 }
2447
2448
2449 static void
2450 fmod_test (void)
2451 {
2452
2453   START (fmod);
2454
2455   /* fmod (+0, y) == +0 for y != 0.  */
2456   TEST_ff_f (fmod, 0, 3, 0);
2457
2458   /* fmod (-0, y) == -0 for y != 0.  */
2459   TEST_ff_f (fmod, minus_zero, 3, minus_zero);
2460
2461   /* fmod (+inf, y) == NaN plus invalid exception.  */
2462   TEST_ff_f (fmod, plus_infty, 3, nan_value, INVALID_EXCEPTION);
2463   /* fmod (-inf, y) == NaN plus invalid exception.  */
2464   TEST_ff_f (fmod, minus_infty, 3, nan_value, INVALID_EXCEPTION);
2465   /* fmod (x, +0) == NaN plus invalid exception.  */
2466   TEST_ff_f (fmod, 3, 0, nan_value, INVALID_EXCEPTION);
2467   /* fmod (x, -0) == NaN plus invalid exception.  */
2468   TEST_ff_f (fmod, 3, minus_zero, nan_value, INVALID_EXCEPTION);
2469
2470   /* fmod (x, +inf) == x for x not infinite.  */
2471   TEST_ff_f (fmod, 3.0, plus_infty, 3.0);
2472   /* fmod (x, -inf) == x for x not infinite.  */
2473   TEST_ff_f (fmod, 3.0, minus_infty, 3.0);
2474
2475   TEST_ff_f (fmod, nan_value, nan_value, nan_value);
2476
2477   TEST_ff_f (fmod, 6.5, 2.3, 1.9);
2478   TEST_ff_f (fmod, -6.5, 2.3, -1.9);
2479   TEST_ff_f (fmod, 6.5, -2.3, 1.9);
2480   TEST_ff_f (fmod, -6.5, -2.3, -1.9);
2481
2482   END (fmod);
2483 }
2484
2485 static void
2486 fpclassify_test (void)
2487 {
2488   START (fpclassify);
2489
2490   TEST_f_i (fpclassify, nan_value, FP_NAN);
2491   TEST_f_i (fpclassify, plus_infty, FP_INFINITE);
2492   TEST_f_i (fpclassify, minus_infty, FP_INFINITE);
2493   TEST_f_i (fpclassify, plus_zero, FP_ZERO);
2494   TEST_f_i (fpclassify, minus_zero, FP_ZERO);
2495   TEST_f_i (fpclassify, 1000, FP_NORMAL);
2496
2497   END (fpclassify);
2498 }
2499
2500
2501 static void
2502 frexp_test (void)
2503 {
2504   int x;
2505
2506   START (frexp);
2507
2508   TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE);
2509   TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE);
2510   TEST_fI_f1 (frexp, nan_value, nan_value, IGNORE);
2511
2512   TEST_fI_f1 (frexp, 0.0, 0.0, 0.0);
2513   TEST_fI_f1 (frexp, minus_zero, minus_zero, 0.0);
2514
2515   TEST_fI_f1 (frexp, 12.8, 0.8, 4);
2516   TEST_fI_f1 (frexp, -27.34, -0.854375, 5);
2517
2518   END (frexp);
2519 }
2520
2521
2522 static void
2523 gamma_test (void)
2524 {
2525   errno = 0;
2526   FUNC(gamma) (1);
2527
2528   if (errno == ENOSYS)
2529     /* Function not implemented.  */
2530     return;
2531   feclearexcept (FE_ALL_EXCEPT);
2532
2533   START (gamma);
2534
2535   TEST_f_f (gamma, plus_infty, plus_infty);
2536   TEST_f_f (gamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2537   TEST_f_f (gamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2538   TEST_f_f (gamma, minus_infty, plus_infty);
2539   TEST_f_f (gamma, nan_value, nan_value);
2540
2541   TEST_f_f1 (gamma, 1, 0, 1);
2542   TEST_f_f1 (gamma, 3, M_LN2l, 1);
2543
2544   TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1);
2545   TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2546
2547   END (gamma);
2548 }
2549
2550 static void
2551 hypot_test (void)
2552 {
2553   START (hypot);
2554
2555   TEST_ff_f (hypot, plus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2556   TEST_ff_f (hypot, minus_infty, 1, plus_infty, IGNORE_ZERO_INF_SIGN);
2557
2558 #ifndef TEST_INLINE
2559   TEST_ff_f (hypot, plus_infty, nan_value, plus_infty);
2560   TEST_ff_f (hypot, minus_infty, nan_value, plus_infty);
2561   TEST_ff_f (hypot, nan_value, plus_infty, plus_infty);
2562   TEST_ff_f (hypot, nan_value, minus_infty, plus_infty);
2563 #endif
2564
2565   TEST_ff_f (hypot, nan_value, nan_value, nan_value);
2566
2567   /* hypot (x,y) == hypot (+-x, +-y)  */
2568   TEST_ff_f (hypot, 0.7, 12.4, 12.41974234837422060118L);
2569   TEST_ff_f (hypot, -0.7, 12.4, 12.41974234837422060118L);
2570   TEST_ff_f (hypot, 0.7, -12.4, 12.41974234837422060118L);
2571   TEST_ff_f (hypot, -0.7, -12.4, 12.41974234837422060118L);
2572   TEST_ff_f (hypot, 12.4, 0.7, 12.41974234837422060118L);
2573   TEST_ff_f (hypot, -12.4, 0.7, 12.41974234837422060118L);
2574   TEST_ff_f (hypot, 12.4, -0.7, 12.41974234837422060118L);
2575   TEST_ff_f (hypot, -12.4, -0.7, 12.41974234837422060118L);
2576
2577   /*  hypot (x,0) == fabs (x)  */
2578   TEST_ff_f (hypot, 0.7, 0, 0.7);
2579   TEST_ff_f (hypot, -0.7, 0, 0.7);
2580   TEST_ff_f (hypot, -5.7e7, 0, 5.7e7);
2581
2582   TEST_ff_f (hypot, 0.7, 1.2, 1.3892443989449804508L);
2583
2584   END (hypot);
2585 }
2586
2587
2588 static void
2589 ilogb_test (void)
2590 {
2591   START (ilogb);
2592
2593   TEST_f_i (ilogb, 1, 0);
2594   TEST_f_i (ilogb, M_El, 1);
2595   TEST_f_i (ilogb, 1024, 10);
2596   TEST_f_i (ilogb, -2000, 10);
2597
2598   /* XXX We have a problem here: the standard does not tell us whether
2599      exceptions are allowed/required.  ignore them for now.  */
2600
2601   TEST_f_i (ilogb, 0.0, FP_ILOGB0, EXCEPTIONS_OK);
2602   TEST_f_i (ilogb, nan_value, FP_ILOGBNAN, EXCEPTIONS_OK);
2603
2604   END (ilogb);
2605 }
2606
2607 static void
2608 isfinite_test (void)
2609 {
2610   START (isfinite);
2611
2612   TEST_f_b (isfinite, 0, 1);
2613   TEST_f_b (isfinite, minus_zero, 1);
2614   TEST_f_b (isfinite, 10, 1);
2615   TEST_f_b (isfinite, plus_infty, 0);
2616   TEST_f_b (isfinite, minus_infty, 0);
2617   TEST_f_b (isfinite, nan_value, 0);
2618
2619   END (isfinite);
2620 }
2621
2622 static void
2623 isnormal_test (void)
2624 {
2625   START (isnormal);
2626
2627   TEST_f_b (isnormal, 0, 0);
2628   TEST_f_b (isnormal, minus_zero, 0);
2629   TEST_f_b (isnormal, 10, 1);
2630   TEST_f_b (isnormal, plus_infty, 0);
2631   TEST_f_b (isnormal, minus_infty, 0);
2632   TEST_f_b (isnormal, nan_value, 0);
2633
2634   END (isnormal);
2635 }
2636
2637 static void
2638 j0_test (void)
2639 {
2640   errno = 0;
2641   FUNC(j0) (0);
2642   if (errno == ENOSYS)
2643     /* Function not implemented.  */
2644     return;
2645
2646   START (j0);
2647
2648   /* j0 is the Bessel function of the first kind of order 0 */
2649   TEST_f_f (j0, nan_value, nan_value);
2650   TEST_f_f (j0, plus_infty, 0);
2651   TEST_f_f (j0, -1.0, 0.76519768655796655145);
2652   TEST_f_f (j0, 0.0, 1.0);
2653   TEST_f_f (j0, 0.1, 0.99750156206604003228);
2654   TEST_f_f (j0, 0.7, 0.88120088860740528084);
2655   TEST_f_f (j0, 1.0, 0.76519768655796655145);
2656   TEST_f_f (j0, 1.5, 0.51182767173591812875);
2657   TEST_f_f (j0, 2.0, 0.22389077914123566805);
2658   TEST_f_f (j0, 8.0, 0.17165080713755390609);
2659   TEST_f_f (j0, 10.0, -0.24593576445134833520);
2660
2661   END (j0);
2662 }
2663
2664
2665 static void
2666 j1_test (void)
2667 {
2668   errno = 0;
2669   FUNC(j1) (0);
2670   if (errno == ENOSYS)
2671     /* Function not implemented.  */
2672     return;
2673
2674   /* j1 is the Bessel function of the first kind of order 1 */
2675
2676   START (j1);
2677
2678   TEST_f_f (j1, nan_value, nan_value);
2679   TEST_f_f (j1, plus_infty, 0);
2680
2681   TEST_f_f (j1, -1.0, -0.44005058574493351596);
2682   TEST_f_f (j1, 0.0, 0.0);
2683   TEST_f_f (j1, 0.1, 0.049937526036241997556);
2684   TEST_f_f (j1, 0.7, 0.32899574154005894785);
2685   TEST_f_f (j1, 1.0, 0.44005058574493351596);
2686   TEST_f_f (j1, 1.5, 0.55793650791009964199);
2687   TEST_f_f (j1, 2.0, 0.57672480775687338720);
2688   TEST_f_f (j1, 8.0, 0.23463634685391462438);
2689   TEST_f_f (j1, 10.0, 0.043472746168861436670);
2690
2691   END (j1);
2692 }
2693
2694 static void
2695 jn_test (void)
2696 {
2697   errno = 0;
2698   FUNC(jn) (1, 1);
2699   if (errno == ENOSYS)
2700     /* Function not implemented.  */
2701     return;
2702
2703   /* jn is the Bessel function of the first kind of order n.  */
2704   START (jn);
2705
2706   /* jn (0, x) == j0 (x)  */
2707   TEST_ff_f (jn, 0, nan_value, nan_value);
2708   TEST_ff_f (jn, 0, plus_infty, 0);
2709   TEST_ff_f (jn, 0, -1.0, 0.76519768655796655145);
2710   TEST_ff_f (jn, 0, 0.0, 1.0);
2711   TEST_ff_f (jn, 0, 0.1, 0.99750156206604003228);
2712   TEST_ff_f (jn, 0, 0.7, 0.88120088860740528084);
2713   TEST_ff_f (jn, 0, 1.0, 0.76519768655796655145);
2714   TEST_ff_f (jn, 0, 1.5, 0.51182767173591812875);
2715   TEST_ff_f (jn, 0, 2.0, 0.22389077914123566805);
2716   TEST_ff_f (jn, 0, 8.0, 0.17165080713755390609);
2717   TEST_ff_f (jn, 0, 10.0, -0.24593576445134833520);
2718
2719   /* jn (1, x) == j1 (x)  */
2720   TEST_ff_f (jn, 1, nan_value, nan_value);
2721   TEST_ff_f (jn, 1, plus_infty, 0);
2722
2723   TEST_ff_f (jn, 1, -1.0, -0.44005058574493351596);
2724   TEST_ff_f (jn, 1, 0.0, 0.0);
2725   TEST_ff_f (jn, 1, 0.1, 0.049937526036241997556);
2726   TEST_ff_f (jn, 1, 0.7, 0.32899574154005894785);
2727   TEST_ff_f (jn, 1, 1.0, 0.44005058574493351596);
2728   TEST_ff_f (jn, 1, 1.5, 0.55793650791009964199);
2729   TEST_ff_f (jn, 1, 2.0, 0.57672480775687338720);
2730   TEST_ff_f (jn, 1, 8.0, 0.23463634685391462438);
2731   TEST_ff_f (jn, 1, 10.0, 0.043472746168861436670);
2732
2733   /* jn (3, x)  */
2734   TEST_ff_f (jn, 3, nan_value, nan_value);
2735   TEST_ff_f (jn, 3, plus_infty, 0);
2736
2737   TEST_ff_f (jn, 3, -1.0, -0.019563353982668405919);
2738   TEST_ff_f (jn, 3, 0.0, 0.0);
2739   TEST_ff_f (jn, 3, 0.1, 0.000020820315754756261429);
2740   TEST_ff_f (jn, 3, 0.7, 0.0069296548267508408077);
2741   TEST_ff_f (jn, 3, 1.0, 0.019563353982668405919);
2742   TEST_ff_f (jn, 3, 2.0, 0.12894324947440205110);
2743   TEST_ff_f (jn, 3, 10.0, 0.058379379305186812343);
2744
2745   /*  jn (10, x)  */
2746   TEST_ff_f (jn, 10, nan_value, nan_value);
2747   TEST_ff_f (jn, 10, plus_infty, 0);
2748
2749   TEST_ff_f (jn, 10, -1.0, 0.26306151236874532070e-9);
2750   TEST_ff_f (jn, 10, 0.0, 0.0);
2751   TEST_ff_f (jn, 10, 0.1, 0.26905328954342155795e-19);
2752   TEST_ff_f (jn, 10, 0.7, 0.75175911502153953928e-11);
2753   TEST_ff_f (jn, 10, 1.0, 0.26306151236874532070e-9);
2754   TEST_ff_f (jn, 10, 2.0, 0.25153862827167367096e-6);
2755   TEST_ff_f (jn, 10, 10.0, 0.20748610663335885770);
2756
2757   END (jn);
2758 }
2759
2760
2761 static void
2762 ldexp_test (void)
2763 {
2764   TEST_ff_f (ldexp, 0, 0, 0);
2765   TEST_ff_f (ldexp, minus_zero, 0, minus_zero);
2766
2767   TEST_ff_f (ldexp, plus_infty, 1, plus_infty);
2768   TEST_ff_f (ldexp, minus_infty, 1, minus_infty);
2769   TEST_ff_f (ldexp, nan_value, 1, nan_value);
2770
2771   TEST_ff_f (ldexp, 0.8L, 4, 12.8L);
2772   TEST_ff_f (ldexp, -0.854375L, 5, -27.34L);
2773
2774   /* ldexp (x, 0) == x.  */
2775   TEST_ff_f (ldexp, 1.0L, 0L, 1.0L);
2776 }
2777
2778 static void
2779 lgamma_test (void)
2780 {
2781   errno = 0;
2782   FUNC(lgamma) (0);
2783   if (errno == ENOSYS)
2784     /* Function not implemented.  */
2785     return;
2786   feclearexcept (FE_ALL_EXCEPT);
2787
2788   START (lgamma);
2789
2790   TEST_f_f (lgamma, plus_infty, plus_infty);
2791   TEST_f_f (lgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2792   TEST_f_f (lgamma, nan_value, nan_value);
2793
2794   /* lgamma (x) == +inf plus divide by zero exception for integer x <= 0.  */
2795   TEST_f_f (lgamma, -3, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2796   TEST_f_f (lgamma, minus_infty, plus_infty);
2797
2798   TEST_f_f1 (lgamma, 1, 0, 1);
2799
2800   TEST_f_f1 (lgamma, 3, M_LN2l, 1);
2801
2802   TEST_f_f1 (lgamma, 0.5, M_LOG_SQRT_PIl, 1);
2803   TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1);
2804   TEST_f_f1 (lgamma, 0.7, 0.26086724653166651439L, 1);
2805   TEST_f_f1 (lgamma, 1.2, -0.853740900033158497197e-1L, 1);
2806
2807   END (lgamma);
2808 }
2809
2810 static void
2811 lrint_test (void)
2812 {
2813   /* XXX this test is incomplete.  We need to have a way to specifiy
2814      the rounding method and test the critical cases.  So far, only
2815      unproblematic numbers are tested.  */
2816
2817   START (lrint);
2818
2819   TEST_f_l (lrint, 0.0, 0);
2820   TEST_f_l (lrint, minus_zero, 0);
2821   TEST_f_l (lrint, 0.2, 0);
2822   TEST_f_l (lrint, -0.2, 0);
2823
2824   TEST_f_l (lrint, 1.4, 1);
2825   TEST_f_l (lrint, -1.4, -1);
2826
2827   TEST_f_l (lrint, 8388600.3, 8388600);
2828   TEST_f_l (lrint, -8388600.3, -8388600);
2829
2830   END (lrint);
2831 }
2832
2833 static void
2834 llrint_test (void)
2835 {
2836   /* XXX this test is incomplete.  We need to have a way to specifiy
2837      the rounding method and test the critical cases.  So far, only
2838      unproblematic numbers are tested.  */
2839
2840   START (llrint);
2841
2842   TEST_f_L (llrint, 0.0, 0);
2843   TEST_f_L (llrint, minus_zero, 0);
2844   TEST_f_L (llrint, 0.2, 0);
2845   TEST_f_L (llrint, -0.2, 0);
2846
2847   TEST_f_L (llrint, 1.4, 1);
2848   TEST_f_L (llrint, -1.4, -1);
2849
2850   TEST_f_L (llrint, 8388600.3, 8388600);
2851   TEST_f_L (llrint, -8388600.3, -8388600);
2852
2853   /* Test boundary conditions.  */
2854   /* 0x1FFFFF */
2855   TEST_f_L (llrint, 2097151.0,2097151LL);
2856   /* 0x800000 */
2857   TEST_f_L (llrint, 8388608.0, 8388608LL);
2858   /* 0x1000000 */
2859   TEST_f_L (llrint, 16777216.0, 16777216LL);
2860   /* 0x20000000000 */
2861   TEST_f_L (llrint, 2199023255552.0, 2199023255552LL);
2862   /* 0x40000000000 */
2863   TEST_f_L (llrint, 4398046511104.0, 4398046511104LL);
2864   /* 0x10000000000000 */
2865   TEST_f_L (llrint, 4503599627370496.0, 4503599627370496LL);
2866   /* 0x10000080000000 */
2867   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
2868   /* 0x20000000000000 */
2869   TEST_f_L (llrint, 9007199254740992.0, 9007199254740992LL);
2870   /* 0x80000000000000 */
2871   TEST_f_L (llrint, 36028797018963968.0, 36028797018963968LL);
2872   /* 0x100000000000000 */
2873   TEST_f_L (llrint, 72057594037927936.0, 72057594037927936LL);
2874
2875   END (llrint);
2876 }
2877
2878 static void
2879 log_test (void)
2880 {
2881   START (log);
2882
2883   TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2884   TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2885
2886   TEST_f_f (log, 1, 0);
2887
2888   TEST_f_f (log, -1, nan_value, INVALID_EXCEPTION);
2889   TEST_f_f (log, plus_infty, plus_infty);
2890
2891   TEST_f_f (log, M_El, 1);
2892   TEST_f_f (log, 1.0 / M_El, -1);
2893   TEST_f_f (log, 2, M_LN2l);
2894   TEST_f_f (log, 10, M_LN10l);
2895   TEST_f_f (log, 0.7, -0.35667494393873237891L);
2896
2897   END (log);
2898 }
2899
2900
2901 static void
2902 log10_test (void)
2903 {
2904   START (log10);
2905
2906   TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2907   TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2908
2909   TEST_f_f (log10, 1, 0);
2910
2911   /* log10 (x) == NaN plus invalid exception if x < 0.  */
2912   TEST_f_f (log10, -1, nan_value, INVALID_EXCEPTION);
2913
2914   TEST_f_f (log10, plus_infty, plus_infty);
2915   TEST_f_f (log10, nan_value, nan_value);
2916
2917   TEST_f_f (log10, 0.1L, -1);
2918   TEST_f_f (log10, 10.0, 1);
2919   TEST_f_f (log10, 100.0, 2);
2920   TEST_f_f (log10, 10000.0, 4);
2921   TEST_f_f (log10, M_El, M_LOG10El);
2922   TEST_f_f (log10, 0.7, -0.15490195998574316929L);
2923
2924   END (log10);
2925 }
2926
2927
2928 static void
2929 log1p_test (void)
2930 {
2931   START (log1p);
2932
2933   TEST_f_f (log1p, 0, 0);
2934   TEST_f_f (log1p, minus_zero, minus_zero);
2935
2936   TEST_f_f (log1p, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2937   TEST_f_f (log1p, -2, nan_value, INVALID_EXCEPTION);
2938
2939   TEST_f_f (log1p, plus_infty, plus_infty);
2940   TEST_f_f (log1p, nan_value, nan_value);
2941
2942   TEST_f_f (log1p, M_El - 1.0, 1);
2943
2944   TEST_f_f (log1p, -0.3, -0.35667494393873237891L);
2945
2946   END (log1p);
2947 }
2948
2949
2950 static void
2951 log2_test (void)
2952 {
2953   START (log2);
2954
2955   TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2956   TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2957
2958   TEST_f_f (log2, 1, 0);
2959
2960   TEST_f_f (log2, -1, nan_value, INVALID_EXCEPTION);
2961
2962   TEST_f_f (log2, plus_infty, plus_infty);
2963   TEST_f_f (log2, nan_value, nan_value);
2964
2965   TEST_f_f (log2, M_El, M_LOG2El);
2966   TEST_f_f (log2, 2.0, 1);
2967   TEST_f_f (log2, 16.0, 4);
2968   TEST_f_f (log2, 256.0, 8);
2969   TEST_f_f (log2, 0.7, -0.51457317282975824043L);
2970
2971   END (log2);
2972 }
2973
2974
2975 static void
2976 logb_test (void)
2977 {
2978   START (logb);
2979
2980   TEST_f_f (logb, plus_infty, plus_infty);
2981   TEST_f_f (logb, minus_infty, plus_infty);
2982
2983   TEST_f_f (logb, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2984
2985   TEST_f_f (logb, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
2986   TEST_f_f (logb, nan_value, nan_value);
2987
2988   TEST_f_f (logb, 1, 0);
2989   TEST_f_f (logb, M_El, 1);
2990   TEST_f_f (logb, 1024, 10);
2991   TEST_f_f (logb, -2000, 10);
2992
2993   END (logb);
2994 }
2995
2996 static void
2997 lround_test (void)
2998 {
2999   START (lround);
3000
3001   TEST_f_l (lround, 0, 0);
3002   TEST_f_l (lround, minus_zero, 0);
3003   TEST_f_l (lround, 0.2, 0.0);
3004   TEST_f_l (lround, -0.2, 0);
3005   TEST_f_l (lround, 0.5, 1);
3006   TEST_f_l (lround, -0.5, -1);
3007   TEST_f_l (lround, 0.8, 1);
3008   TEST_f_l (lround, -0.8, -1);
3009   TEST_f_l (lround, 1.5, 2);
3010   TEST_f_l (lround, -1.5, -2);
3011   TEST_f_l (lround, 22514.5, 22515);
3012   TEST_f_l (lround, -22514.5, -22515);
3013 #ifndef TEST_FLOAT
3014   TEST_f_l (lround, 2097152.5, 2097153);
3015   TEST_f_l (lround, -2097152.5, -2097153);
3016 #endif
3017   END (lround);
3018 }
3019
3020
3021 static void
3022 llround_test (void)
3023 {
3024   START (llround);
3025
3026   TEST_f_L (llround, 0, 0);
3027   TEST_f_L (llround, minus_zero, 0);
3028   TEST_f_L (llround, 0.2, 0.0);
3029   TEST_f_L (llround, -0.2, 0);
3030   TEST_f_L (llround, 0.5, 1);
3031   TEST_f_L (llround, -0.5, -1);
3032   TEST_f_L (llround, 0.8, 1);
3033   TEST_f_L (llround, -0.8, -1);
3034   TEST_f_L (llround, 1.5, 2);
3035   TEST_f_L (llround, -1.5, -2);
3036   TEST_f_L (llround, 22514.5, 22515);
3037   TEST_f_L (llround, -22514.5, -22515);
3038 #ifndef TEST_FLOAT
3039   TEST_f_L (llround, 2097152.5, 2097153);
3040   TEST_f_L (llround, -2097152.5, -2097153);
3041   TEST_f_L (llround, 34359738368.5, 34359738369ll);
3042   TEST_f_L (llround, -34359738368.5, -34359738369ll);
3043 #endif
3044
3045   /* Test boundary conditions.  */
3046   /* 0x1FFFFF */
3047   TEST_f_L (llround, 2097151.0, 2097151LL);
3048   /* 0x800000 */
3049   TEST_f_L (llround, 8388608.0, 8388608LL);
3050   /* 0x1000000 */
3051   TEST_f_L (llround, 16777216.0, 16777216LL);
3052   /* 0x20000000000 */
3053   TEST_f_L (llround, 2199023255552.0, 2199023255552LL);
3054   /* 0x40000000000 */
3055   TEST_f_L (llround, 4398046511104.0, 4398046511104LL);
3056   /* 0x10000000000000 */
3057   TEST_f_L (llround, 4503599627370496.0, 4503599627370496LL);
3058   /* 0x10000080000000 */
3059   TEST_f_L (llrint, 4503601774854144.0, 4503601774854144LL);
3060   /* 0x20000000000000 */
3061   TEST_f_L (llround, 9007199254740992.0, 9007199254740992LL);
3062   /* 0x80000000000000 */
3063   TEST_f_L (llround, 36028797018963968.0, 36028797018963968LL);
3064   /* 0x100000000000000 */
3065   TEST_f_L (llround, 72057594037927936.0, 72057594037927936LL);
3066
3067   END (llround);
3068 }
3069
3070 static void
3071 modf_test (void)
3072 {
3073   FLOAT x;
3074
3075   START (modf);
3076
3077   TEST_fF_f1 (modf, plus_infty, 0, plus_infty);
3078   TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty);
3079   TEST_fF_f1 (modf, nan_value, nan_value, nan_value);
3080   TEST_fF_f1 (modf, 0, 0, 0);
3081   TEST_fF_f1 (modf, 1.5, 0.5, 1);
3082   TEST_fF_f1 (modf, 2.5, 0.5, 2);
3083   TEST_fF_f1 (modf, -2.5, -0.5, -2);
3084   TEST_fF_f1 (modf, 20, 0, 20);
3085   TEST_fF_f1 (modf, 21, 0, 21);
3086   TEST_fF_f1 (modf, 89.5, 0.5, 89);
3087
3088   END (modf);
3089 }
3090
3091
3092 static void
3093 nearbyint_test (void)
3094 {
3095   START (nearbyint);
3096
3097   TEST_f_f (nearbyint, 0.0, 0.0);
3098   TEST_f_f (nearbyint, minus_zero, minus_zero);
3099   TEST_f_f (nearbyint, plus_infty, plus_infty);
3100   TEST_f_f (nearbyint, minus_infty, minus_infty);
3101   TEST_f_f (nearbyint, nan_value, nan_value);
3102
3103   END (nearbyint);
3104 }
3105
3106 static void
3107 nextafter_test (void)
3108 {
3109
3110   START (nextafter);
3111
3112   TEST_ff_f (nextafter, 0, 0, 0);
3113   TEST_ff_f (nextafter, minus_zero, 0, 0);
3114   TEST_ff_f (nextafter, 0, minus_zero, minus_zero);
3115   TEST_ff_f (nextafter, minus_zero, minus_zero, minus_zero);
3116
3117   TEST_ff_f (nextafter, 9, 9, 9);
3118   TEST_ff_f (nextafter, -9, -9, -9);
3119   TEST_ff_f (nextafter, plus_infty, plus_infty, plus_infty);
3120   TEST_ff_f (nextafter, minus_infty, minus_infty, minus_infty);
3121
3122   TEST_ff_f (nextafter, nan_value, 1.1, nan_value);
3123   TEST_ff_f (nextafter, 1.1, nan_value, nan_value);
3124   TEST_ff_f (nextafter, nan_value, nan_value, nan_value);
3125
3126   /* XXX We need the hexadecimal FP number representation here for further
3127      tests.  */
3128
3129   END (nextafter);
3130 }
3131
3132
3133 static void
3134 nexttoward_test (void)
3135 {
3136   START (nexttoward);
3137   TEST_ff_f (nexttoward, 0, 0, 0);
3138   TEST_ff_f (nexttoward, minus_zero, 0, 0);
3139   TEST_ff_f (nexttoward, 0, minus_zero, minus_zero);
3140   TEST_ff_f (nexttoward, minus_zero, minus_zero, minus_zero);
3141
3142   TEST_ff_f (nexttoward, 9, 9, 9);
3143   TEST_ff_f (nexttoward, -9, -9, -9);
3144   TEST_ff_f (nexttoward, plus_infty, plus_infty, plus_infty);
3145   TEST_ff_f (nexttoward, minus_infty, minus_infty, minus_infty);
3146
3147   TEST_ff_f (nexttoward, nan_value, 1.1, nan_value);
3148   TEST_ff_f (nexttoward, 1.1, nan_value, nan_value);
3149   TEST_ff_f (nexttoward, nan_value, nan_value, nan_value);
3150
3151   /* XXX We need the hexadecimal FP number representation here for further
3152      tests.  */
3153
3154   END (nexttoward);
3155 }
3156
3157
3158 static void
3159 pow_test (void)
3160 {
3161
3162   START (pow);
3163
3164   TEST_ff_f (pow, 0, 0, 1);
3165   TEST_ff_f (pow, 0, minus_zero, 1);
3166   TEST_ff_f (pow, minus_zero, 0, 1);
3167   TEST_ff_f (pow, minus_zero, minus_zero, 1);
3168
3169   TEST_ff_f (pow, 10, 0, 1);
3170   TEST_ff_f (pow, 10, minus_zero, 1);
3171   TEST_ff_f (pow, -10, 0, 1);
3172   TEST_ff_f (pow, -10, minus_zero, 1);
3173
3174   TEST_ff_f (pow, nan_value, 0, 1);
3175   TEST_ff_f (pow, nan_value, minus_zero, 1);
3176
3177
3178 #ifndef TEST_INLINE
3179   TEST_ff_f (pow, 1.1, plus_infty, plus_infty);
3180   TEST_ff_f (pow, plus_infty, plus_infty, plus_infty);
3181   TEST_ff_f (pow, -1.1, plus_infty, plus_infty);
3182   TEST_ff_f (pow, minus_infty, plus_infty, plus_infty);
3183
3184   TEST_ff_f (pow, 0.9L, plus_infty, 0);
3185   TEST_ff_f (pow, 1e-7L, plus_infty, 0);
3186   TEST_ff_f (pow, -0.9L, plus_infty, 0);
3187   TEST_ff_f (pow, -1e-7L, plus_infty, 0);
3188
3189   TEST_ff_f (pow, 1.1, minus_infty, 0);
3190   TEST_ff_f (pow, plus_infty, minus_infty, 0);
3191   TEST_ff_f (pow, -1.1, minus_infty, 0);
3192   TEST_ff_f (pow, minus_infty, minus_infty, 0);
3193
3194   TEST_ff_f (pow, 0.9L, minus_infty, plus_infty);
3195   TEST_ff_f (pow, 1e-7L, minus_infty, plus_infty);
3196   TEST_ff_f (pow, -0.9L, minus_infty, plus_infty);
3197   TEST_ff_f (pow, -1e-7L, minus_infty, plus_infty);
3198
3199   TEST_ff_f (pow, plus_infty, 1e-7L, plus_infty);
3200   TEST_ff_f (pow, plus_infty, 1, plus_infty);
3201   TEST_ff_f (pow, plus_infty, 1e7L, plus_infty);
3202
3203   TEST_ff_f (pow, plus_infty, -1e-7L, 0);
3204   TEST_ff_f (pow, plus_infty, -1, 0);
3205   TEST_ff_f (pow, plus_infty, -1e7L, 0);
3206
3207   TEST_ff_f (pow, minus_infty, 1, minus_infty);
3208   TEST_ff_f (pow, minus_infty, 11, minus_infty);
3209   TEST_ff_f (pow, minus_infty, 1001, minus_infty);
3210
3211   TEST_ff_f (pow, minus_infty, 2, plus_infty);
3212   TEST_ff_f (pow, minus_infty, 12, plus_infty);
3213   TEST_ff_f (pow, minus_infty, 1002, plus_infty);
3214   TEST_ff_f (pow, minus_infty, 0.1, plus_infty);
3215   TEST_ff_f (pow, minus_infty, 1.1, plus_infty);
3216   TEST_ff_f (pow, minus_infty, 11.1, plus_infty);
3217   TEST_ff_f (pow, minus_infty, 1001.1, plus_infty);
3218
3219   TEST_ff_f (pow, minus_infty, -1, minus_zero);
3220   TEST_ff_f (pow, minus_infty, -11, minus_zero);
3221   TEST_ff_f (pow, minus_infty, -1001, minus_zero);
3222
3223   TEST_ff_f (pow, minus_infty, -2, 0);
3224   TEST_ff_f (pow, minus_infty, -12, 0);
3225   TEST_ff_f (pow, minus_infty, -1002, 0);
3226   TEST_ff_f (pow, minus_infty, -0.1, 0);
3227   TEST_ff_f (pow, minus_infty, -1.1, 0);
3228   TEST_ff_f (pow, minus_infty, -11.1, 0);
3229   TEST_ff_f (pow, minus_infty, -1001.1, 0);
3230 #endif
3231
3232   TEST_ff_f (pow, nan_value, nan_value, nan_value);
3233   TEST_ff_f (pow, 0, nan_value, nan_value);
3234   TEST_ff_f (pow, 1, nan_value, nan_value);
3235   TEST_ff_f (pow, -1, nan_value, nan_value);
3236   TEST_ff_f (pow, nan_value, 1, nan_value);
3237   TEST_ff_f (pow, nan_value, -1, nan_value);
3238
3239   /* pow (x, NaN) == NaN.  */
3240   TEST_ff_f (pow, 3.0, nan_value, nan_value);
3241
3242   TEST_ff_f (pow, 1, plus_infty, nan_value, INVALID_EXCEPTION);
3243   TEST_ff_f (pow, -1, plus_infty, nan_value, INVALID_EXCEPTION);
3244   TEST_ff_f (pow, 1, minus_infty, nan_value, INVALID_EXCEPTION);
3245   TEST_ff_f (pow, -1, minus_infty, nan_value, INVALID_EXCEPTION);
3246
3247   TEST_ff_f (pow, -0.1, 1.1, nan_value, INVALID_EXCEPTION);
3248   TEST_ff_f (pow, -0.1, -1.1, nan_value, INVALID_EXCEPTION);
3249   TEST_ff_f (pow, -10.1, 1.1, nan_value, INVALID_EXCEPTION);
3250   TEST_ff_f (pow, -10.1, -1.1, nan_value, INVALID_EXCEPTION);
3251
3252   TEST_ff_f (pow, 0, -1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3253   TEST_ff_f (pow, 0, -11, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3254   TEST_ff_f (pow, minus_zero, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3255   TEST_ff_f (pow, minus_zero, -11, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3256
3257   TEST_ff_f (pow, 0, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3258   TEST_ff_f (pow, 0, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3259   TEST_ff_f (pow, minus_zero, -2, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3260   TEST_ff_f (pow, minus_zero, -11.1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);
3261
3262
3263   TEST_ff_f (pow, 0, 1, 0);
3264   TEST_ff_f (pow, 0, 11, 0);
3265
3266   TEST_ff_f (pow, minus_zero, 1, minus_zero);
3267   TEST_ff_f (pow, minus_zero, 11, minus_zero);
3268
3269
3270   TEST_ff_f (pow, 0, 2, 0);
3271   TEST_ff_f (pow, 0, 11.1, 0);
3272
3273
3274   TEST_ff_f (pow, minus_zero, 2, 0);
3275   TEST_ff_f (pow, minus_zero, 11.1, 0);
3276
3277 #ifndef TEST_INLINE
3278   /* pow (x, +inf) == +inf for |x| > 1.  */
3279   TEST_ff_f (pow, 1.5, plus_infty, plus_infty);
3280
3281   /* pow (x, +inf) == +0 for |x| < 1.  */
3282   TEST_ff_f (pow, 0.5, plus_infty, 0.0);
3283
3284   /* pow (x, -inf) == +0 for |x| > 1.  */
3285   TEST_ff_f (pow, 1.5, minus_infty, 0.0);
3286
3287   /* pow (x, -inf) == +inf for |x| < 1.  */
3288   TEST_ff_f (pow, 0.5, minus_infty, plus_infty);
3289 #endif
3290
3291   /* pow (+inf, y) == +inf for y > 0.  */
3292   TEST_ff_f (pow, plus_infty, 2, plus_infty);
3293
3294   /* pow (+inf, y) == +0 for y < 0.  */
3295   TEST_ff_f (pow, plus_infty, -1, 0.0);
3296
3297   /* pow (-inf, y) == -inf for y an odd integer > 0.  */
3298   TEST_ff_f (pow, minus_infty, 27, minus_infty);
3299
3300   /* pow (-inf, y) == +inf for y > 0 and not an odd integer.  */
3301   TEST_ff_f (pow, minus_infty, 28, plus_infty);
3302
3303   /* pow (-inf, y) == -0 for y an odd integer < 0. */
3304   TEST_ff_f (pow, minus_infty, -3, minus_zero);
3305   /* pow (-inf, y) == +0 for y < 0 and not an odd integer.  */
3306   TEST_ff_f (pow, minus_infty, -2.0, 0.0);
3307
3308   /* pow (+0, y) == +0 for y an odd integer > 0.  */
3309   TEST_ff_f (pow, 0.0, 27, 0.0);
3310
3311   /* pow (-0, y) == -0 for y an odd integer > 0.  */
3312   TEST_ff_f (pow, minus_zero, 27, minus_zero);
3313
3314   /* pow (+0, y) == +0 for y > 0 and not an odd integer.  */
3315   TEST_ff_f (pow, 0.0, 4, 0.0);
3316
3317   /* pow (-0, y) == +0 for y > 0 and not an odd integer.  */
3318   TEST_ff_f (pow, minus_zero, 4, 0.0);
3319
3320   TEST_ff_f (pow, 0.7, 1.2, 0.65180494056638638188L);
3321
3322 #ifdef TEST_DOUBLE
3323   TEST_ff_f (pow, -7.49321e+133, -9.80818e+16, 0);
3324 #endif
3325
3326   END (pow);
3327 }
3328
3329 static void
3330 remainder_test (void)
3331 {
3332
3333   START (remainder);
3334
3335   TEST_ff_f (remainder, 1, 0, nan_value, INVALID_EXCEPTION);
3336   TEST_ff_f (remainder, 1, minus_zero, nan_value, INVALID_EXCEPTION);
3337   TEST_ff_f (remainder, plus_infty, 1, nan_value, INVALID_EXCEPTION);
3338   TEST_ff_f (remainder, minus_infty, 1, nan_value, INVALID_EXCEPTION);
3339   TEST_ff_f (remainder, nan_value, nan_value, nan_value);
3340
3341   TEST_ff_f (remainder, 1.625, 1.0, -0.375);
3342   TEST_ff_f (remainder, -1.625, 1.0, 0.375);
3343   TEST_ff_f (remainder, 1.625, -1.0, -0.375);
3344   TEST_ff_f (remainder, -1.625, -1.0, 0.375);
3345   TEST_ff_f (remainder, 5.0, 2.0, 1.0);
3346   TEST_ff_f (remainder, 3.0, 2.0, -1.0);
3347
3348   END (remainder);
3349 }
3350
3351 static void
3352 remquo_test (void)
3353 {
3354   /* x is needed.  */
3355   int x;
3356
3357   START (remquo);
3358
3359   TEST_ffI_f1 (remquo, 1, 0, nan_value, IGNORE, INVALID_EXCEPTION);
3360   TEST_ffI_f1 (remquo, 1, minus_zero, nan_value, IGNORE, INVALID_EXCEPTION);
3361   TEST_ffI_f1 (remquo, plus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3362   TEST_ffI_f1 (remquo, minus_infty, 1, nan_value, IGNORE, INVALID_EXCEPTION);
3363   TEST_ffI_f1 (remquo, nan_value, nan_value, nan_value, IGNORE);
3364
3365   TEST_ffI_f1 (remquo, 1.625, 1.0, -0.375, 2);
3366   TEST_ffI_f1 (remquo, -1.625, 1.0, 0.375, -2);
3367   TEST_ffI_f1 (remquo, 1.625, -1.0, -0.375, -2);
3368   TEST_ffI_f1 (remquo, -1.625, -1.0, 0.375, 2);
3369
3370   TEST_ffI_f1 (remquo, 5, 2, 1, 2);
3371   TEST_ffI_f1 (remquo, 3, 2, -1, 2);
3372
3373   END (remquo);
3374 }
3375
3376 static void
3377 rint_test (void)
3378 {
3379   START (rint);
3380
3381   TEST_f_f (rint, 0.0, 0.0);
3382   TEST_f_f (rint, minus_zero, minus_zero);
3383   TEST_f_f (rint, plus_infty, plus_infty);
3384   TEST_f_f (rint, minus_infty, minus_infty);
3385
3386   END (rint);
3387 }
3388
3389 static void
3390 round_test (void)
3391 {
3392   START (round);
3393
3394   TEST_f_f (round, 0, 0);
3395   TEST_f_f (round, minus_zero, minus_zero);
3396   TEST_f_f (round, 0.2, 0.0);
3397   TEST_f_f (round, -0.2, minus_zero);
3398   TEST_f_f (round, 0.5, 1.0);
3399   TEST_f_f (round, -0.5, -1.0);
3400   TEST_f_f (round, 0.8, 1.0);
3401   TEST_f_f (round, -0.8, -1.0);
3402   TEST_f_f (round, 1.5, 2.0);
3403   TEST_f_f (round, -1.5, -2.0);
3404   TEST_f_f (round, 2097152.5, 2097153);
3405   TEST_f_f (round, -2097152.5, -2097153);
3406
3407   END (round);
3408 }
3409
3410
3411 static void
3412 scalb_test (void)
3413 {
3414
3415   START (scalb);
3416
3417   TEST_ff_f (scalb, 2.0, 0.5, nan_value);
3418   TEST_ff_f (scalb, 3.0, -2.5, nan_value);
3419
3420   TEST_ff_f (scalb, 0, nan_value, nan_value);
3421   TEST_ff_f (scalb, 1, nan_value, nan_value);
3422
3423   TEST_ff_f (scalb, 1, 0, 1);
3424   TEST_ff_f (scalb, -1, 0, -1);
3425
3426   TEST_ff_f (scalb, 0, plus_infty, nan_value, INVALID_EXCEPTION);
3427   TEST_ff_f (scalb, minus_zero, plus_infty, nan_value, INVALID_EXCEPTION);
3428
3429   TEST_ff_f (scalb, 0, 2, 0);
3430   TEST_ff_f (scalb, minus_zero, -4, minus_zero);
3431   TEST_ff_f (scalb, 0, 0, 0);
3432   TEST_ff_f (scalb, minus_zero, 0, minus_zero);
3433   TEST_ff_f (scalb, 0, -1, 0);
3434   TEST_ff_f (scalb, minus_zero, -10, minus_zero);
3435   TEST_ff_f (scalb, 0, minus_infty, 0);
3436   TEST_ff_f (scalb, minus_zero, minus_infty, minus_zero);
3437
3438   TEST_ff_f (scalb, plus_infty, -1, plus_infty);
3439   TEST_ff_f (scalb, minus_infty, -10, minus_infty);
3440   TEST_ff_f (scalb, plus_infty, 0, plus_infty);
3441   TEST_ff_f (scalb, minus_infty, 0, minus_infty);
3442   TEST_ff_f (scalb, plus_infty, 2, plus_infty);
3443   TEST_ff_f (scalb, minus_infty, 100, minus_infty);
3444
3445   TEST_ff_f (scalb, 0.1, minus_infty, 0.0);
3446   TEST_ff_f (scalb, -0.1, minus_infty, minus_zero);
3447
3448   TEST_ff_f (scalb, 1, plus_infty, plus_infty);
3449   TEST_ff_f (scalb, -1, plus_infty, minus_infty);
3450   TEST_ff_f (scalb, plus_infty, plus_infty, plus_infty);
3451   TEST_ff_f (scalb, minus_infty, plus_infty, minus_infty);
3452
3453   TEST_ff_f (scalb, plus_infty, minus_infty, nan_value);
3454   TEST_ff_f (scalb, minus_infty, minus_infty, nan_value);
3455
3456   TEST_ff_f (scalb, nan_value, 1, nan_value);
3457   TEST_ff_f (scalb, 1, nan_value, nan_value);
3458   TEST_ff_f (scalb, nan_value, 0, nan_value);
3459   TEST_ff_f (scalb, 0, nan_value, nan_value);
3460   TEST_ff_f (scalb, nan_value, plus_infty, nan_value);
3461   TEST_ff_f (scalb, plus_infty, nan_value, nan_value);
3462   TEST_ff_f (scalb, nan_value, nan_value, nan_value);
3463
3464   TEST_ff_f (scalb, 0.8L, 4, 12.8L);
3465   TEST_ff_f (scalb, -0.854375L, 5, -27.34L);
3466
3467   END (scalb);
3468 }
3469
3470
3471 static void
3472 scalbn_test (void)
3473 {
3474
3475   START (scalbn);
3476
3477   TEST_fi_f (scalbn, 0, 0, 0);
3478   TEST_fi_f (scalbn, minus_zero, 0, minus_zero);
3479
3480   TEST_fi_f (scalbn, plus_infty, 1, plus_infty);
3481   TEST_fi_f (scalbn, minus_infty, 1, minus_infty);
3482   TEST_fi_f (scalbn, nan_value, 1, nan_value);
3483
3484   TEST_fi_f (scalbn, 0.8L, 4, 12.8L);
3485   TEST_fi_f (scalbn, -0.854375L, 5, -27.34L);
3486
3487   TEST_fi_f (scalbn, 1, 0L, 1);
3488
3489   END (scalbn);
3490 }
3491
3492 static void
3493 scalbln_test (void)
3494 {
3495
3496   START (scalbln);
3497
3498   TEST_fl_f (scalbln, 0, 0, 0);
3499   TEST_fl_f (scalbln, minus_zero, 0, minus_zero);
3500
3501   TEST_fl_f (scalbln, plus_infty, 1, plus_infty);
3502   TEST_fl_f (scalbln, minus_infty, 1, minus_infty);
3503   TEST_fl_f (scalbln, nan_value, 1, nan_value);
3504
3505   TEST_fl_f (scalbln, 0.8L, 4, 12.8L);
3506   TEST_fl_f (scalbln, -0.854375L, 5, -27.34L);
3507
3508   TEST_fl_f (scalbln, 1, 0L, 1);
3509
3510   END (scalbn);
3511 }
3512
3513 static void
3514 signbit_test (void)
3515 {
3516
3517   START (signbit);
3518
3519   TEST_f_b (signbit, 0, 0);
3520   TEST_f_b (signbit, minus_zero, 1);
3521   TEST_f_b (signbit, plus_infty, 0);
3522   TEST_f_b (signbit, minus_infty, 1);
3523
3524   /* signbit (x) != 0 for x < 0.  */
3525   TEST_f_b (signbit, -1, 1);
3526   /* signbit (x) == 0 for x >= 0.  */
3527   TEST_f_b (signbit, 1, 0);
3528
3529   END (signbit);
3530 }
3531
3532 static void
3533 sin_test (void)
3534 {
3535   START (sin);
3536
3537   TEST_f_f (sin, 0, 0);
3538   TEST_f_f (sin, minus_zero, minus_zero);
3539   TEST_f_f (sin, plus_infty, nan_value, INVALID_EXCEPTION);
3540   TEST_f_f (sin, minus_infty, nan_value, INVALID_EXCEPTION);
3541   TEST_f_f (sin, nan_value, nan_value);
3542
3543   TEST_f_f (sin, M_PI_6l, 0.5);
3544   TEST_f_f (sin, -M_PI_6l, -0.5);
3545   TEST_f_f (sin, M_PI_2l, 1);
3546   TEST_f_f (sin, -M_PI_2l, -1);
3547   TEST_f_f (sin, 0.7, 0.64421768723769105367L);
3548
3549   END (sin);
3550
3551 }
3552
3553 static void
3554 sincos_test (void)
3555 {
3556   FLOAT sin_res, cos_res;
3557
3558   START (sincos);
3559
3560   /* sincos is treated differently because it returns void.  */
3561   TEST_extra (sincos, 0, 0, 1);
3562
3563   TEST_extra (sincos, minus_zero, minus_zero, 1);
3564   TEST_extra (sincos, plus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3565   TEST_extra (sincos, minus_infty, nan_value, nan_value, INVALID_EXCEPTION);
3566   TEST_extra (sincos, nan_value, nan_value, nan_value);
3567
3568   TEST_extra (sincos, M_PI_2l, 1, 0);
3569   TEST_extra (sincos, M_PI_6l, 0.5, 0.866025403784438646764L);
3570   TEST_extra (sincos, M_PI_6l*2.0, 0.866025403784438646764L, 0.5);
3571   TEST_extra (sincos, 0.7, 0.64421768723769105367L, 0.76484218728448842626L);
3572
3573   END (sincos);
3574 }
3575
3576 static void
3577 sinh_test (void)
3578 {
3579   START (sinh);
3580   TEST_f_f (sinh, 0, 0);
3581   TEST_f_f (sinh, minus_zero, minus_zero);
3582
3583 #ifndef TEST_INLINE
3584   TEST_f_f (sinh, plus_infty, plus_infty);
3585   TEST_f_f (sinh, minus_infty, minus_infty);
3586 #endif
3587   TEST_f_f (sinh, nan_value, nan_value);
3588
3589   TEST_f_f (sinh, 0.7, 0.75858370183953350346L);
3590
3591   END (sinh);
3592 }
3593
3594 static void
3595 sqrt_test (void)
3596 {
3597   START (sqrt);
3598
3599   TEST_f_f (sqrt, 0, 0);
3600   TEST_f_f (sqrt, nan_value, nan_value);
3601   TEST_f_f (sqrt, plus_infty, plus_infty);
3602
3603   TEST_f_f (sqrt, minus_zero, minus_zero);
3604
3605   /* sqrt (x) == NaN plus invalid exception for x < 0.  */
3606   TEST_f_f (sqrt, -1, nan_value, INVALID_EXCEPTION);
3607   TEST_f_f (sqrt, minus_infty, nan_value, INVALID_EXCEPTION);
3608   TEST_f_f (sqrt, nan_value, nan_value);
3609
3610   TEST_f_f (sqrt, 2209, 47);
3611   TEST_f_f (sqrt, 4, 2);
3612   TEST_f_f (sqrt, 2, M_SQRT2l);
3613   TEST_f_f (sqrt, 0.25, 0.5);
3614   TEST_f_f (sqrt, 6642.25, 81.5);
3615   TEST_f_f (sqrt, 15239.9025, 123.45);
3616   TEST_f_f (sqrt, 0.7, 0.83666002653407554798L);
3617
3618   END (sqrt);
3619 }
3620
3621 static void
3622 tan_test (void)
3623 {
3624   START (tan);
3625
3626   TEST_f_f (tan, 0, 0);
3627   TEST_f_f (tan, minus_zero, minus_zero);
3628   TEST_f_f (tan, plus_infty, nan_value, INVALID_EXCEPTION);
3629   TEST_f_f (tan, minus_infty, nan_value, INVALID_EXCEPTION);
3630   TEST_f_f (tan, nan_value, nan_value);
3631
3632   TEST_f_f (tan, M_PI_4l, 1);
3633   TEST_f_f (tan, 0.7, 0.84228838046307944813L);
3634
3635   END (tan);
3636 }
3637
3638 static void
3639 tanh_test (void)
3640 {
3641   START (tanh);
3642
3643   TEST_f_f (tanh, 0, 0);
3644   TEST_f_f (tanh, minus_zero, minus_zero);
3645
3646 #ifndef TEST_INLINE
3647   TEST_f_f (tanh, plus_infty, 1);
3648   TEST_f_f (tanh, minus_infty, -1);
3649 #endif
3650   TEST_f_f (tanh, nan_value, nan_value);
3651
3652   TEST_f_f (tanh, 0.7, 0.60436777711716349631L);
3653
3654   END (tanh);
3655 }
3656
3657 static void
3658 tgamma_test (void)
3659 {
3660   errno = 0;
3661   FUNC(tgamma) (1);
3662   if (errno == ENOSYS)
3663     /* Function not implemented.  */
3664     return;
3665   feclearexcept (FE_ALL_EXCEPT);
3666
3667   START (tgamma);
3668
3669   TEST_f_f (tgamma, plus_infty, plus_infty);
3670   TEST_f_f (tgamma, 0, nan_value, INVALID_EXCEPTION);
3671   TEST_f_f (tgamma, minus_zero, nan_value, INVALID_EXCEPTION);
3672   /* tgamma (x) == NaN plus invalid exception for integer x <= 0.  */
3673   TEST_f_f (tgamma, -2, nan_value, INVALID_EXCEPTION);
3674   TEST_f_f (tgamma, minus_infty, nan_value, INVALID_EXCEPTION);
3675   TEST_f_f (tgamma, nan_value, nan_value);
3676
3677   TEST_f_f (tgamma, 0.5, M_SQRT_PIl);
3678   TEST_f_f (tgamma, -0.5, -M_2_SQRT_PIl);
3679
3680   TEST_f_f (tgamma, 1, 1);
3681   TEST_f_f (tgamma, 4, 6);
3682
3683   TEST_f_f (tgamma, 0.7, 1.29805533264755778568L);
3684   TEST_f_f (tgamma, 1.2, 0.91816874239976061064L);
3685
3686   END (tgamma);
3687 }
3688
3689 static void
3690 trunc_test (void)
3691 {
3692   START (trunc);
3693
3694   TEST_f_f (trunc, plus_infty, plus_infty);
3695   TEST_f_f (trunc, minus_infty, minus_infty);
3696   TEST_f_f (trunc, nan_value, nan_value);
3697
3698   TEST_f_f (trunc, 0, 0);
3699   TEST_f_f (trunc, minus_zero, minus_zero);
3700   TEST_f_f (trunc, 0.625, 0);
3701   TEST_f_f (trunc, -0.625, minus_zero);
3702   TEST_f_f (trunc, 1, 1);
3703   TEST_f_f (trunc, -1, -1);
3704   TEST_f_f (trunc, 1.625, 1);
3705   TEST_f_f (trunc, -1.625, -1);
3706
3707   TEST_f_f (trunc, 1048580.625L, 1048580L);
3708   TEST_f_f (trunc, -1048580.625L, -1048580L);
3709
3710   TEST_f_f (trunc, 8388610.125L, 8388610.0L);
3711   TEST_f_f (trunc, -8388610.125L, -8388610.0L);
3712
3713   TEST_f_f (trunc, 4294967296.625L, 4294967296.0L);
3714   TEST_f_f (trunc, -4294967296.625L, -4294967296.0L);
3715
3716
3717   END (trunc);
3718 }
3719
3720 static void
3721 y0_test (void)
3722 {
3723   errno = 0;
3724   FUNC(y0) (1);
3725   if (errno == ENOSYS)
3726     /* Function not implemented.  */
3727     return;
3728
3729   /* y0 is the Bessel function of the second kind of order 0 */
3730   START (y0);
3731
3732   TEST_f_f (y0, -1.0, minus_infty);
3733   TEST_f_f (y0, 0.0, minus_infty);
3734   TEST_f_f (y0, nan_value, nan_value);
3735   TEST_f_f (y0, plus_infty, 0);
3736
3737   TEST_f_f (y0, 0.1, -1.5342386513503668441);
3738   TEST_f_f (y0, 0.7, -0.19066492933739506743);
3739   TEST_f_f (y0, 1.0, 0.088256964215676957983);
3740   TEST_f_f (y0, 1.5, 0.38244892379775884396);
3741   TEST_f_f (y0, 2.0, 0.51037567264974511960);
3742   TEST_f_f (y0, 8.0, 0.22352148938756622053);
3743   TEST_f_f (y0, 10.0, 0.055671167283599391424);
3744
3745   END (y0);
3746 }
3747
3748
3749 static void
3750 y1_test (void)
3751 {
3752   errno = 0;
3753   FUNC(y1) (1);
3754   if (errno == ENOSYS)
3755     /* Function not implemented.  */
3756     return;
3757
3758   /* y1 is the Bessel function of the second kind of order 1 */
3759   START (y1);
3760
3761   TEST_f_f (y1, -1.0, minus_infty);
3762   TEST_f_f (y1, 0.0, minus_infty);
3763   TEST_f_f (y1, plus_infty, 0);
3764   TEST_f_f (y1, nan_value, nan_value);
3765
3766   TEST_f_f (y1, 0.1, -6.4589510947020269877);
3767   TEST_f_f (y1, 0.7, -1.1032498719076333697);
3768   TEST_f_f (y1, 1.0, -0.78121282130028871655);
3769   TEST_f_f (y1, 1.5, -0.41230862697391129595);
3770   TEST_f_f (y1, 2.0, -0.10703243154093754689);
3771   TEST_f_f (y1, 8.0, -0.15806046173124749426);
3772   TEST_f_f (y1, 10.0, 0.24901542420695388392);
3773
3774   END (y1);
3775 }
3776
3777 static void
3778 yn_test (void)
3779 {
3780   errno = 0;
3781   FUNC(yn) (1, 1);
3782   if (errno == ENOSYS)
3783     /* Function not implemented.  */
3784     return;
3785
3786   /* yn is the Bessel function of the second kind of order n */
3787   START (yn);
3788
3789   /* yn (0, x) == y0 (x)  */
3790   TEST_ff_f (yn, 0, -1.0, minus_infty);
3791   TEST_ff_f (yn, 0, 0.0, minus_infty);
3792   TEST_ff_f (yn, 0, nan_value, nan_value);
3793   TEST_ff_f (yn, 0, plus_infty, 0);
3794
3795   TEST_ff_f (yn, 0, 0.1, -1.5342386513503668441);
3796   TEST_ff_f (yn, 0, 0.7, -0.19066492933739506743);
3797   TEST_ff_f (yn, 0, 1.0, 0.088256964215676957983);
3798   TEST_ff_f (yn, 0, 1.5, 0.38244892379775884396);
3799   TEST_ff_f (yn, 0, 2.0, 0.51037567264974511960);
3800   TEST_ff_f (yn, 0, 8.0, 0.22352148938756622053);
3801   TEST_ff_f (yn, 0, 10.0, 0.055671167283599391424);
3802
3803   /* yn (1, x) == y1 (x)  */
3804   TEST_ff_f (yn, 1, -1.0, minus_infty);
3805   TEST_ff_f (yn, 1, 0.0, minus_infty);
3806   TEST_ff_f (yn, 1, plus_infty, 0);
3807   TEST_ff_f (yn, 1, nan_value, nan_value);
3808
3809   TEST_ff_f (yn, 1, 0.1, -6.4589510947020269877);
3810   TEST_ff_f (yn, 1, 0.7, -1.1032498719076333697);