(gmp-objs): Add udiv_qrnnd.
[kopensolaris-gnu/glibc.git] / math / libm-test.c
1 /* Copyright (C) 1997, 1998 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
21 /*
22    Part of testsuite for libm.
23
24    This file has to be included by a master file that defines:
25
26    Makros:
27    FUNC(function): converts general function name (like cos) to
28    name with correct suffix (e.g. cosl or cosf)
29    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
30    MATHTYPE:       floating point type to test
31    TEST_MSG:       informal message to be displayed
32    CHOOSE(Clongdouble,Cdouble,Cfloat):
33    chooses one of the parameters as epsilon for testing
34    equality
35    PRINTF_EXPR     Floating point conversion specification to print a variable
36    of type MATHTYPE with printf. PRINTF_EXPR just contains
37    the specifier, not the percent and width arguments,
38    e.g. "f".
39    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
40  */
41
42 /* This program isn't finished yet.
43    It has tests for:
44    acos, acosh, asin, asinh, atan, atan2, atanh,
45    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
46    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
47    frexp, gamma, hypot,
48    ilogb, isfinite, isinf, isnan, isnormal,
49    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
50    ldexp, lgamma, log, log10, log1p, log2, logb,
51    modf, nearbyint, nextafter,
52    pow, remainder, remquo, rint, lrint, llrint,
53    round, lround, llround,
54    scalb, scalbn, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc
55
56    and for the following complex math functions:
57    cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,
58    ccos, ccosh, cexp, clog, cpow, csin, csinh, csqrt, ctan, ctanh.
59
60    At the moment the following functions aren't tested:
61 OB   conj, cproj, cimag, creal, drem,
62    j0, j1, jn, y0, y1, yn,
63    significand,
64    nan
65
66    The routines using random variables are still under construction. I don't
67    like it the way it's working now and will change it.
68
69    Parameter handling is primitive in the moment:
70    --verbose=[0..4] for different levels of output:
71    0: only error count
72    1: basic report on failed tests (default)
73    2: full report on failed tests
74    3: full report on failed and passed tests
75    4: additional report on exceptions
76    -v for full output (equals --verbose=4)
77    -s,--silent outputs only the error count (equals --verbose=0)
78  */
79
80 /* "Philosophy":
81
82    This suite tests some aspects of the correct implementation of
83    mathematical functions in libm.  Some simple, specific parameters
84    are tested for correctness but there's no exhaustive
85    testing. Handling of specific inputs (e.g. infinity, not-a-number)
86    is also tested. Correct handling of exceptions is checked
87    against. These implemented tests should check all cases that are
88    specified in ISO C 9X.
89
90    Exception testing: At the moment only divide-by-zero and invalid
91    exceptions are tested. Overflow/underflow and inexact exceptions
92    aren't checked at the moment.
93
94    NaN values: There exist signalling and quiet NaNs. This implementation
95    only uses signalling NaN as parameter but does not differenciate
96    between the two kinds of NaNs as result.
97
98    Inline functions: Inlining functions should give an improvement in
99    speed - but not in precission. The inlined functions return
100    reasonable values for a reasonable range of input values. The
101    result is not necessarily correct for all values and exceptions are
102    not correctly raised in all cases. Problematic input and return
103    values are infinity, not-a-number and minus zero. This suite
104    therefore does not check these specific inputs and the exception
105    handling for inlined mathematical functions - just the "reasonable"
106    values are checked.
107
108    Beware: The tests might fail for any of the following reasons:
109    - Tests are wrong
110    - Functions are wrong
111    - Floating Point Unit not working properly
112    - Compiler has errors
113
114    With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error.
115
116 */
117
118 #ifndef _GNU_SOURCE
119 # define _GNU_SOURCE
120 #endif
121
122 #include <complex.h>
123 #include <math.h>
124 #include <float.h>
125 #include <fenv.h>
126
127 #include <errno.h>
128 #include <stdlib.h>
129 #include <stdio.h>
130 #include <getopt.h>
131
132 /* Possible exceptions */
133 #define NO_EXCEPTION             0x0
134 #define INVALID_EXCEPTION        0x1
135 #define DIVIDE_BY_ZERO_EXCEPTION 0x2
136
137 #define PRINT 1
138 #define NO_PRINT 0
139
140 /* Various constants (we must supply them precalculated for accuracy).  */
141 #define M_PI_6l  .52359877559829887308L
142 #define M_E2l   7.389056098930650227230L
143 #define M_E3l   20.08553692318766774093L
144
145 static int noErrors;   /* number of errors */
146 static int noTests;    /* number of tests (without testing exceptions) */
147 static int noExcTests; /* number of tests for exception flags */
148
149 static int verbose = 3;
150 static MATHTYPE minus_zero, plus_zero;
151 static MATHTYPE plus_infty, minus_infty, nan_value;
152
153 typedef MATHTYPE (*mathfunc) (MATHTYPE);
154
155 #define BUILD_COMPLEX(real, imag) \
156   ({ __complex__ MATHTYPE __retval;                                           \
157      __real__ __retval = (real);                                              \
158      __imag__ __retval = (imag);                                              \
159      __retval; })
160
161
162 #define ISINF(x) \
163 (sizeof (x) == sizeof (float) ?                                               \
164  isinff (x)                                                                   \
165  : sizeof (x) == sizeof (double) ?                                            \
166  isinf (x) : isinfl (x))
167
168
169      /*
170         Test if Floating-Point stack hasn't changed
171       */
172 static void
173 fpstack_test (const char *test_name)
174 {
175 #ifdef i386
176   static int old_stack;
177   int sw;
178 asm ("fnstsw":"=a" (sw));
179   sw >>= 11;
180   sw &= 7;
181   if (sw != old_stack)
182     {
183       printf ("FP-Stack wrong after test %s\n", test_name);
184       if (verbose > 2)
185         printf ("=======> stack = %d\n", sw);
186       ++noErrors;
187       old_stack = sw;
188     }
189 #endif
190 }
191
192
193 /*
194    Get a random value x with min_value < x < max_value
195    and min_value, max_value finite,
196    max_value and min_value shouldn't be too close together
197  */
198 static MATHTYPE
199 random_value (MATHTYPE min_value, MATHTYPE max_value)
200 {
201   int r;
202   MATHTYPE x;
203
204   r = rand ();
205
206   x = (max_value - min_value) / RAND_MAX * (MATHTYPE) r + min_value;
207
208   if ((x <= min_value) || (x >= max_value) || !isfinite (x))
209     x = (max_value - min_value) / 2 + min_value;
210
211   /* Make sure the RNG has no influence on the exceptions.  */
212   feclearexcept (FE_ALL_EXCEPT);
213
214   return x;
215 }
216
217 /* Get a random value x with x > min_value.  */
218 static MATHTYPE
219 random_greater (MATHTYPE min_value)
220 {
221   return random_value (min_value, 1e6);         /* CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX) */
222 }
223
224 /* Get a random value x with x < max_value.  */
225 static MATHTYPE
226 random_less (MATHTYPE max_value)
227 {
228   return random_value (-1e6, max_value);
229 }
230
231
232 static void
233 output_new_test (const char *test_name)
234 {
235   if (verbose > 2)
236     printf ("\nTesting: %s\n", test_name);
237 }
238
239
240 static void
241 output_pass_value (void)
242 {
243   if (verbose > 2)
244     printf ("Pass: Value Ok.\n");
245 }
246
247
248 static void
249 output_fail_value (const char * test_name)
250 {
251   if (verbose > 0 && verbose < 3)
252     printf ("Fail: %s\n", test_name);
253   if (verbose >= 3)
254     printf ("Fail:\n");
255 }
256
257
258 /* Test whether a given exception was raised.  */
259 static void
260 test_single_exception (const char *test_name,
261                        short int exception,
262                        short int exc_flag,
263                        int fe_flag,
264                        const char *flag_name)
265 {
266 #ifndef TEST_INLINE
267   if (exception & exc_flag)
268     {
269       if (fetestexcept (fe_flag))
270         {
271           if (verbose > 3)
272             printf ("Pass: Exception \"%s\" set\n", flag_name);
273         }
274       else
275         {
276           if (verbose && verbose < 3)
277             printf ("Fail: %s: Exception \"%s\" not set\n",
278                     test_name, flag_name);
279           if (verbose >= 3)
280             printf ("Fail:  Exception \"%s\" not set\n",
281                     flag_name);
282           ++noErrors;
283         }
284     }
285   else
286     {
287       if (fetestexcept (fe_flag))
288         {
289           if (verbose  && verbose < 3)
290             printf ("Fail: %s: Exception \"%s\" set\n",
291                     test_name, flag_name);
292           if (verbose >= 3)
293             printf ("Fail:  Exception \"%s\" set\n",
294                     flag_name);
295           ++noErrors;
296         }
297       else
298         {
299           if (verbose > 3)
300             printf ("Pass: Exception \"%s\" not set\n",
301                     flag_name);
302         }
303     }
304 #endif
305 }
306
307
308 /* Test whether exception given by EXCEPTION are raised.  */
309 static void
310 test_not_exception (const char *test_name, short int exception)
311 {
312   ++noExcTests;
313 #ifdef FE_DIVBYZERO
314   if ((exception & DIVIDE_BY_ZERO_EXCEPTION) == 0)
315     test_single_exception (test_name, exception,
316                            DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
317                            "Divide by zero");
318 #endif
319 #ifdef FE_INVALID
320   if ((exception & INVALID_EXCEPTION) == 0)
321     test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
322                            "Invalid operation");
323 #endif
324   feclearexcept (FE_ALL_EXCEPT);
325 }
326
327
328 /* Test whether exceptions given by EXCEPTION are raised.  */
329 static void
330 test_exceptions (const char *test_name, short int exception)
331 {
332   ++noExcTests;
333 #ifdef FE_DIVBYZERO
334   test_single_exception (test_name, exception,
335                          DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,
336                          "Divide by zero");
337 #endif
338 #ifdef FE_INVALID
339   test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,
340                          "Invalid operation");
341 #endif
342   feclearexcept (FE_ALL_EXCEPT);
343 }
344
345
346 /* Test if two floating point numbers are equal.  */
347 static int
348 check_equal (MATHTYPE computed, MATHTYPE supplied, MATHTYPE eps, MATHTYPE * diff)
349 {
350   int ret_value;
351
352   /* Both plus Infinity or both minus infinity.  */
353   if (ISINF (computed) && (ISINF (computed) == ISINF (supplied)))
354     return 1;
355
356   if (isnan (computed) && isnan (supplied))     /* isnan works for all types */
357     return 1;
358
359   *diff = FUNC(fabs) (computed - supplied);
360
361
362   ret_value = (*diff <= eps &&
363                (signbit (computed) == signbit (supplied) || eps != 0.0));
364
365   /* Make sure the subtraction/comparison have no influence on the exceptions. */
366   feclearexcept (FE_ALL_EXCEPT);
367
368   return ret_value;
369 }
370
371
372
373 static void
374 output_result_bool (const char *test_name, int result)
375 {
376   ++noTests;
377   if (result)
378     {
379       output_pass_value ();
380     }
381   else
382     {
383       output_fail_value (test_name);
384       if (verbose > 1)
385         printf (" Value: %d\n", result);
386       ++noErrors;
387     }
388
389   fpstack_test (test_name);
390 }
391
392
393 static void
394 output_isvalue (const char *test_name, int result,
395                 MATHTYPE value)
396 {
397   ++noTests;
398   if (result)
399     {
400       output_pass_value ();
401     }
402   else
403     {
404       output_fail_value (test_name);
405       if (verbose > 1)
406         printf (" Value: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
407                 value, value);
408       ++noErrors;
409     }
410
411   fpstack_test (test_name);
412 }
413
414
415 static void
416 output_isvalue_ext (const char *test_name, int result,
417                     MATHTYPE value, MATHTYPE parameter)
418 {
419   ++noTests;
420   if (result)
421     {
422       output_pass_value ();
423     }
424   else
425     {
426       output_fail_value (test_name);
427       if (verbose > 1)
428         {
429           printf (" Value:     % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
430                   value, value);
431           printf (" Parameter: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
432                   parameter, parameter);
433         }
434       noErrors++;
435     }
436
437   fpstack_test (test_name);
438 }
439
440
441 static void
442 output_result (const char *test_name, int result,
443                MATHTYPE computed, MATHTYPE expected,
444                MATHTYPE difference,
445                int print_values, int print_diff)
446 {
447   ++noTests;
448   if (result)
449     {
450       output_pass_value ();
451     }
452   else
453     {
454       output_fail_value (test_name);
455       if (verbose > 1 && print_values)
456         {
457           printf ("Result:\n");
458           printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
459                   computed, computed);
460           printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
461                   expected, expected);
462           if (print_diff)
463             printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
464                     "\n", difference, difference);
465         }
466       ++noErrors;
467     }
468
469   fpstack_test (test_name);
470 }
471
472
473 static void
474 output_result_ext (const char *test_name, int result,
475                    MATHTYPE computed, MATHTYPE expected,
476                    MATHTYPE difference,
477                    MATHTYPE parameter,
478                    int print_values, int print_diff)
479 {
480   ++noTests;
481   if (result)
482     {
483       output_pass_value ();
484     }
485   else
486     {
487       output_fail_value (test_name);
488       if (verbose > 1 && print_values)
489         {
490           printf ("Result:\n");
491           printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
492                   computed, computed);
493           printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
494                   expected, expected);
495           if (print_diff)
496             printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR
497                     "\n", difference, difference);
498           printf ("Parameter:   % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",
499                   parameter, parameter);
500         }
501       ++noErrors;
502     }
503
504   fpstack_test (test_name);
505 }
506
507 /*
508   check that computed and expected values are the same
509  */
510 static void
511 check (const char *test_name, MATHTYPE computed, MATHTYPE expected)
512 {
513   MATHTYPE diff;
514   int result;
515
516   output_new_test (test_name);
517   test_exceptions (test_name, NO_EXCEPTION);
518   result = check_equal (computed, expected, 0, &diff);
519   output_result (test_name, result,
520                  computed, expected, diff, PRINT, PRINT);
521 }
522
523
524 /*
525   check that computed and expected values are the same,
526   outputs the parameter to the function
527  */
528 static void
529 check_ext (const char *test_name, MATHTYPE computed, MATHTYPE expected,
530            MATHTYPE parameter)
531 {
532   MATHTYPE diff;
533   int result;
534
535   output_new_test (test_name);
536   test_exceptions (test_name, NO_EXCEPTION);
537   result = check_equal (computed, expected, 0, &diff);
538   output_result_ext (test_name, result,
539                      computed, expected, diff, parameter, PRINT, PRINT);
540 }
541
542
543 /*
544   check that computed and expected values are the same and
545   checks also for exception flags
546  */
547 static void
548 check_exc (const char *test_name, MATHTYPE computed, MATHTYPE expected,
549            short exception)
550 {
551   MATHTYPE diff;
552   int result;
553
554   output_new_test (test_name);
555   test_exceptions (test_name, exception);
556   result = check_equal (computed, expected, 0, &diff);
557   output_result (test_name, result,
558                  computed, expected, diff, PRINT, PRINT);
559 }
560
561 /*
562   check that computed and expected values are close enough
563  */
564 static void
565 check_eps (const char *test_name, MATHTYPE computed, MATHTYPE expected,
566            MATHTYPE epsilon)
567 {
568   MATHTYPE diff;
569   int result;
570
571   output_new_test (test_name);
572   test_exceptions (test_name, NO_EXCEPTION);
573   result = check_equal (computed, expected, epsilon, &diff);
574   output_result (test_name, result,
575                  computed, expected, diff, PRINT, PRINT);
576 }
577
578 /*
579   check a boolean condition
580  */
581 static void
582 check_bool (const char *test_name, int computed)
583 {
584   output_new_test (test_name);
585   test_exceptions (test_name, NO_EXCEPTION);
586   output_result_bool (test_name, computed);
587 }
588
589
590
591 /*
592   check that computed and expected values are equal (int values)
593  */
594 static void
595 check_int (const char *test_name, int computed, int expected)
596 {
597   int diff = computed - expected;
598   int result = diff == 0;
599
600   output_new_test (test_name);
601   test_exceptions (test_name, NO_EXCEPTION);
602
603   if (result)
604     {
605       output_pass_value ();
606     }
607   else
608     {
609       output_fail_value (test_name);
610       if (verbose > 1)
611         {
612           printf ("Result:\n");
613           printf (" is:         %d\n", computed);
614           printf (" should be:  %d\n", expected);
615         }
616       noErrors++;
617     }
618
619   fpstack_test (test_name);
620 }
621
622
623 /*
624   check that computed and expected values are equal (long int values)
625  */
626 static void
627 check_long (const char *test_name, long int computed, long int expected)
628 {
629   long int diff = computed - expected;
630   int result = diff == 0;
631
632   ++noTests;
633   output_new_test (test_name);
634   test_exceptions (test_name, NO_EXCEPTION);
635
636   if (result)
637     {
638       output_pass_value ();
639     }
640   else
641     {
642       output_fail_value (test_name);
643       if (verbose > 1)
644         {
645           printf ("Result:\n");
646           printf (" is:         %ld\n", computed);
647           printf (" should be:  %ld\n", expected);
648         }
649       noErrors++;
650     }
651
652   fpstack_test (test_name);
653 }
654
655 /*
656   check that computed and expected values are equal (long long int values)
657  */
658 static void
659 check_longlong (const char *test_name, long long int computed,
660                 long long int expected)
661 {
662   long long int diff = computed - expected;
663   int result = diff == 0;
664
665   ++noTests;
666   output_new_test (test_name);
667   test_exceptions (test_name, NO_EXCEPTION);
668
669   if (result)
670     {
671       output_pass_value ();
672     }
673   else
674     {
675       output_fail_value (test_name);
676       if (verbose > 1)
677         {
678           printf ("Result:\n");
679           printf (" is:         %lld\n", computed);
680           printf (" should be:  %lld\n", expected);
681         }
682       noErrors++;
683     }
684
685   fpstack_test (test_name);
686 }
687
688 /*
689   check that computed value is not-a-number
690  */
691 static void
692 check_isnan (const char *test_name, MATHTYPE computed)
693 {
694   output_new_test (test_name);
695   test_exceptions (test_name, NO_EXCEPTION);
696   output_isvalue (test_name, isnan (computed), computed);
697 }
698
699
700 /*
701   check that computed value is not-a-number and test for exceptions
702  */
703 static void
704 check_isnan_exc (const char *test_name, MATHTYPE computed,
705                  short exception)
706 {
707   output_new_test (test_name);
708   test_exceptions (test_name, exception);
709   output_isvalue (test_name, isnan (computed), computed);
710 }
711
712
713 /*
714   check that computed value is not-a-number and test for exceptions
715  */
716 static void
717 check_isnan_maybe_exc (const char *test_name, MATHTYPE computed,
718                        short exception)
719 {
720   output_new_test (test_name);
721   test_not_exception (test_name, exception);
722   output_isvalue (test_name, isnan (computed), computed);
723 }
724
725 /*
726   check that computed value is not-a-number and supply parameter
727  */
728 #ifndef TEST_INLINE
729 static void
730 check_isnan_ext (const char *test_name, MATHTYPE computed,
731                  MATHTYPE parameter)
732 {
733   output_new_test (test_name);
734   test_exceptions (test_name, NO_EXCEPTION);
735   output_isvalue_ext (test_name, isnan (computed), computed, parameter);
736 }
737 #endif
738
739 /*
740   check that computed value is not-a-number, test for exceptions
741   and supply parameter
742  */
743 static void
744 check_isnan_exc_ext (const char *test_name, MATHTYPE computed,
745                      short exception, MATHTYPE parameter)
746 {
747   output_new_test (test_name);
748   test_exceptions (test_name,exception);
749   output_isvalue_ext (test_name, isnan (computed), computed, parameter);
750 }
751
752
753 /* Tests if computed is +Inf */
754 static void
755 check_isinfp (const char *test_name, MATHTYPE computed)
756 {
757   output_new_test (test_name);
758   test_exceptions (test_name, NO_EXCEPTION);
759   output_isvalue (test_name, (ISINF (computed) == +1), computed);
760 }
761
762
763 static void
764 check_isinfp_ext (const char *test_name, MATHTYPE computed,
765                   MATHTYPE parameter)
766 {
767   output_new_test (test_name);
768   test_exceptions (test_name, NO_EXCEPTION);
769   output_isvalue_ext (test_name, (ISINF (computed) == +1), computed, parameter);
770 }
771
772
773 /* Tests if computed is +Inf */
774 static void
775 check_isinfp_exc (const char *test_name, MATHTYPE computed,
776                   int exception)
777 {
778   output_new_test (test_name);
779   test_exceptions (test_name, exception);
780   output_isvalue (test_name, (ISINF (computed) == +1), computed);
781 }
782
783 /* Tests if computed is -Inf */
784 static void
785 check_isinfn (const char *test_name, MATHTYPE computed)
786 {
787   output_new_test (test_name);
788   test_exceptions (test_name, NO_EXCEPTION);
789   output_isvalue (test_name, (ISINF (computed) == -1), computed);
790 }
791
792
793 #ifndef TEST_INLINE
794 static void
795 check_isinfn_ext (const char *test_name, MATHTYPE computed,
796                   MATHTYPE parameter)
797 {
798   output_new_test (test_name);
799   test_exceptions (test_name, NO_EXCEPTION);
800   output_isvalue_ext (test_name, (ISINF (computed) == -1), computed, parameter);
801 }
802 #endif
803
804
805 /* Tests if computed is -Inf */
806 static void
807 check_isinfn_exc (const char *test_name, MATHTYPE computed,
808                   int exception)
809 {
810   output_new_test (test_name);
811   test_exceptions (test_name, exception);
812   output_isvalue (test_name, (ISINF (computed) == -1), computed);
813 }
814
815
816 /* This is to prevent messages from the SVID libm emulation.  */
817 int
818 matherr (struct exception *x __attribute__ ((unused)))
819 {
820   return 1;
821 }
822
823
824 /****************************************************************************
825   Test for single functions of libm
826 ****************************************************************************/
827
828 static void
829 acos_test (void)
830 {
831 #ifndef TEST_INLINE
832   MATHTYPE x;
833
834   x = random_greater (1);
835   check_isnan_exc ("acos (x) == NaN plus invalid exception for |x| > 1",
836                    FUNC(acos) (x),
837                    INVALID_EXCEPTION);
838
839   x = random_less (1);
840   check_isnan_exc ("acos (x) == NaN plus invalid exception for |x| > 1",
841                    FUNC(acos) (x),
842                    INVALID_EXCEPTION);
843 #endif
844   check ("acos (0) == pi/2", FUNC(acos) (0), M_PI_2l);
845   check ("acos (-0) == pi/2", FUNC(acos) (minus_zero), M_PI_2l);
846
847   check ("acos (1) == 0", FUNC(acos) (1), 0);
848   check ("acos (-1) == pi", FUNC(acos) (-1), M_PIl);
849
850   check_eps ("acos (0.5) == pi/3", FUNC(acos) (0.5), M_PI_6l * 2.0,
851              CHOOSE (1e-18, 0, 0));
852   check_eps ("acos (-0.5) == 2*pi/3", FUNC(acos) (-0.5), M_PI_6l * 4.0,
853              CHOOSE (1e-17, 0, 0));
854
855   check_eps ("acos (0.7) == 0.795398830...", FUNC(acos) (0.7),
856              0.7953988301841435554L, CHOOSE(7e-17L, 0, 0));
857
858 }
859
860
861 static void
862 acosh_test (void)
863 {
864 #ifndef TEST_INLINE
865   MATHTYPE x;
866
867   check_isinfp ("acosh(+inf) == +inf", FUNC(acosh) (plus_infty));
868
869   x = random_less (1);
870   check_isnan_exc ("acosh(x) == NaN plus invalid exception if x < 1",
871                    FUNC(acosh) (x), INVALID_EXCEPTION);
872 #endif
873
874   check ("acosh(1) == 0", FUNC(acosh) (1), 0);
875   check_eps ("acosh(7) == 2.633915793...", FUNC(acosh) (7),
876              2.6339157938496334172L, CHOOSE (3e-19, 0, 0));
877 }
878
879
880 static void
881 asin_test (void)
882 {
883 #ifndef TEST_INLINE
884   MATHTYPE x;
885
886   x = random_greater (1);
887   check_isnan_exc ("asin x == NaN plus invalid exception for |x| > 1",
888                    FUNC(asin) (x),
889                    INVALID_EXCEPTION);
890
891   x = random_less (1);
892   check_isnan_exc ("asin x == NaN plus invalid exception for |x| > 1",
893                    FUNC(asin) (x),
894                    INVALID_EXCEPTION);
895 #endif
896
897   check ("asin (0) == 0", FUNC(asin) (0), 0);
898   check ("asin (-0) == -0", FUNC(asin) (minus_zero), minus_zero);
899   check_eps ("asin (0.5) ==  pi/6", FUNC(asin) (0.5), M_PI_6l,
900              CHOOSE(3.5e-18, 0, 2e-7));
901   check_eps ("asin (-0.5) ==  -pi/6", FUNC(asin) (-0.5), -M_PI_6l,
902              CHOOSE(3.5e-18, 0, 2e-7));
903   check ("asin (1.0) ==  pi/2", FUNC(asin) (1.0), M_PI_2l);
904   check ("asin (-1.0) ==  -pi/2", FUNC(asin) (-1.0), -M_PI_2l);
905   check_eps ("asin (0.7) ==  0.775397496...", FUNC(asin) (0.7),
906              0.7753974966107530637L, CHOOSE(7e-17L, 2e-16, 2e-7));
907 }
908
909
910 static void
911 asinh_test (void)
912 {
913
914   check ("asinh(+0) == +0", FUNC(asinh) (0), 0);
915 #ifndef TEST_INLINE
916   check ("asinh(-0) == -0", FUNC(asinh) (minus_zero), minus_zero);
917   check_isinfp ("asinh(+inf) == +inf", FUNC(asinh) (plus_infty));
918   check_isinfn ("asinh(-inf) == -inf", FUNC(asinh) (minus_infty));
919 #endif
920   check_eps ("asinh(0.7) == 0.652666566...", FUNC(asinh) (0.7),
921              0.652666566082355786L, CHOOSE(4e-17L, 0, 6e-8));
922
923 }
924
925
926 static void
927 atan_test (void)
928 {
929   check ("atan (0) == 0", FUNC(atan) (0), 0);
930   check ("atan (-0) == -0", FUNC(atan) (minus_zero), minus_zero);
931
932   check ("atan (+inf) == pi/2", FUNC(atan) (plus_infty), M_PI_2l);
933   check ("atan (-inf) == -pi/2", FUNC(atan) (minus_infty), -M_PI_2l);
934
935   check_eps ("atan (1) == pi/4", FUNC(atan) (1), M_PI_4l,
936              CHOOSE (1e-18, 0, 0));
937   check_eps ("atan (-1) == -pi/4", FUNC(atan) (1), M_PI_4l,
938              CHOOSE (1e-18, 0, 0));
939
940   check_eps ("atan (0.7) == 0.610725964...", FUNC(atan) (0.7),
941              0.6107259643892086165L, CHOOSE(3e-17L, 0, 0));
942 }
943
944
945 static void
946 atan2_test (void)
947 {
948   MATHTYPE x;
949
950   x = random_greater (0);
951   check ("atan2 (0,x) == 0 for x > 0",
952          FUNC(atan2) (0, x), 0);
953   x = random_greater (0);
954   check ("atan2 (-0,x) == -0 for x > 0",
955          FUNC(atan2) (minus_zero, x), minus_zero);
956
957   check ("atan2 (+0,+0) == +0", FUNC(atan2) (0, 0), 0);
958   check ("atan2 (-0,+0) == -0", FUNC(atan2) (minus_zero, 0), minus_zero);
959
960   x = -random_greater (0);
961   check ("atan2 (+0,x) == +pi for x < 0", FUNC(atan2) (0, x), M_PIl);
962
963   x = -random_greater (0);
964   check ("atan2 (-0,x) == -pi for x < 0", FUNC(atan2) (minus_zero, x), -M_PIl);
965
966   check ("atan2 (+0,-0) == +pi", FUNC(atan2) (0, minus_zero), M_PIl);
967   check ("atan2 (-0,-0) == -pi", FUNC(atan2) (minus_zero, minus_zero), -M_PIl);
968
969   x = random_greater (0);
970   check ("atan2 (y,+0) == pi/2 for y > 0", FUNC(atan2) (x, 0), M_PI_2l);
971
972   x = random_greater (0);
973   check ("atan2 (y,-0) == pi/2 for y > 0", FUNC(atan2) (x, minus_zero),
974          M_PI_2l);
975
976   x = random_less (0);
977   check ("atan2 (y,+0) == -pi/2 for y < 0", FUNC(atan2) (x, 0), -M_PI_2l);
978
979   x = random_less (0);
980   check ("atan2 (y,-0) == -pi/2 for y < 0", FUNC(atan2) (x, minus_zero),
981          -M_PI_2l);
982
983   x = random_greater (0);
984   check ("atan2 (y,inf) == +0 for finite y > 0",
985          FUNC(atan2) (x, plus_infty), 0);
986
987   x = -random_greater (0);
988   check ("atan2 (y,inf) == -0 for finite y < 0",
989          FUNC(atan2) (x, plus_infty), minus_zero);
990
991   x = random_value (-1e4, 1e4);
992   check ("atan2(+inf, x) == pi/2 for finite x",
993          FUNC(atan2) (plus_infty, x), M_PI_2l);
994
995   x = random_value (-1e4, 1e4);
996   check ("atan2(-inf, x) == -pi/2 for finite x",
997          FUNC(atan2) (minus_infty, x), -M_PI_2l);
998
999   x = random_greater (0);
1000   check ("atan2 (y,-inf) == +pi for finite y > 0",
1001          FUNC(atan2) (x, minus_infty), M_PIl);
1002
1003   x = -random_greater (0);
1004   check ("atan2 (y,-inf) == -pi for finite y < 0",
1005          FUNC(atan2) (x, minus_infty), -M_PIl);
1006
1007   check ("atan2 (+inf,+inf) == +pi/4",
1008          FUNC(atan2) (plus_infty, plus_infty), M_PI_4l);
1009
1010   check ("atan2 (-inf,+inf) == -pi/4",
1011          FUNC(atan2) (minus_infty, plus_infty), -M_PI_4l);
1012
1013   check ("atan2 (+inf,-inf) == +3*pi/4",
1014          FUNC(atan2) (plus_infty, minus_infty), 3 * M_PI_4l);
1015
1016   check ("atan2 (-inf,-inf) == -3*pi/4",
1017          FUNC(atan2) (minus_infty, minus_infty), -3 * M_PI_4l);
1018
1019   /* FIXME: Add some specific tests */
1020   check_eps ("atan2 (0.7,1) == 0.61072...", FUNC(atan2) (0.7,1),
1021              0.6107259643892086165L, CHOOSE(3e-17L, 0, 0));
1022   check_eps ("atan2 (0.4,0.0003) == 1.57004...", FUNC(atan2) (0.4, 0.0003),
1023              1.5700463269355215718L, CHOOSE(2e-19L, 0, 0));
1024
1025 }
1026
1027
1028 static void
1029 atanh_test (void)
1030 {
1031 #ifndef TEST_INLINE
1032   MATHTYPE x;
1033 #endif
1034
1035   check ("atanh(+0) == +0", FUNC(atanh) (0), 0);
1036 #ifndef TEST_INLINE
1037   check ("atanh(-0) == -0", FUNC(atanh) (minus_zero), minus_zero);
1038
1039   check_isinfp_exc ("atanh(+1) == +inf plus divide-by-zero exception",
1040                     FUNC(atanh) (1), DIVIDE_BY_ZERO_EXCEPTION);
1041   check_isinfn_exc ("atanh(-1) == -inf plus divide-by-zero exception",
1042                     FUNC(atanh) (-1), DIVIDE_BY_ZERO_EXCEPTION);
1043
1044   x = random_greater (1.0);
1045   check_isnan_exc_ext ("atanh (x) == NaN plus invalid exception if |x| > 1",
1046                        FUNC(atanh) (x), INVALID_EXCEPTION, x);
1047
1048   x = random_less (1.0);
1049   check_isnan_exc_ext ("atanh (x) == NaN plus invalid exception if |x| > 1",
1050                        FUNC(atanh) (x), INVALID_EXCEPTION, x);
1051
1052 #endif
1053   check_eps ("atanh(0.7) == 0.867300527...", FUNC(atanh) (0.7),
1054              0.8673005276940531944L, CHOOSE(9e-17L, 2e-16, 0));
1055 }
1056
1057
1058 static void
1059 cbrt_test (void)
1060 {
1061   check ("cbrt (+0) == +0", FUNC(cbrt) (0.0), 0.0);
1062   check ("cbrt (-0) == -0", FUNC(cbrt) (minus_zero), minus_zero);
1063
1064 #ifndef TEST_INLINE
1065   check_isinfp ("cbrt (+inf) == +inf", FUNC(cbrt) (plus_infty));
1066   check_isinfn ("cbrt (-inf) == -inf", FUNC(cbrt) (minus_infty));
1067   check_isnan ("cbrt (NaN) == NaN", FUNC(cbrt) (nan_value));
1068 #endif
1069   check_eps ("cbrt (-0.001) == -0.1", FUNC(cbrt) (-0.001), -0.1,
1070              CHOOSE (5e-18L, 0, 0));
1071   check_eps ("cbrt (8) == 2", FUNC(cbrt) (8), 2, CHOOSE (5e-17L, 0, 0));
1072   check_eps ("cbrt (-27) == -3", FUNC(cbrt) (-27.0), -3.0,
1073              CHOOSE (3e-16L, 5e-16, 0));
1074   check_eps ("cbrt (0.970299) == 0.99", FUNC(cbrt) (0.970299), 0.99,
1075              CHOOSE (2e-17L, 2e-16, 0));
1076   check_eps ("cbrt (0.7) == .8879040017...", FUNC(cbrt) (0.7),
1077              0.8879040017426007084L, CHOOSE(2e-17L, 6e-16, 0));
1078
1079 }
1080
1081
1082 static void
1083 ceil_test (void)
1084 {
1085   check ("ceil (+0) == +0", FUNC(ceil) (0.0), 0.0);
1086   check ("ceil (-0) == -0", FUNC(ceil) (minus_zero), minus_zero);
1087   check_isinfp ("ceil (+inf) == +inf", FUNC(ceil) (plus_infty));
1088   check_isinfn ("ceil (-inf) == -inf", FUNC(ceil) (minus_infty));
1089
1090   check ("ceil (pi) == 4", FUNC(ceil) (M_PIl), 4.0);
1091   check ("ceil (-pi) == -3", FUNC(ceil) (-M_PIl), -3.0);
1092 }
1093
1094
1095 static void
1096 cos_test (void)
1097 {
1098
1099   check ("cos (+0) == 1", FUNC(cos) (0), 1);
1100   check ("cos (-0) == 1", FUNC(cos) (minus_zero), 1);
1101   check_isnan_exc ("cos (+inf) == NaN plus invalid exception",
1102                    FUNC(cos) (plus_infty),
1103                    INVALID_EXCEPTION);
1104   check_isnan_exc ("cos (-inf) == NaN plus invalid exception",
1105                    FUNC(cos) (minus_infty),
1106                    INVALID_EXCEPTION);
1107
1108   check_eps ("cos (pi/3) == 0.5", FUNC(cos) (M_PI_6l * 2.0),
1109              0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L));
1110   check_eps ("cos (2*pi/3) == -0.5", FUNC(cos) (M_PI_6l * 4.0),
1111              -0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L));
1112   check_eps ("cos (pi/2) == 0", FUNC(cos) (M_PI_2l),
1113              0, CHOOSE (1e-19L, 1e-16L, 1e-7L));
1114
1115   check_eps ("cos (0.7) == 0.7648421872...", FUNC(cos) (0.7),
1116              0.7648421872844884262L, CHOOSE(3e-17, 2e-16, 6e-8));
1117 }
1118
1119 static void
1120 cosh_test (void)
1121 {
1122   check ("cosh (+0) == 1", FUNC(cosh) (0), 1);
1123   check ("cosh (-0) == 1", FUNC(cosh) (minus_zero), 1);
1124
1125 #ifndef TEST_INLINE
1126   check_isinfp ("cosh (+inf) == +inf", FUNC(cosh) (plus_infty));
1127   check_isinfp ("cosh (-inf) == +inf", FUNC(cosh) (minus_infty));
1128 #endif
1129
1130   check_eps ("cosh (0.7) ==  1.2551690056...", FUNC(cosh) (0.7),
1131              1.255169005630943018L, CHOOSE(4e-17L, 0, 0));
1132 }
1133
1134
1135 static void
1136 erf_test (void)
1137 {
1138   errno = 0;
1139   FUNC(erf) (0);
1140   if (errno == ENOSYS)
1141     /* Function not implemented.  */
1142     return;
1143
1144   check ("erf (+0) == +0", FUNC(erf) (0), 0);
1145   check ("erf (-0) == -0", FUNC(erf) (minus_zero), minus_zero);
1146   check ("erf (+inf) == +1", FUNC(erf) (plus_infty), 1);
1147   check ("erf (-inf) == -1", FUNC(erf) (minus_infty), -1);
1148
1149   check_eps ("erf (0.7) == 0.6778011938...", FUNC(erf) (0.7),
1150              0.67780119383741847297L, CHOOSE(0, 2e-16, 0));
1151 }
1152
1153
1154 static void
1155 erfc_test (void)
1156 {
1157   errno = 0;
1158   FUNC(erfc) (0);
1159   if (errno == ENOSYS)
1160     /* Function not implemented.  */
1161     return;
1162
1163   check ("erfc (+inf) == 0", FUNC(erfc) (plus_infty), 0.0);
1164   check ("erfc (-inf) == 2", FUNC(erfc) (minus_infty), 2.0);
1165   check ("erfc (+0) == 1", FUNC(erfc) (0.0), 1.0);
1166   check ("erfc (-0) == 1", FUNC(erfc) (minus_zero), 1.0);
1167
1168   check_eps ("erfc (0.7) == 0.3221988061...", FUNC(erfc) (0.7),
1169              0.32219880616258152702L, CHOOSE(0, 6e-17, 0));
1170 }
1171
1172
1173 static void
1174 exp_test (void)
1175 {
1176   check ("exp (+0) == 1", FUNC(exp) (0), 1);
1177   check ("exp (-0) == 1", FUNC(exp) (minus_zero), 1);
1178
1179 #ifndef TEST_INLINE
1180   check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty));
1181   check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0);
1182 #endif
1183   check_eps ("exp (1) == e", FUNC(exp) (1), M_El, CHOOSE (4e-18L, 0, 0));
1184
1185   check_eps ("exp (2) == e^2", FUNC(exp) (2), M_E2l,
1186              CHOOSE (1e-18, 0, 0));
1187   check_eps ("exp (3) == e^3", FUNC(exp) (3), M_E3l,
1188              CHOOSE (1.5e-17, 0, 0));
1189   check_eps ("exp (0.7) == 2.0137527074...", FUNC(exp) (0.7),
1190              2.0137527074704765216L, CHOOSE(9e-17L, 0, 0));
1191 }
1192
1193
1194 static void
1195 exp10_test (void)
1196 {
1197   errno = 0;
1198   FUNC(exp10) (0);
1199   if (errno == ENOSYS)
1200     /* Function not implemented.  */
1201     return;
1202
1203   check ("exp10 (+0) == 1", FUNC(exp10) (0), 1);
1204   check ("exp10 (-0) == 1", FUNC(exp10) (minus_zero), 1);
1205
1206   check_isinfp ("exp10 (+inf) == +inf", FUNC(exp10) (plus_infty));
1207   check ("exp10 (-inf) == 0", FUNC(exp10) (minus_infty), 0);
1208   check_eps ("exp10 (3) == 1000", FUNC(exp10) (3), 1000,
1209              CHOOSE(5e-16, 7e-13, 2e-4));
1210   check_eps ("exp10 (-1) == 0.1", FUNC(exp10) (-1), 0.1,
1211              CHOOSE(6e-18, 3e-17, 8e-09));
1212   check_isinfp ("exp10 (1e6) == +inf", FUNC(exp10) (1e6));
1213   check ("exp10 (-1e6) == 0", FUNC(exp10) (-1e6), 0);
1214   check_eps ("exp10 (0.7) == 5.0118723...", FUNC(exp10) (0.7),
1215              5.0118723362727228500L, CHOOSE(6e-16, 9e-16, 5e-7));
1216 }
1217
1218
1219 static void
1220 exp2_test (void)
1221 {
1222   errno = 0;
1223   FUNC(exp2) (0);
1224   if (errno == ENOSYS)
1225     /* Function not implemented.  */
1226     return;
1227
1228   check ("exp2 (+0) == 1", FUNC(exp2) (0), 1);
1229   check ("exp2 (-0) == 1", FUNC(exp2) (minus_zero), 1);
1230
1231   check_isinfp ("exp2 (+inf) == +inf", FUNC(exp2) (plus_infty));
1232   check ("exp2 (-inf) == 0", FUNC(exp2) (minus_infty), 0);
1233   check ("exp2 (10) == 1024", FUNC(exp2) (10), 1024);
1234   check ("exp2 (-1) == 0.5", FUNC(exp2) (-1), 0.5);
1235   check_isinfp ("exp2 (1e6) == +inf", FUNC(exp2) (1e6));
1236   check ("exp2 (-1e6) == 0", FUNC(exp2) (-1e6), 0);
1237   check_eps ("exp2 (0.7) == 1.6245047927...", FUNC(exp2) (0.7),
1238              1.6245047927124710452L, CHOOSE(6e-17L, 0, 6e-8));
1239 }
1240
1241
1242 static void
1243 expm1_test (void)
1244 {
1245   check ("expm1 (+0) == 0", FUNC(expm1) (0), 0);
1246 #ifndef TEST_INLINE
1247   check ("expm1 (-0) == -0", FUNC(expm1) (minus_zero), minus_zero);
1248
1249   check_isinfp ("expm1 (+inf) == +inf", FUNC(expm1) (plus_infty));
1250   check ("expm1 (-inf) == -1", FUNC(expm1) (minus_infty), -1);
1251 #endif
1252
1253   check_eps ("expm1 (1) == e-1", FUNC(expm1) (1), M_El - 1.0,
1254              CHOOSE (4e-18L, 0, 2e-7));
1255
1256   check_eps ("expm1 (0.7) == 1.01375...", FUNC(expm1) (0.7),
1257              1.0137527074704765216L, CHOOSE(9e-17L, 0, 0));
1258 }
1259
1260
1261
1262
1263 static void
1264 check_frexp (const char *test_name, MATHTYPE computed, MATHTYPE expected,
1265              int comp_int, int exp_int)
1266 {
1267   MATHTYPE diff;
1268   int result;
1269
1270   result = (check_equal (computed, expected, 0, &diff)
1271             && (comp_int == exp_int));
1272
1273   if (result)
1274     {
1275       if (verbose > 2)
1276         printf ("Pass: %s\n", test_name);
1277     }
1278   else
1279     {
1280       if (verbose)
1281         printf ("Fail: %s\n", test_name);
1282       if (verbose > 1)
1283         {
1284           printf ("Result:\n");
1285           printf (" is:         %.20" PRINTF_EXPR " *2^%d  %.20"
1286                   PRINTF_XEXPR "*2^%d\n",
1287                   computed, comp_int, computed, comp_int);
1288           printf (" should be:  %.20" PRINTF_EXPR " *2^%d  %.20"
1289                   PRINTF_XEXPR "*2^%d\n",
1290                   expected, exp_int, expected, exp_int);
1291           printf (" difference: %.20" PRINTF_EXPR "  %.20" PRINTF_XEXPR "\n",
1292                   diff, diff);
1293         }
1294       noErrors++;
1295     }
1296   fpstack_test (test_name);
1297   output_result (test_name, result,
1298                  computed, expected, diff, PRINT, PRINT);
1299 }
1300
1301
1302 static void
1303 frexp_test (void)
1304 {
1305   int x_int;
1306   MATHTYPE result;
1307
1308   result = FUNC(frexp) (plus_infty, &x_int);
1309   check_isinfp ("frexp (+inf, expr) == +inf", result);
1310
1311   result = FUNC(frexp) (minus_infty, &x_int);
1312   check_isinfn ("frexp (-inf, expr) == -inf", result);
1313
1314   result = FUNC(frexp) (nan_value, &x_int);
1315   check_isnan ("frexp (Nan, expr) == NaN", result);
1316
1317   result = FUNC(frexp) (0, &x_int);
1318   check_frexp ("frexp: +0 == 0 * 2^0", result, 0, x_int, 0);
1319
1320   result = FUNC(frexp) (minus_zero, &x_int);
1321   check_frexp ("frexp: -0 == -0 * 2^0", result, minus_zero, x_int, 0);
1322
1323   result = FUNC(frexp) (12.8L, &x_int);
1324   check_frexp ("frexp: 12.8 == 0.8 * 2^4", result, 0.8L, x_int, 4);
1325
1326   result = FUNC(frexp) (-27.34L, &x_int);
1327   check_frexp ("frexp: -27.34 == -0.854375 * 2^5", result, -0.854375L, x_int, 5);
1328
1329 }
1330
1331
1332 #if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1)
1333 /* All floating-point numbers can be put in one of these categories.  */
1334 enum
1335 {
1336   FP_NAN,
1337 #define FP_NAN FP_NAN
1338   FP_INFINITE,
1339 #define FP_INFINITE FP_INFINITE
1340   FP_ZERO,
1341 #define FP_ZERO FP_ZERO
1342   FP_SUBNORMAL,
1343 #define FP_SUBNORMAL FP_SUBNORMAL
1344   FP_NORMAL
1345 #define FP_NORMAL FP_NORMAL
1346 };
1347 #endif
1348
1349
1350 static void
1351 fpclassify_test (void)
1352 {
1353   MATHTYPE x;
1354
1355   /* fpclassify is a macro, don't give it constants as parameter */
1356   check_bool ("fpclassify (NaN) == FP_NAN", fpclassify (nan_value) == FP_NAN);
1357   check_bool ("fpclassify (+inf) == FP_INFINITE",
1358               fpclassify (plus_infty) == FP_INFINITE);
1359   check_bool ("fpclassify (-inf) == FP_INFINITE",
1360               fpclassify (minus_infty) == FP_INFINITE);
1361   check_bool ("fpclassify (+0) == FP_ZERO",
1362               fpclassify (plus_zero) == FP_ZERO);
1363   check_bool ("fpclassify (-0) == FP_ZERO",
1364               fpclassify (minus_zero) == FP_ZERO);
1365
1366   x = 1000.0;
1367   check_bool ("fpclassify (1000) == FP_NORMAL",
1368               fpclassify (x) == FP_NORMAL);
1369 }
1370
1371
1372 static void
1373 isfinite_test (void)
1374 {
1375   check_bool ("isfinite (0) != 0", isfinite (0));
1376   check_bool ("isfinite (-0) != 0", isfinite (minus_zero));
1377   check_bool ("isfinite (10) != 0", isfinite (10));
1378   check_bool ("isfinite (+inf) == 0", isfinite (plus_infty) == 0);
1379   check_bool ("isfinite (-inf) == 0", isfinite (minus_infty) == 0);
1380   check_bool ("isfinite (NaN) == 0", isfinite (nan_value) == 0);
1381 }
1382
1383
1384 static void
1385 isnormal_test (void)
1386 {
1387   check_bool ("isnormal (0) == 0", isnormal (0) == 0);
1388   check_bool ("isnormal (-0) == 0", isnormal (minus_zero) == 0);
1389   check_bool ("isnormal (10) != 0", isnormal (10));
1390   check_bool ("isnormal (+inf) == 0", isnormal (plus_infty) == 0);
1391   check_bool ("isnormal (-inf) == 0", isnormal (minus_infty) == 0);
1392   check_bool ("isnormal (NaN) == 0", isnormal (nan_value) == 0);
1393
1394 }
1395
1396
1397 static void
1398 signbit_test (void)
1399 {
1400   MATHTYPE x;
1401
1402   check_bool ("signbit (+0) == 0", signbit (0) == 0);
1403   check_bool ("signbit (-0) != 0", signbit (minus_zero));
1404   check_bool ("signbit (+inf) == 0", signbit (plus_infty) == 0);
1405   check_bool ("signbit (-inf) != 0", signbit (minus_infty));
1406
1407   x = random_less (0);
1408   check_bool ("signbit (x) != 0 for x < 0", signbit (x));
1409
1410   x = random_greater (0);
1411   check_bool ("signbit (x) == 0 for x > 0", signbit (x) == 0);
1412
1413 }
1414
1415
1416 static void
1417 gamma_test (void)
1418 {
1419   errno = 0;
1420   FUNC(gamma) (1);
1421   if (errno == ENOSYS)
1422     /* Function not implemented.  */
1423     return;
1424   feclearexcept (FE_ALL_EXCEPT);
1425
1426
1427   check_isinfp ("gamma (+inf) == +inf", FUNC(gamma) (plus_infty));
1428   check_isinfp_exc ("gamma (0) == +inf plus divide by zero exception",
1429                     FUNC(gamma) (0), DIVIDE_BY_ZERO_EXCEPTION);
1430
1431   check_isinfp_exc ("gamma (x) == +inf plus divide by zero exception for integer x <= 0",
1432                     FUNC(gamma) (-3), DIVIDE_BY_ZERO_EXCEPTION);
1433   check_isnan_exc ("gamma (-inf) == NaN plus invalid exception",
1434                    FUNC(gamma) (minus_infty), INVALID_EXCEPTION);
1435
1436   signgam = 0;
1437   check ("gamma (1) == 0", FUNC(gamma) (1), 0);
1438   check_int ("gamma (1) sets signgam to 1", signgam, 1);
1439
1440   signgam = 0;
1441   check ("gamma (3) == M_LN2", FUNC(gamma) (3), M_LN2l);
1442   check_int ("gamma (3) sets signgam to 1", signgam, 1);
1443
1444   signgam = 0;
1445   check_eps ("gamma (0.5) == log(sqrt(pi))", FUNC(gamma) (0.5),
1446              FUNC(log) (FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 1e-7));
1447   check_int ("gamma (0.5) sets signgam to 1", signgam, 1);
1448
1449   signgam = 0;
1450   check_eps ("gamma (-0.5) == log(2*sqrt(pi))", FUNC(gamma) (-0.5),
1451              FUNC(log) (2*FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 0));
1452
1453   check_int ("gamma (-0.5) sets signgam to -1", signgam, -1);
1454 }
1455
1456
1457 static void
1458 tgamma_test (void)
1459 {
1460   errno = 0;
1461   FUNC(tgamma) (1);
1462   if (errno == ENOSYS)
1463     /* Function not implemented.  */
1464     return;
1465   feclearexcept (FE_ALL_EXCEPT);
1466
1467
1468   check_isinfp ("tgamma (+inf) == +inf", FUNC(tgamma) (plus_infty));
1469   check_isnan_exc ("tgamma (0) == NaN plus invalid exception",
1470                     FUNC(tgamma) (0), INVALID_EXCEPTION);
1471
1472   check_isnan_exc_ext ("tgamma (x) == NaN plus invalid exception for integer x <= 0",
1473                         FUNC(tgamma) (-2), INVALID_EXCEPTION, -2);
1474   check_isnan_exc ("tgamma (-inf) == NaN plus invalid exception",
1475                    FUNC(tgamma) (minus_infty), INVALID_EXCEPTION);
1476
1477 #ifdef TODO
1478   check_eps ("tgamma (0.5) == sqrt(pi)", FUNC(tgamma) (0.5),
1479              FUNC(sqrt) (M_PIl), CHOOSE (0, 5e-16, 2e-7));
1480 #endif
1481   check_eps ("tgamma (-0.5) == -2*sqrt(pi)", FUNC(tgamma) (-0.5),
1482              -2*FUNC(sqrt) (M_PIl), CHOOSE (0, 5e-16, 3e-7));
1483
1484   check ("tgamma (1) == 1", FUNC(tgamma) (1), 1);
1485   check ("tgamma (4) == 6", FUNC(tgamma) (4), 6);
1486
1487   check_eps ("tgamma (0.7) == 1.29805...", FUNC(tgamma) (0.7),
1488              1.29805533264755778568L, CHOOSE(0, 3e-16, 2e-7));
1489   check ("tgamma (1.2) == 0.91816...", FUNC(tgamma) (1.2),
1490          0.91816874239976061064L);
1491 }
1492
1493
1494 static void
1495 lgamma_test (void)
1496 {
1497   errno = 0;
1498   FUNC(lgamma) (0);
1499   if (errno == ENOSYS)
1500     /* Function not implemented.  */
1501     return;
1502   feclearexcept (FE_ALL_EXCEPT);
1503
1504   check_isinfp ("lgamma (+inf) == +inf", FUNC(lgamma) (plus_infty));
1505   check_isinfp_exc ("lgamma (0) == +inf plus divide by zero exception",
1506                     FUNC(lgamma) (0), DIVIDE_BY_ZERO_EXCEPTION);
1507
1508   check_isinfp_exc ("lgamma (x) == +inf plus divide by zero exception for integer x <= 0",
1509                     FUNC(lgamma) (-3), DIVIDE_BY_ZERO_EXCEPTION);
1510   check_isnan_exc ("lgamma (-inf) == NaN plus invalid exception",
1511                    FUNC(lgamma) (minus_infty), INVALID_EXCEPTION);
1512
1513   signgam = 0;
1514   check ("lgamma (1) == 0", FUNC(lgamma) (1), 0);
1515   check_int ("lgamma (0) sets signgam to 1", signgam, 1);
1516
1517   signgam = 0;
1518   check ("lgamma (3) == M_LN2", FUNC(lgamma) (3), M_LN2l);
1519   check_int ("lgamma (3) sets signgam to 1", signgam, 1);
1520
1521   signgam = 0;
1522   check_eps ("lgamma (0.5) == log(sqrt(pi))", FUNC(lgamma) (0.5),
1523              FUNC(log) (FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 1e-7));
1524   check_int ("lgamma (0.5) sets signgam to 1", signgam, 1);
1525
1526   signgam = 0;
1527   check_eps ("lgamma (-0.5) == log(2*sqrt(pi))", FUNC(lgamma) (-0.5),
1528              FUNC(log) (2*FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 0));
1529
1530   check_int ("lgamma (-0.5) sets signgam to -1", signgam, -1);
1531
1532   signgam = 0;
1533   check_eps ("lgamma (0.7) == 0.26086...", FUNC(lgamma) (0.7),
1534              0.26086724653166651439L, CHOOSE(0, 6e-17, 3e-8));
1535   check_int ("lgamma (0.7) sets signgam to 1", signgam, 1);
1536
1537   signgam = 0;
1538   check_eps ("lgamma (1.2) == -0.08537...", FUNC(lgamma) (1.2),
1539              -0.853740900033158497197e-1L, CHOOSE(0, 2e-17, 2e-8));
1540   check_int ("lgamma (1.2) sets signgam to 1", signgam, 1);
1541
1542 }
1543
1544
1545 static void
1546 ilogb_test (void)
1547 {
1548   int i;
1549
1550   check_int ("ilogb (1) == 0", FUNC(ilogb) (1), 0);
1551   check_int ("ilogb (e) == 1", FUNC(ilogb) (M_El), 1);
1552   check_int ("ilogb (1024) == 10", FUNC(ilogb) (1024), 10);
1553   check_int ("ilogb (-2000) == 10", FUNC(ilogb) (-2000), 10);
1554
1555   /* XXX We have a problem here: the standard does not tell us whether
1556      exceptions are allowed/required.  ignore them for now.  */
1557   i = FUNC (ilogb) (0.0);
1558   feclearexcept (FE_ALL_EXCEPT);
1559   check_int ("ilogb (0) == FP_ILOGB0", i, FP_ILOGB0);
1560   i = FUNC(ilogb) (nan_value);
1561   feclearexcept (FE_ALL_EXCEPT);
1562   check_int ("ilogb (NaN) == FP_ILOGBNAN", i, FP_ILOGBNAN);
1563
1564 }
1565
1566
1567 static void
1568 ldexp_test (void)
1569 {
1570   MATHTYPE x;
1571
1572   check ("ldexp (0, 0) == 0", FUNC(ldexp) (0, 0), 0);
1573
1574   check_isinfp ("ldexp (+inf, 1) == +inf", FUNC(ldexp) (plus_infty, 1));
1575   check_isinfn ("ldexp (-inf, 1) == -inf", FUNC(ldexp) (minus_infty, 1));
1576   check_isnan ("ldexp (NaN, 1) == NaN", FUNC(ldexp) (nan_value, 1));
1577
1578   check ("ldexp (0.8, 4) == 12.8", FUNC(ldexp) (0.8L, 4), 12.8L);
1579   check ("ldexp (-0.854375, 5) == -27.34", FUNC(ldexp) (-0.854375L, 5), -27.34L);
1580
1581   x = random_greater (0.0);
1582   check_ext ("ldexp (x, 0) == x", FUNC(ldexp) (x, 0L), x, x);
1583
1584 }
1585
1586
1587 static void
1588 log_test (void)
1589 {
1590   check_isinfn_exc ("log (+0) == -inf plus divide-by-zero exception",
1591                     FUNC(log) (0), DIVIDE_BY_ZERO_EXCEPTION);
1592   check_isinfn_exc ("log (-0) == -inf plus divide-by-zero exception",
1593                     FUNC(log) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1594
1595   check ("log (1) == 0", FUNC(log) (1), 0);
1596
1597   check_isnan_exc ("log (x) == NaN plus invalid exception if x < 0",
1598                    FUNC(log) (-1), INVALID_EXCEPTION);
1599   check_isinfp ("log (+inf) == +inf", FUNC(log) (plus_infty));
1600
1601   check_eps ("log (e) == 1", FUNC(log) (M_El), 1, CHOOSE (1e-18L, 0, 9e-8L));
1602   check_eps ("log (1/e) == -1", FUNC(log) (1.0 / M_El), -1,
1603              CHOOSE (2e-18L, 0, 0));
1604   check ("log (2) == M_LN2", FUNC(log) (2), M_LN2l);
1605   check_eps ("log (10) == M_LN10", FUNC(log) (10), M_LN10l,
1606              CHOOSE (1e-18L, 0, 0));
1607   check_eps ("log (0.7) == -0.3566749439...", FUNC(log) (0.7),
1608              -0.35667494393873237891L, CHOOSE(7e-17L, 6e-17, 3e-8));
1609 }
1610
1611
1612 static void
1613 log10_test (void)
1614 {
1615   check_isinfn_exc ("log10 (+0) == -inf plus divide-by-zero exception",
1616                     FUNC(log10) (0), DIVIDE_BY_ZERO_EXCEPTION);
1617   check_isinfn_exc ("log10 (-0) == -inf plus divide-by-zero exception",
1618                     FUNC(log10) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1619
1620   check ("log10 (1) == +0", FUNC(log10) (1), 0);
1621
1622   check_isnan_exc ("log10 (x) == NaN plus invalid exception if x < 0",
1623                    FUNC(log10) (-1), INVALID_EXCEPTION);
1624
1625   check_isinfp ("log10 (+inf) == +inf", FUNC(log10) (plus_infty));
1626
1627   check_eps ("log10 (0.1) == -1", FUNC(log10) (0.1L), -1,
1628              CHOOSE (1e-18L, 0, 0));
1629   check_eps ("log10 (10) == 1", FUNC(log10) (10.0), 1,
1630              CHOOSE (1e-18L, 0, 0));
1631   check_eps ("log10 (100) == 2", FUNC(log10) (100.0), 2,
1632              CHOOSE (1e-18L, 0, 0));
1633   check ("log10 (10000) == 4", FUNC(log10) (10000.0), 4);
1634   check_eps ("log10 (e) == M_LOG10E", FUNC(log10) (M_El), M_LOG10El,
1635              CHOOSE (1e-18, 0, 9e-8));
1636   check_eps ("log10 (0.7) == -0.1549019599...", FUNC(log10) (0.7),
1637              -0.15490195998574316929L, CHOOSE(3e-17L, 3e-17, 2e-8));
1638 }
1639
1640
1641 static void
1642 log1p_test (void)
1643 {
1644   check ("log1p (+0) == +0", FUNC(log1p) (0), 0);
1645   check ("log1p (-0) == -0", FUNC(log1p) (minus_zero), minus_zero);
1646
1647   check_isinfn_exc ("log1p (-1) == -inf plus divide-by-zero exception",
1648                     FUNC(log1p) (-1), DIVIDE_BY_ZERO_EXCEPTION);
1649   check_isnan_exc ("log1p (x) == NaN plus invalid exception if x < -1",
1650                    FUNC(log1p) (-2), INVALID_EXCEPTION);
1651
1652   check_isinfp ("log1p (+inf) == +inf", FUNC(log1p) (plus_infty));
1653
1654   check_eps ("log1p (e-1) == 1", FUNC(log1p) (M_El - 1.0), 1,
1655              CHOOSE (1e-18L, 0, 6e-8));
1656
1657   check_eps ("log1p (-0.3) == -0.35667...", FUNC(log1p) (-0.3),
1658              -0.35667494393873237891L, CHOOSE(2e-17L, 6e-17, 3e-8));
1659 }
1660
1661
1662 static void
1663 log2_test (void)
1664 {
1665   check_isinfn_exc ("log2 (+0) == -inf plus divide-by-zero exception",
1666                     FUNC(log2) (0), DIVIDE_BY_ZERO_EXCEPTION);
1667   check_isinfn_exc ("log2 (-0) == -inf plus divide-by-zero exception",
1668                     FUNC(log2) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1669
1670   check ("log2 (1) == +0", FUNC(log2) (1), 0);
1671
1672   check_isnan_exc ("log2 (x) == NaN plus invalid exception if x < 0",
1673                    FUNC(log2) (-1), INVALID_EXCEPTION);
1674
1675   check_isinfp ("log2 (+inf) == +inf", FUNC(log2) (plus_infty));
1676
1677   check_eps ("log2 (e) == M_LOG2E", FUNC(log2) (M_El), M_LOG2El,
1678              CHOOSE (1e-18L, 0, 0));
1679   check ("log2 (2) == 1", FUNC(log2) (2.0), 1);
1680   check_eps ("log2 (16) == 4", FUNC(log2) (16.0), 4, CHOOSE (1e-18L, 0, 0));
1681   check ("log2 (256) == 8", FUNC(log2) (256.0), 8);
1682   check_eps ("log2 (0.7) == -0.5145731728...", FUNC(log2) (0.7),
1683              -0.51457317282975824043L, CHOOSE(1e-16L, 2e-16, 6e-8));
1684
1685 }
1686
1687
1688 static void
1689 logb_test (void)
1690 {
1691   check_isinfp ("logb (+inf) == +inf", FUNC(logb) (plus_infty));
1692   check_isinfp ("logb (-inf) == +inf", FUNC(logb) (minus_infty));
1693
1694   check_isinfn_exc ("logb (+0) == -inf plus divide-by-zero exception",
1695                     FUNC(logb) (0), DIVIDE_BY_ZERO_EXCEPTION);
1696
1697   check_isinfn_exc ("logb (-0) == -inf plus divide-by-zero exception",
1698                     FUNC(logb) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1699
1700   check ("logb (1) == 0", FUNC(logb) (1), 0);
1701   check ("logb (e) == 1", FUNC(logb) (M_El), 1);
1702   check ("logb (1024) == 10", FUNC(logb) (1024), 10);
1703   check ("logb (-2000) == 10", FUNC(logb) (-2000), 10);
1704
1705 }
1706
1707
1708 static void
1709 modf_test (void)
1710 {
1711   MATHTYPE result, intpart;
1712
1713   result = FUNC(modf) (plus_infty, &intpart);
1714   check ("modf (+inf, &x) returns +0", result, 0);
1715   check_isinfp ("modf (+inf, &x) set x to +inf", intpart);
1716
1717   result = FUNC(modf) (minus_infty, &intpart);
1718   check ("modf (-inf, &x) returns -0", result, minus_zero);
1719   check_isinfn ("modf (-inf, &x) sets x to -inf", intpart);
1720
1721   result = FUNC(modf) (nan_value, &intpart);
1722   check_isnan ("modf (NaN, &x) returns NaN", result);
1723   check_isnan ("modf (NaN, &x) sets x to NaN", intpart);
1724
1725   result = FUNC(modf) (0, &intpart);
1726   check ("modf (0, &x) returns 0", result, 0);
1727   check ("modf (0, &x) sets x to 0", intpart, 0);
1728
1729   result = FUNC(modf) (minus_zero, &intpart);
1730   check ("modf (-0, &x) returns -0", result, minus_zero);
1731   check ("modf (-0, &x) sets x to -0", intpart, minus_zero);
1732
1733   result = FUNC(modf) (1.5, &intpart);
1734   check ("modf (1.5, &x) returns 0.5", result, 0.5);
1735   check ("modf (1.5, &x) sets x to 1", intpart, 1);
1736
1737   result = FUNC(modf) (2.5, &intpart);
1738   check ("modf (2.5, &x) returns 0.5", result, 0.5);
1739   check ("modf (2.5, &x) sets x to 2", intpart, 2);
1740
1741   result = FUNC(modf) (-2.5, &intpart);
1742   check ("modf (-2.5, &x) returns -0.5", result, -0.5);
1743   check ("modf (-2.5, &x) sets x to -2", intpart, -2);
1744
1745   result = FUNC(modf) (20, &intpart);
1746   check ("modf (20, &x) returns 0", result, 0);
1747   check ("modf (20, &x) sets x to 20", intpart, 20);
1748
1749   result = FUNC(modf) (21, &intpart);
1750   check ("modf (21, &x) returns 0", result, 0);
1751   check ("modf (21, &x) sets x to 21", intpart, 21);
1752
1753   result = FUNC(modf) (89.6, &intpart);
1754   check_eps ("modf (89.6, &x) returns 0.6", result, 0.6,
1755              CHOOSE(6e-15L, 6e-15, 2e-6));
1756   check ("modf (89.6, &x) sets x to 89", intpart, 89);
1757 }
1758
1759
1760 static void
1761 scalb_test (void)
1762 {
1763   MATHTYPE x;
1764
1765   check_isnan ("scalb (2, 0.5) == NaN", FUNC(scalb) (2, 0.5));
1766   check_isnan ("scalb (3, -2.5) == NaN", FUNC(scalb) (3, -2.5));
1767
1768   check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value));
1769   check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value));
1770
1771   x = random_greater (0.0);
1772   check ("scalb (x, 0) == 0", FUNC(scalb) (x, 0), x);
1773   x = random_greater (0.0);
1774   check ("scalb (-x, 0) == 0", FUNC(scalb) (-x, 0), -x);
1775
1776   check_isnan_exc ("scalb (+0, +inf) == NaN plus invalid exception",
1777                    FUNC(scalb) (0, plus_infty), INVALID_EXCEPTION);
1778   check_isnan_exc ("scalb (-0, +inf) == NaN plus invalid exception",
1779                    FUNC(scalb) (minus_zero, plus_infty), INVALID_EXCEPTION);
1780
1781   check ("scalb (+0, 2) == +0", FUNC(scalb) (0, 2), 0);
1782   check ("scalb (-0, 4) == -0", FUNC(scalb) (minus_zero, -4), minus_zero);
1783   check ("scalb (+0, 0) == +0", FUNC(scalb) (0, 0), 0);
1784   check ("scalb (-0, 0) == -0", FUNC(scalb) (minus_zero, 0), minus_zero);
1785   check ("scalb (+0, -1) == +0", FUNC(scalb) (0, -1), 0);
1786   check ("scalb (-0, -10) == -0", FUNC(scalb) (minus_zero, -10), minus_zero);
1787   check ("scalb (+0, -inf) == +0", FUNC(scalb) (0, minus_infty), 0);
1788   check ("scalb (-0, -inf) == -0", FUNC(scalb) (minus_zero, minus_infty),
1789          minus_zero);
1790
1791   check_isinfp ("scalb (+inf, -1) == +inf", FUNC(scalb) (plus_infty, -1));
1792   check_isinfn ("scalb (-inf, -10) == -inf", FUNC(scalb) (minus_infty, -10));
1793   check_isinfp ("scalb (+inf, 0) == +inf", FUNC(scalb) (plus_infty, 0));
1794   check_isinfn ("scalb (-inf, 0) == -inf", FUNC(scalb) (minus_infty, 0));
1795   check_isinfp ("scalb (+inf, 2) == +inf", FUNC(scalb) (plus_infty, 2));
1796   check_isinfn ("scalb (-inf, 100) == -inf", FUNC(scalb) (minus_infty, 100));
1797
1798   x = random_greater (0.0);
1799   check ("scalb (x, -inf) == 0", FUNC(scalb) (x, minus_infty), 0.0);
1800   check ("scalb (-x, -inf) == -0", FUNC(scalb) (-x, minus_infty), minus_zero);
1801
1802   x = random_greater (0.0);
1803   check_isinfp ("scalb (x, +inf) == +inf", FUNC(scalb) (x, plus_infty));
1804   x = random_greater (0.0);
1805   check_isinfn ("scalb (-x, +inf) == -inf", FUNC(scalb) (-x, plus_infty));
1806   check_isinfp ("scalb (+inf, +inf) == +inf",
1807                 FUNC(scalb) (plus_infty, plus_infty));
1808   check_isinfn ("scalb (-inf, +inf) == -inf",
1809                 FUNC(scalb) (minus_infty, plus_infty));
1810
1811   check_isnan ("scalb (+inf, -inf) == NaN",
1812                FUNC(scalb) (plus_infty, minus_infty));
1813   check_isnan ("scalb (-inf, -inf) == NaN",
1814                FUNC(scalb) (minus_infty, minus_infty));
1815
1816   check_isnan ("scalb (NaN, 1) == NaN", FUNC(scalb) (nan_value, 1));
1817   check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value));
1818   check_isnan ("scalb (NaN, 0) == NaN", FUNC(scalb) (nan_value, 0));
1819   check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value));
1820   check_isnan ("scalb (NaN, +inf) == NaN",
1821                FUNC(scalb) (nan_value, plus_infty));
1822   check_isnan ("scalb (+inf, NaN) == NaN",
1823                FUNC(scalb) (plus_infty, nan_value));
1824   check_isnan ("scalb (NaN, NaN) == NaN", FUNC(scalb) (nan_value, nan_value));
1825
1826   check ("scalb (0.8, 4) == 12.8", FUNC(scalb) (0.8L, 4), 12.8L);
1827   check ("scalb (-0.854375, 5) == -27.34", FUNC(scalb) (-0.854375L, 5), -27.34L);
1828 }
1829
1830
1831 static void
1832 scalbn_test (void)
1833 {
1834   MATHTYPE x;
1835
1836   check ("scalbn (0, 0) == 0", FUNC(scalbn) (0, 0), 0);
1837
1838   check_isinfp ("scalbn (+inf, 1) == +inf", FUNC(scalbn) (plus_infty, 1));
1839   check_isinfn ("scalbn (-inf, 1) == -inf", FUNC(scalbn) (minus_infty, 1));
1840   check_isnan ("scalbn (NaN, 1) == NaN", FUNC(scalbn) (nan_value, 1));
1841
1842   check ("scalbn (0.8, 4) == 12.8", FUNC(scalbn) (0.8L, 4), 12.8L);
1843   check ("scalbn (-0.854375, 5) == -27.34", FUNC(scalbn) (-0.854375L, 5), -27.34L);
1844
1845   x = random_greater (0.0);
1846   check_ext ("scalbn (x, 0) == x", FUNC(scalbn) (x, 0L), x, x);
1847 }
1848
1849
1850 static void
1851 sin_test (void)
1852 {
1853   check ("sin (+0) == +0", FUNC(sin) (0), 0);
1854   check ("sin (-0) == -0", FUNC(sin) (minus_zero), minus_zero);
1855   check_isnan_exc ("sin (+inf) == NaN plus invalid exception",
1856                    FUNC(sin) (plus_infty),
1857                    INVALID_EXCEPTION);
1858   check_isnan_exc ("sin (-inf) == NaN plus invalid exception",
1859                    FUNC(sin) (minus_infty),
1860                    INVALID_EXCEPTION);
1861
1862   check_eps ("sin (pi/6) == 0.5", FUNC(sin) (M_PI_6l),
1863              0.5, CHOOSE (4e-18L, 0, 0));
1864   check_eps ("sin (-pi/6) == -0.5", FUNC(sin) (-M_PI_6l),
1865              -0.5, CHOOSE (4e-18L, 0, 0));
1866   check ("sin (pi/2) == 1", FUNC(sin) (M_PI_2l), 1);
1867   check ("sin (-pi/2) == -1", FUNC(sin) (-M_PI_2l), -1);
1868   check_eps ("sin (0.7) == 0.6442176872...", FUNC(sin) (0.7),
1869              0.64421768723769105367L, CHOOSE(4e-17L, 0, 0));
1870 }
1871
1872
1873 static void
1874 sinh_test (void)
1875 {
1876   check ("sinh (+0) == +0", FUNC(sinh) (0), 0);
1877
1878 #ifndef TEST_INLINE
1879   check ("sinh (-0) == -0", FUNC(sinh) (minus_zero), minus_zero);
1880
1881   check_isinfp ("sinh (+inf) == +inf", FUNC(sinh) (plus_infty));
1882   check_isinfn ("sinh (-inf) == -inf", FUNC(sinh) (minus_infty));
1883 #endif
1884
1885   check_eps ("sinh (0.7) == 0.7585837018...", FUNC(sinh) (0.7),
1886              0.75858370183953350346L, CHOOSE(6e-17L, 2e-16, 6e-8));
1887 }
1888
1889
1890 static void
1891 sincos_test (void)
1892 {
1893   MATHTYPE sin_res, cos_res;
1894   fenv_t fenv;
1895
1896   FUNC(sincos) (0, &sin_res, &cos_res);
1897   fegetenv (&fenv);
1898   check ("sincos (+0, &sin, &cos) puts +0 in sin", sin_res, 0);
1899   fesetenv (&fenv);
1900   check ("sincos (+0, &sin, &cos) puts 1 in cos", cos_res, 1);
1901
1902   FUNC(sincos) (minus_zero, &sin_res, &cos_res);
1903   fegetenv (&fenv);
1904   check ("sincos (-0, &sin, &cos) puts -0 in sin", sin_res, minus_zero);
1905   fesetenv (&fenv);
1906   check ("sincos (-0, &sin, &cos) puts 1 in cos", cos_res, 1);
1907
1908   FUNC(sincos) (plus_infty, &sin_res, &cos_res);
1909   fegetenv (&fenv);
1910   check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in sin plus invalid exception",
1911                    sin_res, INVALID_EXCEPTION);
1912   fesetenv (&fenv);
1913   check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in cos plus invalid exception",
1914                    cos_res, INVALID_EXCEPTION);
1915
1916   FUNC(sincos) (minus_infty, &sin_res, &cos_res);
1917   fegetenv (&fenv);
1918   check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in sin plus invalid exception",
1919                    sin_res, INVALID_EXCEPTION);
1920   fesetenv (&fenv);
1921   check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in cos plus invalid exception",
1922                    cos_res, INVALID_EXCEPTION);
1923
1924   FUNC(sincos) (M_PI_2l, &sin_res, &cos_res);
1925   fegetenv (&fenv);
1926   check ("sincos (pi/2, &sin, &cos) puts 1 in sin", sin_res, 1);
1927   fesetenv (&fenv);
1928   check_eps ("sincos (pi/2, &sin, &cos) puts 0 in cos", cos_res, 0,
1929              CHOOSE (1e-18L, 1e-16, 1e-7));
1930
1931   FUNC(sincos) (M_PI_6l, &sin_res, &cos_res);
1932   check_eps ("sincos (pi/6, &sin, &cos) puts 0.5 in sin", sin_res, 0.5,
1933              CHOOSE (5e-18L, 0, 0));
1934
1935   FUNC(sincos) (M_PI_6l*2.0, &sin_res, &cos_res);
1936   check_eps ("sincos (pi/3, &sin, &cos) puts 0.5 in cos", cos_res, 0.5,
1937              CHOOSE (5e-18L, 1e-15, 1e-7));
1938
1939   FUNC(sincos) (0.7, &sin_res, &cos_res);
1940   check_eps ("sincos (0.7, &sin, &cos) puts 0.6442176872... in sin", sin_res,
1941              0.64421768723769105367L, CHOOSE(4e-17L, 0, 0));
1942   check_eps ("sincos (0.7, &sin, &cos) puts 0.7648421872... in cos", cos_res,
1943              0.76484218728448842626L, CHOOSE(3e-17L, 2e-16, 6e-8));
1944 }
1945
1946
1947 static void
1948 tan_test (void)
1949 {
1950   check ("tan (+0) == +0", FUNC(tan) (0), 0);
1951   check ("tan (-0) == -0", FUNC(tan) (minus_zero), minus_zero);
1952   check_isnan_exc ("tan (+inf) == NaN plus invalid exception",
1953                    FUNC(tan) (plus_infty), INVALID_EXCEPTION);
1954   check_isnan_exc ("tan (-inf) == NaN plus invalid exception",
1955                    FUNC(tan) (minus_infty), INVALID_EXCEPTION);
1956
1957   check_eps ("tan (pi/4) == 1", FUNC(tan) (M_PI_4l), 1,
1958              CHOOSE (2e-18L, 1e-15L, 2e-7));
1959   check_eps ("tan (0.7) == 0.8422883804...", FUNC(tan) (0.7),
1960              0.84228838046307944813L, CHOOSE(8e-17L, 0, 0));
1961 }
1962
1963
1964 static void
1965 tanh_test (void)
1966 {
1967   check ("tanh (+0) == +0", FUNC(tanh) (0), 0);
1968 #ifndef TEST_INLINE
1969   check ("tanh (-0) == -0", FUNC(tanh) (minus_zero), minus_zero);
1970
1971   check ("tanh (+inf) == +1", FUNC(tanh) (plus_infty), 1);
1972   check ("tanh (-inf) == -1", FUNC(tanh) (minus_infty), -1);
1973 #endif
1974   check_eps ("tanh (0.7) == 0.6043677771...", FUNC(tanh) (0.7),
1975              0.60436777711716349631L, CHOOSE(3e-17L, 2e-16, 6e-8));
1976 }
1977
1978
1979 static void
1980 fabs_test (void)
1981 {
1982   check ("fabs (+0) == +0", FUNC(fabs) (0), 0);
1983   check ("fabs (-0) == +0", FUNC(fabs) (minus_zero), 0);
1984
1985   check_isinfp ("fabs (+inf) == +inf", FUNC(fabs) (plus_infty));
1986   check_isinfp ("fabs (-inf) == +inf", FUNC(fabs) (minus_infty));
1987
1988   check ("fabs (+38) == 38", FUNC(fabs) (38.0), 38.0);
1989   check ("fabs (-e) == e", FUNC(fabs) (-M_El), M_El);
1990 }
1991
1992
1993 static void
1994 floor_test (void)
1995 {
1996   check ("floor (+0) == +0", FUNC(floor) (0.0), 0.0);
1997   check ("floor (-0) == -0", FUNC(floor) (minus_zero), minus_zero);
1998   check_isinfp ("floor (+inf) == +inf", FUNC(floor) (plus_infty));
1999   check_isinfn ("floor (-inf) == -inf", FUNC(floor) (minus_infty));
2000
2001   check ("floor (pi) == 3", FUNC(floor) (M_PIl), 3.0);
2002   check ("floor (-pi) == -4", FUNC(floor) (-M_PIl), -4.0);
2003 }
2004
2005
2006 static void
2007 hypot_test (void)
2008 {
2009   MATHTYPE a;
2010
2011   a = random_greater (0);
2012   check_isinfp_ext ("hypot (+inf, x) == +inf", FUNC(hypot) (plus_infty, a), a);
2013   check_isinfp_ext ("hypot (-inf, x) == +inf", FUNC(hypot) (minus_infty, a), a);
2014
2015 #ifndef TEST_INLINE
2016   check_isinfp ("hypot (+inf, NaN) == +inf", FUNC(hypot) (plus_infty, nan_value));
2017   check_isinfp ("hypot (-inf, NaN) == +inf", FUNC(hypot) (minus_infty, nan_value));
2018 #endif
2019
2020   check_isnan ("hypot (NaN, NaN) == NaN", FUNC(hypot) (nan_value, nan_value));
2021
2022   a = FUNC(hypot) (12.4L, 0.7L);
2023   check ("hypot (x,y) == hypot (y,x)", FUNC(hypot) (0.7L, 12.4L), a);
2024   check ("hypot (x,y) == hypot (-x,y)", FUNC(hypot) (-12.4L, 0.7L), a);
2025   check ("hypot (x,y) == hypot (-y,x)", FUNC(hypot) (-0.7L, 12.4L), a);
2026   check ("hypot (x,y) == hypot (-x,-y)", FUNC(hypot) (-12.4L, -0.7L), a);
2027   check ("hypot (x,y) == hypot (-y,-x)", FUNC(hypot) (-0.7L, -12.4L), a);
2028   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-0.7L, 0), 0.7L);
2029   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (0.7L, 0), 0.7L);
2030   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-1.0L, 0), 1.0L);
2031   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (1.0L, 0), 1.0L);
2032   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-5.7e7L, 0), 5.7e7L);
2033   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (5.7e7L, 0), 5.7e7L);
2034
2035   check_eps ("hypot (0.7,1.2) == 1.38924...", FUNC(hypot) (0.7, 1.2),
2036              1.3892443989449804508L, CHOOSE(7e-17L, 3e-16, 0));
2037 }
2038
2039
2040 static void
2041 pow_test (void)
2042 {
2043   MATHTYPE x;
2044
2045   check ("pow (+0, +0) == 1", FUNC(pow) (0, 0), 1);
2046   check ("pow (+0, -0) == 1", FUNC(pow) (0, minus_zero), 1);
2047   check ("pow (-0, +0) == 1", FUNC(pow) (minus_zero, 0), 1);
2048   check ("pow (-0, -0) == 1", FUNC(pow) (minus_zero, minus_zero), 1);
2049
2050   check ("pow (+10, +0) == 1", FUNC(pow) (10, 0), 1);
2051   check ("pow (+10, -0) == 1", FUNC(pow) (10, minus_zero), 1);
2052   check ("pow (-10, +0) == 1", FUNC(pow) (-10, 0), 1);
2053   check ("pow (-10, -0) == 1", FUNC(pow) (-10, minus_zero), 1);
2054
2055   check ("pow (NaN, +0) == 1", FUNC(pow) (nan_value, 0), 1);
2056   check ("pow (NaN, -0) == 1", FUNC(pow) (nan_value, minus_zero), 1);
2057
2058 #ifndef TEST_INLINE
2059   check_isinfp ("pow (+1.1, +inf) == +inf", FUNC(pow) (1.1, plus_infty));
2060   check_isinfp ("pow (+inf, +inf) == +inf", FUNC(pow) (plus_infty, plus_infty));
2061   check_isinfp ("pow (-1.1, +inf) == +inf", FUNC(pow) (-1.1, plus_infty));
2062   check_isinfp ("pow (-inf, +inf) == +inf", FUNC(pow) (minus_infty, plus_infty));
2063
2064   check ("pow (0.9, +inf) == +0", FUNC(pow) (0.9L, plus_infty), 0);
2065   check ("pow (1e-7, +inf) == +0", FUNC(pow) (1e-7L, plus_infty), 0);
2066   check ("pow (-0.9, +inf) == +0", FUNC(pow) (-0.9L, plus_infty), 0);
2067   check ("pow (-1e-7, +inf) == +0", FUNC(pow) (-1e-7L, plus_infty), 0);
2068
2069   check ("pow (+1.1, -inf) == 0", FUNC(pow) (1.1, minus_infty), 0);
2070   check ("pow (+inf, -inf) == 0", FUNC(pow) (plus_infty, minus_infty), 0);
2071   check ("pow (-1.1, -inf) == 0", FUNC(pow) (-1.1, minus_infty), 0);
2072   check ("pow (-inf, -inf) == 0", FUNC(pow) (minus_infty, minus_infty), 0);
2073
2074   check_isinfp ("pow (0.9, -inf) == +inf", FUNC(pow) (0.9L, minus_infty));
2075   check_isinfp ("pow (1e-7, -inf) == +inf", FUNC(pow) (1e-7L, minus_infty));
2076   check_isinfp ("pow (-0.9, -inf) == +inf", FUNC(pow) (-0.9L, minus_infty));
2077   check_isinfp ("pow (-1e-7, -inf) == +inf", FUNC(pow) (-1e-7L, minus_infty));
2078
2079   check_isinfp ("pow (+inf, 1e-7) == +inf", FUNC(pow) (plus_infty, 1e-7L));
2080   check_isinfp ("pow (+inf, 1) == +inf", FUNC(pow) (plus_infty, 1));
2081   check_isinfp ("pow (+inf, 1e7) == +inf", FUNC(pow) (plus_infty, 1e7L));
2082
2083   check ("pow (+inf, -1e-7) == 0", FUNC(pow) (plus_infty, -1e-7L), 0);
2084   check ("pow (+inf, -1) == 0", FUNC(pow) (plus_infty, -1), 0);
2085   check ("pow (+inf, -1e7) == 0", FUNC(pow) (plus_infty, -1e7L), 0);
2086
2087   check_isinfn ("pow (-inf, 1) == -inf", FUNC(pow) (minus_infty, 1));
2088   check_isinfn ("pow (-inf, 11) == -inf", FUNC(pow) (minus_infty, 11));
2089   check_isinfn ("pow (-inf, 1001) == -inf", FUNC(pow) (minus_infty, 1001));
2090
2091   check_isinfp ("pow (-inf, 2) == +inf", FUNC(pow) (minus_infty, 2));
2092   check_isinfp ("pow (-inf, 12) == +inf", FUNC(pow) (minus_infty, 12));
2093   check_isinfp ("pow (-inf, 1002) == +inf", FUNC(pow) (minus_infty, 1002));
2094   check_isinfp ("pow (-inf, 0.1) == +inf", FUNC(pow) (minus_infty, 0.1));
2095   check_isinfp ("pow (-inf, 1.1) == +inf", FUNC(pow) (minus_infty, 1.1));
2096   check_isinfp ("pow (-inf, 11.1) == +inf", FUNC(pow) (minus_infty, 11.1));
2097   check_isinfp ("pow (-inf, 1001.1) == +inf", FUNC(pow) (minus_infty, 1001.1));
2098
2099   check ("pow (-inf, -1) == -0", FUNC(pow) (minus_infty, -1), minus_zero);
2100   check ("pow (-inf, -11) == -0", FUNC(pow) (minus_infty, -11), minus_zero);
2101   check ("pow (-inf, -1001) == -0", FUNC(pow) (minus_infty, -1001), minus_zero);
2102
2103   check ("pow (-inf, -2) == +0", FUNC(pow) (minus_infty, -2), 0);
2104   check ("pow (-inf, -12) == +0", FUNC(pow) (minus_infty, -12), 0);
2105   check ("pow (-inf, -1002) == +0", FUNC(pow) (minus_infty, -1002), 0);
2106   check ("pow (-inf, -0.1) == +0", FUNC(pow) (minus_infty, -0.1), 0);
2107   check ("pow (-inf, -1.1) == +0", FUNC(pow) (minus_infty, -1.1), 0);
2108   check ("pow (-inf, -11.1) == +0", FUNC(pow) (minus_infty, -11.1), 0);
2109   check ("pow (-inf, -1001.1) == +0", FUNC(pow) (minus_infty, -1001.1), 0);
2110
2111   check_isnan ("pow (NaN, NaN) == NaN", FUNC(pow) (nan_value, nan_value));
2112   check_isnan ("pow (0, NaN) == NaN", FUNC(pow) (0, nan_value));
2113   check_isnan ("pow (1, NaN) == NaN", FUNC(pow) (1, nan_value));
2114   check_isnan ("pow (-1, NaN) == NaN", FUNC(pow) (-1, nan_value));
2115   check_isnan ("pow (NaN, 1) == NaN", FUNC(pow) (nan_value, 1));
2116   check_isnan ("pow (NaN, -1) == NaN", FUNC(pow) (nan_value, -1));
2117
2118   x = random_greater (0.0);
2119   check_isnan_ext ("pow (x, NaN) == NaN", FUNC(pow) (x, nan_value), x);
2120
2121   check_isnan_exc ("pow (+1, +inf) == NaN plus invalid exception",
2122                    FUNC(pow) (1, plus_infty), INVALID_EXCEPTION);
2123   check_isnan_exc ("pow (-1, +inf) == NaN plus invalid exception",
2124                    FUNC(pow) (-1, plus_infty), INVALID_EXCEPTION);
2125   check_isnan_exc ("pow (+1, -inf) == NaN plus invalid exception",
2126                    FUNC(pow) (1, minus_infty), INVALID_EXCEPTION);
2127   check_isnan_exc ("pow (-1, -inf) == NaN plus invalid exception",
2128                    FUNC(pow) (-1, minus_infty), INVALID_EXCEPTION);
2129
2130   check_isnan_exc ("pow (-0.1, 1.1) == NaN plus invalid exception",
2131                    FUNC(pow) (-0.1, 1.1), INVALID_EXCEPTION);
2132   check_isnan_exc ("pow (-0.1, -1.1) == NaN plus invalid exception",
2133                    FUNC(pow) (-0.1, -1.1), INVALID_EXCEPTION);
2134   check_isnan_exc ("pow (-10.1, 1.1) == NaN plus invalid exception",
2135                    FUNC(pow) (-10.1, 1.1), INVALID_EXCEPTION);
2136   check_isnan_exc ("pow (-10.1, -1.1) == NaN plus invalid exception",
2137                    FUNC(pow) (-10.1, -1.1), INVALID_EXCEPTION);
2138
2139   check_isinfp_exc ("pow (+0, -1) == +inf plus divide-by-zero exception",
2140                     FUNC(pow) (0, -1), DIVIDE_BY_ZERO_EXCEPTION);
2141   check_isinfp_exc ("pow (+0, -11) == +inf plus divide-by-zero exception",
2142                     FUNC(pow) (0, -11), DIVIDE_BY_ZERO_EXCEPTION);
2143   check_isinfn_exc ("pow (-0, -1) == -inf plus divide-by-zero exception",
2144                     FUNC(pow) (minus_zero, -1), DIVIDE_BY_ZERO_EXCEPTION);
2145   check_isinfn_exc ("pow (-0, -11) == -inf plus divide-by-zero exception",
2146                     FUNC(pow) (minus_zero, -11), DIVIDE_BY_ZERO_EXCEPTION);
2147
2148   check_isinfp_exc ("pow (+0, -2) == +inf plus divide-by-zero exception",
2149                     FUNC(pow) (0, -2), DIVIDE_BY_ZERO_EXCEPTION);
2150   check_isinfp_exc ("pow (+0, -11.1) == +inf plus divide-by-zero exception",
2151                     FUNC(pow) (0, -11.1), DIVIDE_BY_ZERO_EXCEPTION);
2152   check_isinfp_exc ("pow (-0, -2) == +inf plus divide-by-zero exception",
2153                     FUNC(pow) (minus_zero, -2), DIVIDE_BY_ZERO_EXCEPTION);
2154   check_isinfp_exc ("pow (-0, -11.1) == +inf plus divide-by-zero exception",
2155                     FUNC(pow) (minus_zero, -11.1), DIVIDE_BY_ZERO_EXCEPTION);
2156 #endif
2157
2158   check ("pow (+0, 1) == +0", FUNC(pow) (0, 1), 0);
2159   check ("pow (+0, 11) == +0", FUNC(pow) (0, 11), 0);
2160 #ifndef TEST_INLINE
2161   check ("pow (-0, 1) == -0", FUNC(pow) (minus_zero, 1), minus_zero);
2162   check ("pow (-0, 11) == -0", FUNC(pow) (minus_zero, 11), minus_zero);
2163 #endif
2164
2165   check ("pow (+0, 2) == +0", FUNC(pow) (0, 2), 0);
2166   check ("pow (+0, 11.1) == +0", FUNC(pow) (0, 11.1), 0);
2167
2168 #ifndef TEST_INLINE
2169   check ("pow (-0, 2) == +0", FUNC(pow) (minus_zero, 2), 0);
2170   check ("pow (-0, 11.1) == +0", FUNC(pow) (minus_zero, 11.1), 0);
2171
2172   x = random_greater (1.0);
2173   check_isinfp_ext ("pow (x, +inf) == +inf for |x| > 1",
2174                     FUNC(pow) (x, plus_infty), x);
2175
2176   x = random_value (-1.0, 1.0);
2177   check_ext ("pow (x, +inf) == +0 for |x| < 1",
2178              FUNC(pow) (x, plus_infty), 0.0, x);
2179
2180   x = random_greater (1.0);
2181   check_ext ("pow (x, -inf) == +0 for |x| > 1",
2182              FUNC(pow) (x, minus_infty), 0.0, x);
2183
2184   x = random_value (-1.0, 1.0);
2185   check_isinfp_ext ("pow (x, -inf) == +inf for |x| < 1",
2186                     FUNC(pow) (x, minus_infty), x);
2187
2188   x = random_greater (0.0);
2189   check_isinfp_ext ("pow (+inf, y) == +inf for y > 0",
2190                     FUNC(pow) (plus_infty, x), x);
2191
2192   x = random_less (0.0);
2193   check_ext ("pow (+inf, y) == +0 for y < 0",
2194              FUNC(pow) (plus_infty, x), 0.0, x);
2195
2196   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2197   check_isinfn_ext ("pow (-inf, y) == -inf for y an odd integer > 0",
2198                     FUNC(pow) (minus_infty, x), x);
2199
2200   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2201   check_isinfp_ext ("pow (-inf, y) == +inf for y > 0 and not an odd integer",
2202                     FUNC(pow) (minus_infty, x), x);
2203
2204   x = -((rand () % 1000000) * 2.0 + 1); /* Get random odd integer < 0 */
2205   check_ext ("pow (-inf, y) == -0 for y an odd integer < 0",
2206              FUNC(pow) (minus_infty, x), minus_zero, x);
2207
2208   x = ((rand () % 1000000) + 1) * -2.0; /* Get random even integer < 0 */
2209   check_ext ("pow (-inf, y) == +0 for y < 0 and not an odd integer",
2210              FUNC(pow) (minus_infty, x), 0.0, x);
2211 #endif
2212
2213   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2214   check_ext ("pow (+0, y) == +0 for y an odd integer > 0",
2215              FUNC(pow) (0.0, x), 0.0, x);
2216 #ifndef TEST_INLINE
2217   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2218   check_ext ("pow (-0, y) == -0 for y an odd integer > 0",
2219              FUNC(pow) (minus_zero, x), minus_zero, x);
2220 #endif
2221
2222   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2223   check_ext ("pow (+0, y) == +0 for y > 0 and not an odd integer",
2224              FUNC(pow) (0.0, x), 0.0, x);
2225
2226   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2227   check_ext ("pow (-0, y) == +0 for y > 0 and not an odd integer",
2228              FUNC(pow) (minus_zero, x), 0.0, x);
2229
2230   check_eps ("pow (0.7, 1.2) == 0.65180...", FUNC(pow) (0.7, 1.2),
2231              0.65180494056638638188L, CHOOSE(4e-17L, 0, 0));
2232
2233 #ifdef TEST_DOUBLE
2234   check ("pow (-7.49321e+133, -9.80818e+16) == 0",
2235          FUNC(pow) (-7.49321e+133, -9.80818e+16), 0);
2236 #endif
2237 }
2238
2239
2240 static void
2241 fdim_test (void)
2242 {
2243   check ("fdim (+0, +0) = +0", FUNC(fdim) (0, 0), 0);
2244   check ("fdim (9, 0) = 9", FUNC(fdim) (9, 0), 9);
2245   check ("fdim (0, 9) = 0", FUNC(fdim) (0, 9), 0);
2246   check ("fdim (-9, 0) = 9", FUNC(fdim) (-9, 0), 0);
2247   check ("fdim (0, -9) = 9", FUNC(fdim) (0, -9), 9);
2248
2249   check_isinfp ("fdim (+inf, 9) = +inf", FUNC(fdim) (plus_infty, 9));
2250   check_isinfp ("fdim (+inf, -9) = +inf", FUNC(fdim) (plus_infty, -9));
2251   check ("fdim (-inf, 9) = 0", FUNC(fdim) (minus_infty, 9), 0);
2252   check ("fdim (-inf, -9) = 0", FUNC(fdim) (minus_infty, -9), 0);
2253   check_isinfp ("fdim (+9, -inf) = +inf", FUNC(fdim) (9, minus_infty));
2254   check_isinfp ("fdim (-9, -inf) = +inf", FUNC(fdim) (-9, minus_infty));
2255   check ("fdim (9, inf) = 0", FUNC(fdim) (9, plus_infty), 0);
2256   check ("fdim (-9, inf) = 0", FUNC(fdim) (-9, plus_infty), 0);
2257
2258   check_isnan ("fdim (0, NaN) = NaN", FUNC(fdim) (0, nan_value));
2259   check_isnan ("fdim (9, NaN) = NaN", FUNC(fdim) (9, nan_value));
2260   check_isnan ("fdim (-9, NaN) = NaN", FUNC(fdim) (-9, nan_value));
2261   check_isnan ("fdim (NaN, 9) = NaN", FUNC(fdim) (nan_value, 9));
2262   check_isnan ("fdim (NaN, -9) = NaN", FUNC(fdim) (nan_value, -9));
2263   check_isnan ("fdim (+inf, NaN) = NaN", FUNC(fdim) (plus_infty, nan_value));
2264   check_isnan ("fdim (-inf, NaN) = NaN", FUNC(fdim) (minus_infty, nan_value));
2265   check_isnan ("fdim (NaN, +inf) = NaN", FUNC(fdim) (nan_value, plus_infty));
2266   check_isnan ("fdim (NaN, -inf) = NaN", FUNC(fdim) (nan_value, minus_infty));
2267   check_isnan ("fdim (NaN, NaN) = NaN", FUNC(fdim) (nan_value, nan_value));
2268 }
2269
2270
2271 static void
2272 fmin_test (void)
2273 {
2274   check ("fmin (+0, +0) = +0", FUNC(fmin) (0, 0), 0);
2275   check ("fmin (9, 0) = 0", FUNC(fmin) (9, 0), 0);
2276   check ("fmin (0, 9) = 0", FUNC(fmin) (0, 9), 0);
2277   check ("fmin (-9, 0) = -9", FUNC(fmin) (-9, 0), -9);
2278   check ("fmin (0, -9) = -9", FUNC(fmin) (0, -9), -9);
2279
2280   check ("fmin (+inf, 9) = 9", FUNC(fmin) (plus_infty, 9), 9);
2281   check ("fmin (9, +inf) = 9", FUNC(fmin) (9, plus_infty), 9);
2282   check ("fmin (+inf, -9) = -9", FUNC(fmin) (plus_infty, -9), -9);
2283   check ("fmin (-9, +inf) = -9", FUNC(fmin) (-9, plus_infty), -9);
2284   check_isinfn ("fmin (-inf, 9) = -inf", FUNC(fmin) (minus_infty, 9));
2285   check_isinfn ("fmin (-inf, -9) = -inf", FUNC(fmin) (minus_infty, -9));
2286   check_isinfn ("fmin (+9, -inf) = -inf", FUNC(fmin) (9, minus_infty));
2287   check_isinfn ("fmin (-9, -inf) = -inf", FUNC(fmin) (-9, minus_infty));
2288
2289   check ("fmin (0, NaN) = 0", FUNC(fmin) (0, nan_value), 0);
2290   check ("fmin (9, NaN) = 9", FUNC(fmin) (9, nan_value), 9);
2291   check ("fmin (-9, NaN) = 9", FUNC(fmin) (-9, nan_value), -9);
2292   check ("fmin (NaN, 0) = 0", FUNC(fmin) (nan_value, 0), 0);
2293   check ("fmin (NaN, 9) = NaN", FUNC(fmin) (nan_value, 9), 9);
2294   check ("fmin (NaN, -9) = NaN", FUNC(fmin) (nan_value, -9), -9);
2295   check_isinfp ("fmin (+inf, NaN) = +inf", FUNC(fmin) (plus_infty, nan_value));
2296   check_isinfn ("fmin (-inf, NaN) = -inf", FUNC(fmin) (minus_infty, nan_value));
2297   check_isinfp ("fmin (NaN, +inf) = +inf", FUNC(fmin) (nan_value, plus_infty));
2298   check_isinfn ("fmin (NaN, -inf) = -inf", FUNC(fmin) (nan_value, minus_infty));
2299   check_isnan ("fmin (NaN, NaN) = NaN", FUNC(fmin) (nan_value, nan_value));
2300 }
2301
2302
2303 static void
2304 fmax_test (void)
2305 {
2306   check ("fmax (+0, +0) = +0", FUNC(fmax) (0, 0), 0);
2307   check ("fmax (9, 0) = 9", FUNC(fmax) (9, 0), 9);
2308   check ("fmax (0, 9) = 9", FUNC(fmax) (0, 9), 9);
2309   check ("fmax (-9, 0) = 0", FUNC(fmax) (-9, 0), 0);
2310   check ("fmax (0, -9) = 0", FUNC(fmax) (0, -9), 0);
2311
2312   check_isinfp ("fmax (+inf, 9) = +inf", FUNC(fmax) (plus_infty, 9));
2313   check_isinfp ("fmax (9, +inf) = +inf", FUNC(fmax) (0, plus_infty));
2314   check_isinfp ("fmax (-9, +inf) = +inf", FUNC(fmax) (-9, plus_infty));
2315   check_isinfp ("fmax (+inf, -9) = +inf", FUNC(fmax) (plus_infty, -9));
2316   check ("fmax (-inf, 9) = 9", FUNC(fmax) (minus_infty, 9), 9);
2317   check ("fmax (-inf, -9) = -9", FUNC(fmax) (minus_infty, -9), -9);
2318   check ("fmax (+9, -inf) = 9", FUNC(fmax) (9, minus_infty), 9);
2319   check ("fmax (-9, -inf) = -9", FUNC(fmax) (-9, minus_infty), -9);
2320
2321   check ("fmax (0, NaN) = 0", FUNC(fmax) (0, nan_value), 0);
2322   check ("fmax (9, NaN) = 9", FUNC(fmax) (9, nan_value), 9);
2323   check ("fmax (-9, NaN) = 9", FUNC(fmax) (-9, nan_value), -9);
2324   check ("fmax (NaN, 0) = 0", FUNC(fmax) (nan_value, 0), 0);
2325   check ("fmax (NaN, 9) = NaN", FUNC(fmax) (nan_value, 9), 9);
2326   check ("fmax (NaN, -9) = NaN", FUNC(fmax) (nan_value, -9), -9);
2327   check_isinfp ("fmax (+inf, NaN) = +inf", FUNC(fmax) (plus_infty, nan_value));
2328   check_isinfn ("fmax (-inf, NaN) = -inf", FUNC(fmax) (minus_infty, nan_value));
2329   check_isinfp ("fmax (NaN, +inf) = +inf", FUNC(fmax) (nan_value, plus_infty));
2330   check_isinfn ("fmax (NaN, -inf) = -inf", FUNC(fmax) (nan_value, minus_infty));
2331   check_isnan ("fmax (NaN, NaN) = NaN", FUNC(fmax) (nan_value, nan_value));
2332 }
2333
2334
2335 static void
2336 fmod_test (void)
2337 {
2338   MATHTYPE x;
2339
2340   x = random_greater (0);
2341   check_ext ("fmod (+0, y) == +0 for y != 0", FUNC(fmod) (0, x), 0, x);
2342
2343   x = random_greater (0);
2344   check_ext ("fmod (-0, y) == -0 for y != 0", FUNC(fmod) (minus_zero, x),
2345              minus_zero, x);
2346
2347   check_isnan_exc_ext ("fmod (+inf, y) == NaN plus invalid exception",
2348                        FUNC(fmod) (plus_infty, x), INVALID_EXCEPTION, x);
2349   check_isnan_exc_ext ("fmod (-inf, y) == NaN plus invalid exception",
2350                        FUNC(fmod) (minus_infty, x), INVALID_EXCEPTION, x);
2351   check_isnan_exc_ext ("fmod (x, +0) == NaN plus invalid exception",
2352                        FUNC(fmod) (x, 0), INVALID_EXCEPTION, x);
2353   check_isnan_exc_ext ("fmod (x, -0) == NaN plus invalid exception",
2354                        FUNC(fmod) (x, minus_zero), INVALID_EXCEPTION, x);
2355
2356   x = random_greater (0);
2357   check_ext ("fmod (x, +inf) == x for x not infinite",
2358              FUNC(fmod) (x, plus_infty), x, x);
2359   x = random_greater (0);
2360   check_ext ("fmod (x, -inf) == x for x not infinite",
2361              FUNC(fmod) (x, minus_infty), x, x);
2362
2363   check_eps ("fmod (6.5, 2.3) == 1.9", FUNC(fmod) (6.5, 2.3), 1.9,
2364              CHOOSE(5e-16, 1e-15, 2e-7));
2365   check_eps ("fmod (-6.5, 2.3) == -1.9", FUNC(fmod) (-6.5, 2.3), -1.9,
2366              CHOOSE(5e-16, 1e-15, 2e-7));
2367   check_eps ("fmod (6.5, -2.3) == 1.9", FUNC(fmod) (6.5, -2.3), 1.9,
2368              CHOOSE(5e-16, 1e-15, 2e-7));
2369   check_eps ("fmod (-6.5, -2.3) == -1.9", FUNC(fmod) (-6.5, -2.3), -1.9,
2370              CHOOSE(5e-16, 1e-15, 2e-7));
2371
2372
2373 }
2374
2375
2376 static void
2377 nextafter_test (void)
2378 {
2379   MATHTYPE x;
2380
2381   check ("nextafter (+0, +0) = +0", FUNC(nextafter) (0, 0), 0);
2382   check ("nextafter (-0, +0) = +0", FUNC(nextafter) (minus_zero, 0), 0);
2383   check ("nextafter (+0, -0) = -0", FUNC(nextafter) (0, minus_zero),
2384          minus_zero);
2385   check ("nextafter (-0, -0) = -0", FUNC(nextafter) (minus_zero, minus_zero),
2386          minus_zero);
2387
2388   check ("nextafter (9, 9) = 9",  FUNC(nextafter) (9, 9), 9);
2389   check ("nextafter (-9, -9) = -9",  FUNC(nextafter) (-9, -9), -9);
2390   check_isinfp ("nextafter (+inf, +inf) = +inf",
2391                 FUNC(nextafter) (plus_infty, plus_infty));
2392   check_isinfn ("nextafter (-inf, -inf) = -inf",
2393                 FUNC(nextafter) (minus_infty, minus_infty));
2394
2395   x = rand () * 1.1;
2396   check_isnan ("nextafter (NaN, x) = NaN", FUNC(nextafter) (nan_value, x));
2397   check_isnan ("nextafter (x, NaN) = NaN", FUNC(nextafter) (x, nan_value));
2398   check_isnan ("nextafter (NaN, NaN) = NaN", FUNC(nextafter) (nan_value,
2399                                                               nan_value));
2400
2401   /* XXX We need the hexadecimal FP number representation here for further
2402      tests.  */
2403 }
2404
2405
2406 static void
2407 copysign_test (void)
2408 {
2409   check ("copysign (0, 4) = 0", FUNC(copysign) (0, 4), 0);
2410   check ("copysign (0, -4) = -0", FUNC(copysign) (0, -4), minus_zero);
2411   check ("copysign (-0, 4) = 0", FUNC(copysign) (minus_zero, 4), 0);
2412   check ("copysign (-0, -4) = -0", FUNC(copysign) (minus_zero, -4),
2413          minus_zero);
2414
2415   check_isinfp ("copysign (+inf, 0) = +inf", FUNC(copysign) (plus_infty, 0));
2416   check_isinfn ("copysign (+inf, -0) = -inf", FUNC(copysign) (plus_infty,
2417                                                               minus_zero));
2418   check_isinfp ("copysign (-inf, 0) = +inf", FUNC(copysign) (minus_infty, 0));
2419   check_isinfn ("copysign (-inf, -0) = -inf", FUNC(copysign) (minus_infty,
2420                                                               minus_zero));
2421
2422   check ("copysign (0, +inf) = 0", FUNC(copysign) (0, plus_infty), 0);
2423   check ("copysign (0, -inf) = -0", FUNC(copysign) (0, minus_zero),
2424          minus_zero);
2425   check ("copysign (-0, +inf) = 0", FUNC(copysign) (minus_zero, plus_infty),
2426          0);
2427   check ("copysign (-0, -inf) = -0", FUNC(copysign) (minus_zero, minus_zero),
2428          minus_zero);
2429
2430   /* XXX More correctly we would have to check the sign of the NaN.  */
2431   check_isnan ("copysign (+NaN, 0) = +NaN", FUNC(copysign) (nan_value, 0));
2432   check_isnan ("copysign (+NaN, -0) = -NaN", FUNC(copysign) (nan_value,
2433                                                              minus_zero));
2434   check_isnan ("copysign (-NaN, 0) = +NaN", FUNC(copysign) (-nan_value, 0));
2435   check_isnan ("copysign (-NaN, -0) = -NaN", FUNC(copysign) (-nan_value,
2436                                                              minus_zero));
2437 }
2438
2439
2440 static void
2441 trunc_test (void)
2442 {
2443   check ("trunc(0) = 0", FUNC(trunc) (0), 0);
2444   check ("trunc(-0) = -0", FUNC(trunc) (minus_zero), minus_zero);
2445   check ("trunc(0.625) = 0", FUNC(trunc) (0.625), 0);
2446   check ("trunc(-0.625) = -0", FUNC(trunc) (-0.625), minus_zero);
2447   check ("trunc(1) = 1", FUNC(trunc) (1), 1);
2448   check ("trunc(-1) = -1", FUNC(trunc) (-1), -1);
2449   check ("trunc(1.625) = 1", FUNC(trunc) (1.625), 1);
2450   check ("trunc(-1.625) = -1", FUNC(trunc) (-1.625), -1);
2451
2452   check ("trunc(1048580.625) = 1048580", FUNC(trunc) (1048580.625L),
2453          1048580L);
2454   check ("trunc(-1048580.625) = -1048580", FUNC(trunc) (-1048580.625L),
2455          -1048580L);
2456
2457   check ("trunc(8388610.125) = 8388610", FUNC(trunc) (8388610.125L),
2458          8388610.0L);
2459   check ("trunc(-8388610.125) = -8388610", FUNC(trunc) (-8388610.125L),
2460          -8388610.0L);
2461
2462   check ("trunc(4294967296.625) = 4294967296", FUNC(trunc) (4294967296.625L),
2463          4294967296.0L);
2464   check ("trunc(-4294967296.625) = -4294967296",
2465          FUNC(trunc) (-4294967296.625L), -4294967296.0L);
2466
2467   check_isinfp ("trunc(+inf) = +inf", FUNC(trunc) (plus_infty));
2468   check_isinfn ("trunc(-inf) = -inf", FUNC(trunc) (minus_infty));
2469   check_isnan ("trunc(NaN) = NaN", FUNC(trunc) (nan_value));
2470 }
2471
2472
2473 static void
2474 sqrt_test (void)
2475 {
2476   MATHTYPE x;
2477
2478
2479   /* XXX Tests fuer negative x are missing */
2480   check ("sqrt (0) == 0", FUNC(sqrt) (0), 0);
2481   check_isnan ("sqrt (NaN) == NaN", FUNC(sqrt) (nan_value));
2482   check_isinfp ("sqrt (+inf) == +inf", FUNC(sqrt) (plus_infty));
2483
2484   check ("sqrt (-0) == -0", FUNC(sqrt) (0), 0);
2485
2486   x = random_less (0.0);
2487   check_isnan_exc_ext ("sqrt (x) == NaN plus invalid exception for x < 0",
2488                        FUNC(sqrt) (x), INVALID_EXCEPTION, x);
2489
2490   x = random_value (0, 10000);
2491   check_ext ("sqrt (x*x) == x", FUNC(sqrt) (x*x), x, x);
2492   check ("sqrt (4) == 2", FUNC(sqrt) (4), 2);
2493   check ("sqrt (2) == 1.14142...", FUNC(sqrt) (2), M_SQRT2l);
2494   check ("sqrt (0.25) == 0.5", FUNC(sqrt) (0.25), 0.5);
2495   check ("sqrt (6642.25) == 81.5", FUNC(sqrt) (6642.25), 81.5);
2496   check_eps ("sqrt (15239.903) == 123.45", FUNC(sqrt) (15239.903), 123.45,
2497              CHOOSE (3e-6L, 3e-6, 8e-6));
2498   check_eps ("sqrt (0.7) == 0.8366600265", FUNC(sqrt) (0.7),
2499              0.83666002653407554798L, CHOOSE(3e-17L, 0, 0));
2500 }
2501
2502 static void
2503 remainder_test (void)
2504 {
2505   MATHTYPE result;
2506
2507   result = FUNC(remainder) (1, 0);
2508   check_isnan_exc ("remainder(1, +0) == NaN plus invalid exception",
2509                    result, INVALID_EXCEPTION);
2510
2511   result = FUNC(remainder) (1, minus_zero);
2512   check_isnan_exc ("remainder(1, -0) == NaN plus invalid exception",
2513                    result, INVALID_EXCEPTION);
2514
2515   result = FUNC(remainder) (plus_infty, 1);
2516   check_isnan_exc ("remainder(+inf, 1) == NaN plus invalid exception",
2517                    result, INVALID_EXCEPTION);
2518
2519   result = FUNC(remainder) (minus_infty, 1);
2520   check_isnan_exc ("remainder(-inf, 1) == NaN plus invalid exception",
2521                    result, INVALID_EXCEPTION);
2522
2523   result = FUNC(remainder) (1.625, 1.0);
2524   check ("remainder(1.625, 1.0) == -0.375", result, -0.375);
2525
2526   result = FUNC(remainder) (-1.625, 1.0);
2527   check ("remainder(-1.625, 1.0) == 0.375", result, 0.375);
2528
2529   result = FUNC(remainder) (1.625, -1.0);
2530   check ("remainder(1.625, -1.0) == -0.375", result, -0.375);
2531
2532   result = FUNC(remainder) (-1.625, -1.0);
2533   check ("remainder(-1.625, -1.0) == 0.375", result, 0.375);
2534
2535   result = FUNC(remainder) (5.0, 2.0);
2536   check ("remainder(5.0, 2.0) == 1.0", result, 1.0);
2537
2538   result = FUNC(remainder) (3.0, 2.0);
2539   check ("remainder(3.0, 2.0) == -1.0", result, -1.0);
2540 }
2541
2542
2543 static void
2544 remquo_test (void)
2545 {
2546   int quo;
2547   MATHTYPE result;
2548
2549   result = FUNC(remquo) (1, 0, &quo);
2550   check_isnan_exc ("remquo(1, +0, &x) == NaN plus invalid exception",
2551                    result, INVALID_EXCEPTION);
2552
2553   result = FUNC(remquo) (1, minus_zero, &quo);
2554   check_isnan_exc ("remquo(1, -0, &x) == NaN plus invalid exception",
2555                    result, INVALID_EXCEPTION);
2556
2557   result = FUNC(remquo) (plus_infty, 1, &quo);
2558   check_isnan_exc ("remquo(+inf, 1, &x) == NaN plus invalid exception",
2559                    result, INVALID_EXCEPTION);
2560
2561   result = FUNC(remquo) (minus_infty, 1, &quo);
2562   check_isnan_exc ("remquo(-inf, 1, &x) == NaN plus invalid exception",
2563                    result, INVALID_EXCEPTION);
2564
2565   result = FUNC(remquo) (1.625, 1.0, &quo);
2566   check ("remquo(1.625, 1.0, &x) == -0.375", result, -0.375);
2567   check_long ("remquo(1.625, 1.0, &x) puts 2 in x", quo, 2);
2568
2569   result = FUNC(remquo) (-1.625, 1.0, &quo);
2570   check ("remquo(-1.625, 1.0, &x) == 0.375", result, 0.375);
2571   check_long ("remquo(-1.625, 1.0, &x) puts -2 in x", quo, -2);
2572
2573   result = FUNC(remquo) (1.625, -1.0, &quo);
2574   check ("remquo(1.625, -1.0, &x) == -0.375", result, -0.375);
2575   check_long ("remquo(1.625, -1.0, &x) puts -2 in x", quo, -2);
2576
2577   result = FUNC(remquo) (-1.625, -1.0, &quo);
2578   check ("remquo(-1.625, -1.0, &x) == 0.375", result, 0.375);
2579   check_long ("remquo(-1.625, -1.0, &x) puts 2 in x", quo, 2);
2580
2581   result = FUNC(remquo) (5.0, 2.0, &quo);
2582   check ("remquo(5.0, 2.0, &x) == 1.0", result, 1.0);
2583   check_long ("remquo (5.0, 2.0, &x) puts 2 in x", quo, 2);
2584
2585   result = FUNC(remquo) (3.0, 2.0, &quo);
2586   check ("remquo(3.0, 2.0, &x) == -1.0", result, -1.0);
2587   check_long ("remquo (3.0, 2.0, &x) puts 2 in x", quo, 2);
2588 }
2589
2590
2591 static void
2592 cexp_test (void)
2593 {
2594   __complex__ MATHTYPE result;
2595
2596   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, plus_zero));
2597   check ("real(cexp(0 + 0i)) = 1", __real__ result, 1);
2598   check ("imag(cexp(0 + 0i)) = 0", __imag__ result, 0);
2599   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_zero));
2600   check ("real(cexp(-0 + 0i)) = 1", __real__ result, 1);
2601   check ("imag(cexp(-0 + 0i)) = 0", __imag__ result, 0);
2602   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, minus_zero));
2603   check ("real(cexp(0 - 0i)) = 1", __real__ result, 1);
2604   check ("imag(cexp(0 - 0i)) = -0", __imag__ result, minus_zero);
2605   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_zero));
2606   check ("real(cexp(-0 - 0i)) = 1", __real__ result, 1);
2607   check ("imag(cexp(-0 - 0i)) = -0", __imag__ result, minus_zero);
2608
2609   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_zero));
2610   check_isinfp ("real(cexp(+inf + 0i)) = +inf", __real__ result);
2611   check ("imag(cexp(+inf + 0i)) = 0", __imag__ result, 0);
2612   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_zero));
2613   check_isinfp ("real(cexp(+inf - 0i)) = +inf", __real__ result);
2614   check ("imag(cexp(+inf - 0i)) = -0", __imag__ result, minus_zero);
2615
2616   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_zero));
2617   check ("real(cexp(-inf + 0i)) = 0", __real__ result, 0);
2618   check ("imag(cexp(-inf + 0i)) = 0", __imag__ result, 0);
2619   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_zero));
2620   check ("real(cexp(-inf - 0i)) = 0", __real__ result, 0);
2621   check ("imag(cexp(-inf - 0i)) = -0", __imag__ result, minus_zero);
2622
2623
2624   result = FUNC(cexp) (BUILD_COMPLEX (0.0, plus_infty));
2625   check_isnan_exc ("real(cexp(0 + i inf)) = NaN plus invalid exception",
2626                    __real__ result, INVALID_EXCEPTION);
2627   check_isnan ("imag(cexp(0 + i inf)) = NaN plus invalid exception",
2628                __imag__ result);
2629
2630 #if defined __GNUC__ && __GNUC__ <= 2 && __GNUC_MINOR__ <= 7
2631   if (verbose)
2632     printf ("The following test for cexp might fail due to a gcc compiler error!\n");
2633 #endif
2634
2635   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_infty));
2636   check_isnan_exc ("real(cexp(-0 + i inf)) = NaN plus invalid exception",
2637                    __real__ result, INVALID_EXCEPTION);
2638   check_isnan ("imag(cexp(-0 + i inf)) = NaN plus invalid exception",
2639                __imag__ result);
2640   result = FUNC(cexp) (BUILD_COMPLEX (0.0, minus_infty));
2641   check_isnan_exc ("real(cexp(0 - i inf)) = NaN plus invalid exception",
2642                    __real__ result, INVALID_EXCEPTION);
2643   check_isnan ("imag(cexp(0 - i inf)) = NaN plus invalid exception",
2644                __imag__ result);
2645   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_infty));
2646   check_isnan_exc ("real(cexp(-0 - i inf)) = NaN plus invalid exception",
2647                    __real__ result, INVALID_EXCEPTION);
2648   check_isnan ("imag(cexp(-0 - i inf)) = NaN plus invalid exception",
2649                __imag__ result);
2650
2651   result = FUNC(cexp) (BUILD_COMPLEX (100.0, plus_infty));
2652   check_isnan_exc ("real(cexp(100.0 + i inf)) = NaN plus invalid exception",
2653                    __real__ result, INVALID_EXCEPTION);
2654   check_isnan ("imag(cexp(100.0 + i inf)) = NaN plus invalid exception",
2655                __imag__ result);
2656   result = FUNC(cexp) (BUILD_COMPLEX (-100.0, plus_infty));
2657   check_isnan_exc ("real(cexp(-100.0 + i inf)) = NaN plus invalid exception",
2658                    __real__ result, INVALID_EXCEPTION);
2659   check_isnan ("imag(cexp(-100.0 + i inf)) = NaN plus invalid exception",
2660                __imag__ result);
2661   result = FUNC(cexp) (BUILD_COMPLEX (100.0, minus_infty));
2662   check_isnan_exc ("real(cexp(100.0 - i inf)) = NaN plus invalid exception",
2663                    __real__ result, INVALID_EXCEPTION);
2664   check_isnan ("imag(cexp(100.0 - i inf)) = NaN plus invalid exception",
2665                __imag__ result);
2666   result = FUNC(cexp) (BUILD_COMPLEX (-100.0, minus_infty));
2667   check_isnan_exc ("real(cexp(-100.0 - i inf)) = NaN plus invalid exception",
2668                    __real__ result, INVALID_EXCEPTION);
2669   check_isnan ("imag(cexp(-100.0 - i inf)) = NaN", __imag__ result);
2670
2671   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 2.0));
2672   check ("real(cexp(-inf + 2.0i)) = -0", __real__ result, minus_zero);
2673   check ("imag(cexp(-inf + 2.0i)) = 0", __imag__ result, 0);
2674   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 4.0));
2675   check ("real(cexp(-inf + 4.0i)) = -0", __real__ result, minus_zero);
2676   check ("imag(cexp(-inf + 4.0i)) = -0", __imag__ result, minus_zero);
2677
2678   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 2.0));
2679   check_isinfn ("real(cexp(+inf + 2.0i)) = -inf", __real__ result);
2680   check_isinfp ("imag(cexp(+inf + 2.0i)) = +inf", __imag__ result);
2681   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 4.0));
2682   check_isinfn ("real(cexp(+inf + 4.0i)) = -inf", __real__ result);
2683   check_isinfn ("imag(cexp(+inf + 4.0i)) = -inf", __imag__ result);
2684
2685   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_infty));
2686   check_isinfp_exc ("real(cexp(+inf + i inf)) = +inf plus invalid exception",
2687                     __real__ result, INVALID_EXCEPTION);
2688   check_isnan ("imag(cexp(+inf + i inf)) = NaN plus invalid exception",
2689                __imag__ result);
2690   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_infty));
2691   check_isinfp_exc ("real(cexp(+inf - i inf)) = +inf plus invalid exception",
2692                     __real__ result, INVALID_EXCEPTION);
2693   check_isnan ("imag(cexp(+inf - i inf)) = NaN plus invalid exception",
2694                __imag__ result);
2695
2696   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_infty));
2697   check ("real(cexp(-inf + i inf)) = 0", __real__ result, 0);
2698   check ("imag(cexp(-inf + i inf)) = 0", __imag__ result, 0);
2699   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_infty));
2700   check ("real(cexp(-inf - i inf)) = 0", __real__ result, 0);
2701   check ("imag(cexp(-inf - i inf)) = -0", __imag__ result, minus_zero);
2702
2703   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, nan_value));
2704   check ("real(cexp(-inf + i NaN)) = 0", __real__ result, 0);
2705   check ("imag(cexp(-inf + i NaN)) = 0", fabs (__imag__ result), 0);
2706
2707   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, nan_value));
2708   check_isinfp ("real(cexp(+inf + i NaN)) = +inf", __real__ result);
2709   check_isnan ("imag(cexp(+inf + i NaN)) = NaN", __imag__ result);
2710
2711   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 0.0));
2712   check_isnan_maybe_exc ("real(cexp(NaN + i0)) = NaN plus maybe invalid exception",
2713                          __real__ result, INVALID_EXCEPTION);
2714   check_isnan ("imag(cexp(NaN + i0)) = NaN plus maybe invalid exception",
2715                __imag__ result);
2716   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0));
2717   check_isnan_maybe_exc ("real(cexp(NaN + 1i)) = NaN plus maybe invalid exception",
2718                          __real__ result, INVALID_EXCEPTION);
2719   check_isnan ("imag(cexp(NaN + 1i)) = NaN plus maybe invalid exception",
2720                __imag__ result);
2721   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, plus_infty));
2722   check_isnan_maybe_exc ("real(cexp(NaN + i inf)) = NaN plus maybe invalid exception",
2723                          __real__ result, INVALID_EXCEPTION);
2724   check_isnan ("imag(cexp(NaN + i inf)) = NaN plus maybe invalid exception",
2725                __imag__ result);
2726
2727   result = FUNC(cexp) (BUILD_COMPLEX (0, nan_value));
2728   check_isnan_maybe_exc ("real(cexp(0 + i NaN)) = NaN plus maybe invalid exception",
2729                          __real__ result, INVALID_EXCEPTION);
2730   check_isnan ("imag(cexp(0 + i NaN)) = NaN plus maybe invalid exception",
2731                __imag__ result);
2732   result = FUNC(cexp) (BUILD_COMPLEX (1, nan_value));
2733   check_isnan_maybe_exc ("real(cexp(1 + i NaN)) = NaN plus maybe invalid exception",
2734                          __real__ result, INVALID_EXCEPTION);
2735   check_isnan ("imag(cexp(1 + i NaN)) = NaN plus maybe invalid exception",
2736                __imag__ result);
2737
2738   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, nan_value));
2739   check_isnan ("real(cexp(NaN + i NaN)) = NaN", __real__ result);
2740   check_isnan ("imag(cexp(NaN + i NaN)) = NaN", __imag__ result);
2741
2742   result = FUNC(cexp) (BUILD_COMPLEX (0.7, 1.2));
2743   check_eps ("real(cexp(0.7 + i 1.2)) == 0.72969...", __real__ result,
2744              0.7296989091503236012L, CHOOSE(6e-17L, 2e-16, 2e-7));
2745   check_eps ("imag(cexp(0.7 + i 1.2)) == 1.87689...", __imag__ result,
2746              1.8768962328348102821L, CHOOSE(2e-16L, 0, 3e-7));
2747
2748   result = FUNC(cexp) (BUILD_COMPLEX (-2, -3));
2749   check_eps ("real(cexp(-2 - i 3)) == -0.13398...", __real__ result,
2750              -0.1339809149295426134L, CHOOSE(6e-20L, 0, 2e-8));
2751   check_eps ("imag(cexp(-2 - i 3)) == -0.01909...", __imag__ result,
2752              -0.0190985162611351964L, CHOOSE(4e-20L, 0, 2e-9));
2753 }
2754
2755
2756 static void
2757 csin_test (void)
2758 {
2759   __complex__ MATHTYPE result;
2760
2761   result = FUNC(csin) (BUILD_COMPLEX (0.0, 0.0));
2762   check ("real(csin(0 + 0i)) = 0", __real__ result, 0);
2763   check ("imag(csin(0 + 0i)) = 0", __imag__ result, 0);
2764   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, 0.0));
2765   check ("real(csin(-0 + 0i)) = -0", __real__ result, minus_zero);
2766   check ("imag(csin(-0 + 0i)) = 0", __imag__ result, 0);
2767   result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_zero));
2768   check ("real(csin(0 - 0i)) = 0", __real__ result, 0);
2769   check ("imag(csin(0 - 0i)) = -0", __imag__ result, minus_zero);
2770   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_zero));
2771   check ("real(csin(-0 - 0i)) = -0", __real__ result, minus_zero);
2772   check ("imag(csin(-0 - 0i)) = -0", __imag__ result, minus_zero);
2773
2774   result = FUNC(csin) (BUILD_COMPLEX (0.0, plus_infty));
2775   check ("real(csin(0 + i Inf)) = 0", __real__ result, 0);
2776   check_isinfp ("imag(csin(0 + i Inf)) = +Inf", __imag__ result);
2777   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, plus_infty));
2778   check ("real(csin(-0 + i Inf)) = -0", __real__ result, minus_zero);
2779   check_isinfp ("imag(csin(-0 + i Inf)) = +Inf", __imag__ result);
2780   result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_infty));
2781   check ("real(csin(0 - i Inf)) = 0", __real__ result, 0);
2782   check_isinfn ("imag(csin(0 - i Inf)) = -Inf", __imag__ result);
2783   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_infty));
2784   check ("real(csin(-0 - i Inf)) = -0", __real__ result, minus_zero);
2785   check_isinfn("imag(csin(-0 - i Inf)) = -Inf", __imag__ result);
2786
2787   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 0.0));
2788   check_isnan_exc ("real(csin(+Inf + 0i)) = NaN plus invalid exception",
2789                    __real__ result, INVALID_EXCEPTION);
2790   check ("imag(csin(+Inf + 0i)) = +-0 plus invalid exception",
2791          FUNC(fabs) (__imag__ result), 0);
2792   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 0.0));
2793   check_isnan_exc ("real(csin(-Inf + 0i)) = NaN plus invalid exception",
2794                    __real__ result, INVALID_EXCEPTION);
2795   check ("imag(csin(-Inf + 0i)) = +-0 plus invalid exception",
2796          FUNC(fabs) (__imag__ result), 0);
2797   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_zero));
2798   check_isnan_exc ("real(csin(+Inf - 0i)) = NaN plus invalid exception",
2799                    __real__ result, INVALID_EXCEPTION);
2800   check ("imag(csin(+Inf - 0i)) = +-0 plus invalid exception",
2801          FUNC(fabs) (__imag__ result), 0.0);
2802   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_zero));
2803   check_isnan_exc ("real(csin(-Inf - 0i)) = NaN plus invalid exception",
2804                    __real__ result, INVALID_EXCEPTION);
2805   check ("imag(csin(-Inf - 0i)) = +-0 plus invalid exception",
2806          FUNC(fabs) (__imag__ result), 0.0);
2807
2808   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, plus_infty));
2809   check_isnan_exc ("real(csin(+Inf + i Inf)) = NaN plus invalid exception",
2810                    __real__ result, INVALID_EXCEPTION);
2811   check_isinfp ("imag(csin(+Inf + i Inf)) = +-Inf plus invalid exception",
2812                 FUNC(fabs) (__imag__ result));
2813   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, plus_infty));
2814   check_isnan_exc ("real(csin(-Inf + i Inf)) = NaN plus invalid exception",
2815                    __real__ result, INVALID_EXCEPTION);
2816   check_isinfp ("imag(csin(-Inf + i Inf)) = +-Inf plus invalid exception",
2817                 FUNC(fabs) (__imag__ result));
2818   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_infty));
2819   check_isnan_exc ("real(csin(Inf - i Inf)) = NaN plus invalid exception",
2820                    __real__ result, INVALID_EXCEPTION);
2821   check_isinfp ("imag(csin(Inf - i Inf)) = +-Inf plus invalid exception",
2822                 FUNC(fabs) (__imag__ result));
2823   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_infty));
2824   check_isnan_exc ("real(csin(-Inf - i Inf)) = NaN plus invalid exception",
2825                    __real__ result, INVALID_EXCEPTION);
2826   check_isinfp ("imag(csin(-Inf - i Inf)) = +-Inf plus invalid exception",
2827                 FUNC(fabs) (__imag__ result));
2828
2829   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 6.75));
2830   check_isnan_exc ("real(csin(+Inf + i 6.75)) = NaN plus invalid exception",
2831                    __real__ result, INVALID_EXCEPTION);
2832   check_isnan ("imag(csin(+Inf + i6.75)) = NaN plus invalid exception",
2833                __imag__ result);
2834   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, -6.75));
2835   check_isnan_exc ("real(csin(+Inf - i 6.75)) = NaN plus invalid exception",
2836                    __real__ result, INVALID_EXCEPTION);
2837   check_isnan ("imag(csin(+Inf - i6.75)) = NaN plus invalid exception",
2838                __imag__ result);
2839   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 6.75));
2840   check_isnan_exc ("real(csin(-Inf + i6.75)) = NaN plus invalid exception",
2841                    __real__ result, INVALID_EXCEPTION);
2842   check_isnan ("imag(csin(-Inf + i6.75)) = NaN plus invalid exception",
2843                __imag__ result);
2844   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, -6.75));
2845   check_isnan_exc ("real(csin(-Inf - i6.75)) = NaN plus invalid exception",
2846                    __real__ result, INVALID_EXCEPTION);
2847   check_isnan ("imag(csin(-Inf - i6.75)) = NaN plus invalid exception",
2848                __imag__ result);
2849
2850   result = FUNC(csin) (BUILD_COMPLEX (4.625, plus_infty));
2851   check_isinfn ("real(csin(4.625 + i Inf)) = -Inf", __real__ result);
2852   check_isinfn ("imag(csin(4.625 + i Inf)) = -Inf", __imag__ result);
2853   result = FUNC(csin) (BUILD_COMPLEX (4.625, minus_infty));
2854   check_isinfn ("real(csin(4.625 - i Inf)) = -Inf", __real__ result);
2855   check_isinfp ("imag(csin(4.625 - i Inf)) = +Inf", __imag__ result);
2856   result = FUNC(csin) (BUILD_COMPLEX (-4.625, plus_infty));
2857   check_isinfp ("real(csin(-4.625 + i Inf)) = +Inf", __real__ result);
2858   check_isinfn ("imag(csin(-4.625 + i Inf)) = -Inf", __imag__ result);
2859   result = FUNC(csin) (BUILD_COMPLEX (-4.625, minus_infty));
2860   check_isinfp ("real(csin(-4.625 - i Inf)) = +Inf", __real__ result);
2861   check_isinfp ("imag(csin(-4.625 - i Inf)) = +Inf", __imag__ result);
2862
2863   result = FUNC(csin) (BUILD_COMPLEX (nan_value, 0.0));
2864   check_isnan ("real(csin(NaN + i0)) = NaN", __real__ result);
2865   check ("imag(csin(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
2866   result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_zero));
2867   check_isnan ("real(csin(NaN - i0)) = NaN", __real__ result);
2868   check ("imag(csin(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
2869
2870   result = FUNC(csin) (BUILD_COMPLEX (nan_value, plus_infty));
2871   check_isnan ("real(csin(NaN + i Inf)) = NaN", __real__ result);
2872   check_isinfp ("imag(csin(NaN + i Inf)) = +-Inf",
2873                 FUNC(fabs) (__imag__ result));
2874   result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_infty));
2875   check_isnan ("real(csin(NaN - i Inf)) = NaN", __real__ result);
2876   check_isinfp ("real(csin(NaN - i Inf)) = +-Inf",
2877                 FUNC(fabs) (__imag__ result));
2878
2879   result = FUNC(csin) (BUILD_COMPLEX (nan_value, 9.0));
2880   check_isnan_maybe_exc ("real(csin(NaN + i9.0)) = NaN plus maybe invalid exception",
2881                          __real__ result, INVALID_EXCEPTION);
2882   check_isnan ("imag(csin(NaN + i9.0)) = NaN plus maybe invalid exception",
2883                __imag__ result);
2884   result = FUNC(csin) (BUILD_COMPLEX (nan_value, -9.0));
2885   check_isnan_maybe_exc ("real(csin(NaN - i9.0)) = NaN plus maybe invalid exception",
2886                          __real__ result, INVALID_EXCEPTION);
2887   check_isnan ("imag(csin(NaN - i9.0)) = NaN plus maybe invalid exception",
2888                __imag__ result);
2889
2890   result = FUNC(csin) (BUILD_COMPLEX (0.0, nan_value));
2891   check ("real(csin(0 + i NaN))", __real__ result, 0.0);
2892   check_isnan ("imag(csin(0 + i NaN)) = NaN", __imag__ result);
2893   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, nan_value));
2894   check ("real(csin(-0 + i NaN)) = -0", __real__ result, minus_zero);
2895   check_isnan ("imag(csin(-0 + NaN)) = NaN", __imag__ result);
2896
2897   result = FUNC(csin) (BUILD_COMPLEX (10.0, nan_value));
2898   check_isnan_maybe_exc ("real(csin(10 + i NaN)) = NaN plus maybe invalid exception",
2899                          __real__ result, INVALID_EXCEPTION);
2900   check_isnan ("imag(csin(10 + i NaN)) = NaN plus maybe invalid exception",
2901                __imag__ result);
2902   result = FUNC(csin) (BUILD_COMPLEX (nan_value, -10.0));
2903   check_isnan_maybe_exc ("real(csin(-10 + i NaN)) = NaN plus maybe invalid exception",
2904                          __real__ result, INVALID_EXCEPTION);
2905   check_isnan ("imag(csin(-10 + i NaN)) = NaN plus maybe invalid exception",
2906                __imag__ result);
2907
2908   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, nan_value));
2909   check_isnan_maybe_exc ("real(csin(+Inf + i NaN)) = NaN plus maybe invalid exception",
2910                          __real__ result, INVALID_EXCEPTION);
2911   check_isnan ("imag(csin(+Inf + i NaN)) = NaN plus maybe invalid exception",
2912                __imag__ result);
2913   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, nan_value));
2914   check_isnan_maybe_exc ("real(csin(-Inf + i NaN)) = NaN plus maybe invalid exception",
2915                          __real__ result, INVALID_EXCEPTION);
2916   check_isnan ("imag(csin(-Inf + i NaN)) = NaN plus maybe invalid exception",
2917                __imag__ result);
2918
2919   result = FUNC(csin) (BUILD_COMPLEX (nan_value, nan_value));
2920   check_isnan ("real(csin(NaN + i NaN)) = NaN", __real__ result);
2921   check_isnan ("imag(csin(NaN + i NaN)) = NaN", __imag__ result);
2922
2923   result = FUNC(csin) (BUILD_COMPLEX (0.7, 1.2));
2924   check_eps ("real(csin(0.7 + i 1.2)) = 1.166456341...", __real__ result,
2925              1.1664563419657581376L, CHOOSE(2e-16L, 0, 0));
2926   check_eps ("imag(csin(0.7 + i 1.2)) = 1.154499724...", __imag__ result,
2927              1.1544997246948547371L, CHOOSE(2e-17L, 0, 2e-7));
2928
2929   result = FUNC(csin) (BUILD_COMPLEX (-2, -3));
2930   check_eps ("real(csin(-2 - i 3)) == -9.15449...", __real__ result,
2931              -9.1544991469114295734L, CHOOSE(4e-18L, 0, 1e-6));
2932   check_eps ("imag(csin(-2 - i 3)) == -4.16890...", __imag__ result,
2933              4.1689069599665643507L, CHOOSE(2e-17L, 0, 5e-7));
2934 }
2935
2936
2937 static void
2938 csinh_test (void)
2939 {
2940   __complex__ MATHTYPE result;
2941
2942   result = FUNC(csinh) (BUILD_COMPLEX (0.0, 0.0));
2943   check ("real(csinh(0 + 0i)) = 0", __real__ result, 0);
2944   check ("imag(csinh(0 + 0i)) = 0", __imag__ result, 0);
2945   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, 0.0));
2946   check ("real(csinh(-0 + 0i)) = -0", __real__ result, minus_zero);
2947   check ("imag(csinh(-0 + 0i)) = 0", __imag__ result, 0);
2948   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_zero));
2949   check ("real(csinh(0 - 0i)) = 0", __real__ result, 0);
2950   check ("imag(csinh(0 - 0i)) = -0", __imag__ result, minus_zero);
2951   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_zero));
2952   check ("real(csinh(-0 - 0i)) = -0", __real__ result, minus_zero);
2953   check ("imag(csinh(-0 - 0i)) = -0", __imag__ result, minus_zero);
2954
2955   result = FUNC(csinh) (BUILD_COMPLEX (0.0, plus_infty));
2956   check_exc ("real(csinh(0 + i Inf)) = +-0 plus invalid exception",
2957              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2958   check_isnan ("imag(csinh(0 + i Inf)) = NaN plus invalid exception",
2959                __imag__ result);
2960   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, plus_infty));
2961   check_exc ("real(csinh(-0 + i Inf)) = +-0 plus invalid exception",
2962              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2963   check_isnan ("imag(csinh(-0 + i Inf)) = NaN plus invalid exception",
2964                __imag__ result);
2965   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_infty));
2966   check_exc ("real(csinh(0 - i Inf)) = +-0 plus invalid exception",
2967              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2968   check_isnan ("imag(csinh(0 - i Inf)) = NaN plus invalid exception",
2969                __imag__ result);
2970   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_infty));
2971   check_exc ("real(csinh(-0 - i Inf)) = +-0 plus invalid exception",
2972              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2973   check_isnan ("imag(csinh(-0 - i Inf)) = NaN plus invalid exception",
2974                __imag__ result);
2975
2976   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 0.0));
2977   check_isinfp ("real(csinh(+Inf + 0i)) = +Inf", __real__ result);
2978   check ("imag(csinh(+Inf + 0i)) = 0", __imag__ result, 0);
2979   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 0.0));
2980   check_isinfn ("real(csinh(-Inf + 0i)) = -Inf", __real__ result);
2981   check ("imag(csinh(-Inf + 0i)) = 0", __imag__ result, 0);
2982   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_zero));
2983   check_isinfp ("real(csinh(+Inf - 0i)) = +Inf", __real__ result);
2984   check ("imag(csinh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
2985   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_zero));
2986   check_isinfn ("real(csinh(-Inf - 0i)) = -Inf", __real__ result);
2987   check ("imag(csinh(-Inf - 0i)) = -0", __imag__ result, minus_zero);
2988
2989   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, plus_infty));
2990   check_isinfp_exc ("real(csinh(+Inf + i Inf)) = +-Inf plus invalid exception",
2991                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
2992   check_isnan ("imag(csinh(+Inf + i Inf)) = NaN plus invalid exception",
2993                __imag__ result);
2994   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, plus_infty));
2995   check_isinfp_exc ("real(csinh(-Inf + i Inf)) = +-Inf plus invalid exception",
2996                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
2997   check_isnan ("imag(csinh(-Inf + i Inf)) = NaN plus invalid exception",
2998                __imag__ result);
2999   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_infty));
3000   check_isinfp_exc ("real(csinh(Inf - i Inf)) = +-Inf plus invalid exception",
3001                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
3002   check_isnan ("imag(csinh(Inf - i Inf)) = NaN plus invalid exception",
3003                __imag__ result);
3004   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_infty));
3005   check_isinfp_exc ("real(csinh(-Inf - i Inf)) = +-Inf plus invalid exception",
3006                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
3007   check_isnan ("imag(csinh(-Inf - i Inf)) = NaN plus invalid exception",
3008                __imag__ result);
3009
3010   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 4.625));
3011   check_isinfn ("real(csinh(+Inf + i4.625)) = -Inf", __real__ result);
3012   check_isinfn ("imag(csinh(+Inf + i4.625)) = -Inf", __imag__ result);
3013   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 4.625));
3014   check_isinfp ("real(csinh(-Inf + i4.625)) = +Inf", __real__ result);
3015   check_isinfn ("imag(csinh(-Inf + i4.625)) = -Inf", __imag__ result);
3016   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, -4.625));
3017   check_isinfn ("real(csinh(+Inf - i4.625)) = -Inf", __real__ result);
3018   check_isinfp ("imag(csinh(+Inf - i4.625)) = +Inf", __imag__ result);
3019   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, -4.625));
3020   check_isinfp ("real(csinh(-Inf - i4.625)) = +Inf", __real__ result);
3021   check_isinfp ("imag(csinh(-Inf - i4.625)) = +Inf", __imag__ result);
3022
3023   result = FUNC(csinh) (BUILD_COMPLEX (6.75, plus_infty));
3024   check_isnan_exc ("real(csinh(6.75 + i Inf)) = NaN plus invalid exception",
3025                    __real__ result, INVALID_EXCEPTION);
3026   check_isnan ("imag(csinh(6.75 + i Inf)) = NaN plus invalid exception",
3027                __imag__ result);
3028   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, plus_infty));
3029   check_isnan_exc ("real(csinh(-6.75 + i Inf)) = NaN plus invalid exception",
3030                    __real__ result, INVALID_EXCEPTION);
3031   check_isnan ("imag(csinh(-6.75 + i Inf)) = NaN plus invalid exception",
3032                __imag__ result);
3033   result = FUNC(csinh) (BUILD_COMPLEX (6.75, minus_infty));
3034   check_isnan_exc ("real(csinh(6.75 - i Inf)) = NaN plus invalid exception",
3035                    __real__ result, INVALID_EXCEPTION);
3036   check_isnan ("imag(csinh(6.75 - i Inf)) = NaN plus invalid exception",
3037                __imag__ result);
3038   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, minus_infty));
3039   check_isnan_exc ("real(csinh(-6.75 - i Inf)) = NaN plus invalid exception",
3040                    __real__ result, INVALID_EXCEPTION);
3041   check_isnan ("imag(csinh(-6.75 - i Inf)) = NaN plus invalid exception",
3042                __imag__ result);
3043
3044   result = FUNC(csinh) (BUILD_COMPLEX (0.0, nan_value));
3045   check ("real(csinh(0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0);
3046   check_isnan ("imag(csinh(0 + i NaN)) = NaN", __imag__ result);
3047   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, nan_value));
3048   check ("real(csinh(-0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0);
3049   check_isnan ("imag(csinh(-0 + i NaN)) = NaN", __imag__ result);
3050
3051   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, nan_value));
3052   check_isinfp ("real(csinh(+Inf + i NaN)) = +-Inf",
3053                 FUNC(fabs) (__real__ result));
3054   check_isnan ("imag(csinh(+Inf + i NaN)) = NaN", __imag__ result);
3055   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, nan_value));
3056   check_isinfp ("real(csinh(-Inf + i NaN)) = +-Inf",
3057                 FUNC(fabs) (__real__ result));
3058   check_isnan ("imag(csinh(-Inf + i NaN)) = NaN", __imag__ result);
3059
3060   result = FUNC(csinh) (BUILD_COMPLEX (9.0, nan_value));
3061   check_isnan_maybe_exc ("real(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3062                          __real__ result, INVALID_EXCEPTION);
3063   check_isnan ("imag(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3064                __imag__ result);
3065   result = FUNC(csinh) (BUILD_COMPLEX (-9.0, nan_value));
3066   check_isnan_maybe_exc ("real(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3067                          __real__ result, INVALID_EXCEPTION);
3068   check_isnan ("imag(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3069                __imag__ result);
3070
3071   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 0.0));
3072   check_isnan ("real(csinh(NaN + i0)) = NaN", __real__ result);
3073   check ("imag(csinh(NaN + i0)) = 0", __imag__ result, 0.0);
3074   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_zero));
3075   check_isnan ("real(csinh(NaN - i0)) = NaN", __real__ result);
3076   check ("imag(csinh(NaN - i0)) = -0", __imag__ result, minus_zero);
3077
3078   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 10.0));
3079   check_isnan_maybe_exc ("real(csinh(NaN + i10)) = NaN plus maybe invalid exception",
3080                          __real__ result, INVALID_EXCEPTION);
3081   check_isnan ("imag(csinh(NaN + i10)) = NaN plus maybe invalid exception",
3082                __imag__ result);
3083   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, -10.0));
3084   check_isnan_maybe_exc ("real(csinh(NaN - i10)) = NaN plus maybe invalid exception",
3085                          __real__ result, INVALID_EXCEPTION);
3086   check_isnan ("imag(csinh(NaN - i10)) = NaN plus maybe invalid exception",
3087                __imag__ result);
3088
3089   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, plus_infty));
3090   check_isnan_maybe_exc ("real(csinh(NaN + i Inf)) = NaN plus maybe invalid exception",
3091                          __real__ result, INVALID_EXCEPTION);
3092   check_isnan ("imag(csinh(NaN + i Inf)) = NaN plus maybe invalid exception",
3093                __imag__ result);
3094   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_infty));
3095   check_isnan_maybe_exc ("real(csinh(NaN - i Inf)) = NaN plus maybe invalid exception",
3096                          __real__ result, INVALID_EXCEPTION);
3097   check_isnan ("imag(csinh(NaN - i Inf)) = NaN plus maybe invalid exception",
3098                __imag__ result);
3099
3100   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, nan_value));
3101   check_isnan ("real(csinh(NaN + i NaN)) = NaN", __real__ result);
3102   check_isnan ("imag(csinh(NaN + i NaN)) = NaN", __imag__ result);
3103
3104   result = FUNC(csinh) (BUILD_COMPLEX (0.7, 1.2));
3105   check_eps ("real(csinh(0.7 + i 1.2)) = 0.274878686...", __real__ result,
3106              0.27487868678117583582L, CHOOSE(2e-17L, 6e-17, 3e-8));
3107   check_eps ("imag(csinh(0.7 + i 1.2)) = 1.169866572...", __imag__ result,
3108              1.1698665727426565139L, CHOOSE(6e-17L, 0, 2e-7));
3109
3110   result = FUNC(csinh) (BUILD_COMPLEX (-2, -3));
3111   check_eps ("real(csinh(-2 - i 3)) == -3.59056...", __real__ result,
3112              3.5905645899857799520L, CHOOSE(7e-19L, 5e-16, 3e-7));
3113   check_eps ("imag(csinh(-2 - i 3)) == -0.53092...", __imag__ result,
3114              -0.5309210862485198052L, CHOOSE(3e-19L, 2e-16, 6e-8));
3115 }
3116
3117
3118 static void
3119 ccos_test (void)
3120 {
3121   __complex__ MATHTYPE result;
3122
3123   result = FUNC(ccos) (BUILD_COMPLEX (0.0, 0.0));
3124   check ("real(ccos(0 + 0i)) = 1.0", __real__ result, 1.0);
3125   check ("imag(ccos(0 + 0i)) = -0", __imag__ result, minus_zero);
3126   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, 0.0));
3127   check ("real(ccos(-0 + 0i)) = 1.0", __real__ result, 1.0);
3128   check ("imag(ccos(-0 + 0i)) = 0", __imag__ result, 0.0);
3129   result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_zero));
3130   check ("real(ccos(0 - 0i)) = 1.0", __real__ result, 1.0);
3131   check ("imag(ccos(0 - 0i)) = 0", __imag__ result, 0.0);
3132   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_zero));
3133   check ("real(ccos(-0 - 0i)) = 1.0", __real__ result, 1.0);
3134   check ("imag(ccos(-0 - 0i)) = -0", __imag__ result, minus_zero);
3135
3136   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 0.0));
3137   check_isnan_exc ("real(ccos(+Inf + i0)) = NaN plus invalid exception",
3138                    __real__ result, INVALID_EXCEPTION);
3139   check ("imag(ccos(Inf + i0)) = +-0 plus invalid exception",
3140          FUNC(fabs) (__imag__ result), 0);
3141   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_zero));
3142   check_isnan_exc ("real(ccos(Inf - i0)) = NaN plus invalid exception",
3143                    __real__ result, INVALID_EXCEPTION);
3144   check ("imag(ccos(Inf - i0)) = +-0 plus invalid exception",
3145          FUNC(fabs) (__imag__ result), 0);
3146   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 0.0));
3147   check_isnan_exc ("real(ccos(-Inf + i0)) = NaN plus invalid exception",
3148                    __real__ result, INVALID_EXCEPTION);
3149   check ("imag(ccos(-Inf + i0)) = +-0 plus invalid exception",
3150          FUNC(fabs) (__imag__ result), 0);
3151   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_zero));
3152   check_isnan_exc ("real(ccos(-Inf - i0)) = NaN plus invalid exception",
3153                    __real__ result, INVALID_EXCEPTION);
3154   check ("imag(ccos(-Inf - i0)) = +-0 plus invalid exception",
3155          FUNC(fabs) (__imag__ result), 0);
3156
3157   result = FUNC(ccos) (BUILD_COMPLEX (0.0, plus_infty));
3158   check_isinfp ("real(ccos(0 + i Inf)) = +Inf", __real__ result);
3159   check ("imag(ccos(0 + i Inf)) = -0", __imag__ result, minus_zero);
3160   result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_infty));
3161   check_isinfp ("real(ccos(0 - i Inf)) = +Inf", __real__ result);
3162   check ("imag(ccos(0 - i Inf)) = 0", __imag__ result, 0);
3163   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, plus_infty));
3164   check_isinfp ("real(ccos(-0 + i Inf)) = +Inf", __real__ result);
3165   check ("imag(ccos(-0 + i Inf)) = 0", __imag__ result, 0.0);
3166   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_infty));
3167   check_isinfp ("real(ccos(-0 - i Inf)) = +Inf", __real__ result);
3168   check ("imag(ccos(-0 - i Inf)) = -0", __imag__ result, minus_zero);
3169
3170   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, plus_infty));
3171   check_isinfp_exc ("real(ccos(+Inf + i Inf)) = +Inf plus invalid exception",
3172                     __real__ result, INVALID_EXCEPTION);
3173   check_isnan ("imag(ccos(+Inf + i Inf)) = NaN plus invalid exception",
3174                __imag__ result);
3175   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, plus_infty));
3176   check_isinfp_exc ("real(ccos(-Inf + i Inf)) = +Inf plus invalid exception",
3177                     __real__ result, INVALID_EXCEPTION);
3178   check_isnan ("imag(ccos(-Inf + i Inf)) = NaN plus invalid exception",
3179                __imag__ result);
3180   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_infty));
3181   check_isinfp_exc ("real(ccos(Inf - i Inf)) = +Inf plus invalid exception",
3182                     __real__ result, INVALID_EXCEPTION);
3183   check_isnan ("imag(ccos(Inf - i Inf)) = NaN plus invalid exception",
3184                __imag__ result);
3185   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_infty));
3186   check_isinfp_exc ("real(ccos(-Inf - i Inf)) = +Inf plus invalid exception",
3187                     __real__ result, INVALID_EXCEPTION);
3188   check_isnan ("imag(ccos(-Inf - i Inf)) = NaN plus invalid exception",
3189                __imag__ result);
3190
3191   result = FUNC(ccos) (BUILD_COMPLEX (4.625, plus_infty));
3192   check_isinfn ("real(ccos(4.625 + i Inf)) = -Inf", __real__ result);
3193   check_isinfp ("imag(ccos(4.625 + i Inf)) = +Inf", __imag__ result);
3194   result = FUNC(ccos) (BUILD_COMPLEX (4.625, minus_infty));
3195   check_isinfn ("real(ccos(4.625 - i Inf)) = -Inf", __real__ result);
3196   check_isinfn ("imag(ccos(4.625 - i Inf)) = -Inf", __imag__ result);
3197   result = FUNC(ccos) (BUILD_COMPLEX (-4.625, plus_infty));
3198   check_isinfn ("real(ccos(-4.625 + i Inf)) = -Inf", __real__ result);
3199   check_isinfn ("imag(ccos(-4.625 + i Inf)) = -Inf", __imag__ result);
3200   result = FUNC(ccos) (BUILD_COMPLEX (-4.625, minus_infty));
3201   check_isinfn ("real(ccos(-4.625 - i Inf)) = -Inf", __real__ result);
3202   check_isinfp ("imag(ccos(-4.625 - i Inf)) = +Inf", __imag__ result);
3203
3204   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 6.75));
3205   check_isnan_exc ("real(ccos(+Inf + i6.75)) = NaN plus invalid exception",
3206                    __real__ result, INVALID_EXCEPTION);
3207   check_isnan ("imag(ccos(+Inf + i6.75)) = NaN plus invalid exception",
3208                __imag__ result);
3209   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, -6.75));
3210   check_isnan_exc ("real(ccos(+Inf - i6.75)) = NaN plus invalid exception",
3211                    __real__ result, INVALID_EXCEPTION);
3212   check_isnan ("imag(ccos(+Inf - i6.75)) = NaN plus invalid exception",
3213                __imag__ result);
3214   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 6.75));
3215   check_isnan_exc ("real(ccos(-Inf + i6.75)) = NaN plus invalid exception",
3216                    __real__ result, INVALID_EXCEPTION);
3217   check_isnan ("imag(ccos(-Inf + i6.75)) = NaN plus invalid exception",
3218                __imag__ result);
3219   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, -6.75));
3220   check_isnan_exc ("real(ccos(-Inf - i6.75)) = NaN plus invalid exception",
3221                    __real__ result, INVALID_EXCEPTION);
3222   check_isnan ("imag(ccos(-Inf - i6.75)) = NaN plus invalid exception",
3223                __imag__ result);
3224
3225   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 0.0));
3226   check_isnan ("real(ccos(NaN + i0)) = NaN", __real__ result);
3227   check ("imag(ccos(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
3228   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_zero));
3229   check_isnan ("real(ccos(NaN - i0)) = NaN", __real__ result);
3230   check ("imag(ccos(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
3231
3232   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, plus_infty));
3233   check_isinfp ("real(ccos(NaN + i Inf)) = +Inf", __real__ result);
3234   check_isnan ("imag(ccos(NaN + i Inf)) = NaN", __imag__ result);
3235   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_infty));
3236   check_isinfp ("real(ccos(NaN - i Inf)) = +Inf", __real__ result);
3237   check_isnan ("imag(ccos(NaN - i Inf)) = NaN", __imag__ result);
3238
3239   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 9.0));
3240   check_isnan_maybe_exc ("real(ccos(NaN + i9.0)) = NaN plus maybe invalid exception",
3241                          __real__ result, INVALID_EXCEPTION);
3242   check_isnan ("imag(ccos(NaN + i9.0)) = NaN plus maybe invalid exception",
3243                __imag__ result);
3244   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, -9.0));
3245   check_isnan_maybe_exc ("real(ccos(NaN - i9.0)) = NaN plus maybe invalid exception",
3246                          __real__ result, INVALID_EXCEPTION);
3247   check_isnan ("imag(ccos(NaN - i9.0)) = NaN plus maybe invalid exception",
3248                __imag__ result);
3249
3250   result = FUNC(ccos) (BUILD_COMPLEX (0.0, nan_value));
3251   check_isnan ("real(ccos(0 + i NaN)) = NaN", __real__ result);
3252   check ("imag(ccos(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3253   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, nan_value));
3254   check_isnan ("real(ccos(-0 + i NaN)) = NaN", __real__ result);
3255   check ("imag(ccos(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3256
3257   result = FUNC(ccos) (BUILD_COMPLEX (10.0, nan_value));
3258   check_isnan_maybe_exc ("real(ccos(10 + i NaN)) = NaN plus maybe invalid exception",
3259                          __real__ result, INVALID_EXCEPTION);
3260   check_isnan ("imag(ccos(10 + i NaN)) = NaN plus maybe invalid exception",
3261                __imag__ result);
3262   result = FUNC(ccos) (BUILD_COMPLEX (-10.0, nan_value));
3263   check_isnan_maybe_exc ("real(ccos(-10 + i NaN)) = NaN plus maybe invalid exception",
3264                          __real__ result, INVALID_EXCEPTION);
3265   check_isnan ("imag(ccos(-10 + i NaN)) = NaN plus maybe invalid exception",
3266                __imag__ result);
3267
3268   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, nan_value));
3269   check_isnan_maybe_exc ("real(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception",
3270                          __real__ result, INVALID_EXCEPTION);
3271   check_isnan ("imag(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception",
3272                __imag__ result);
3273   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, nan_value));
3274   check_isnan_maybe_exc ("real(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception",
3275                          __real__ result, INVALID_EXCEPTION);
3276   check_isnan ("imag(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception",
3277                __imag__ result);
3278
3279   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, nan_value));
3280   check_isnan ("real(ccos(NaN + i NaN)) = NaN", __real__ result);
3281   check_isnan ("imag(ccos(NaN + i NaN)) = NaN", __imag__ result);
3282
3283   result = FUNC(ccos) (BUILD_COMPLEX (0.7, 1.2));
3284   check_eps ("real(ccos(0.7 + i 1.2)) = 1.384865764...", __real__ result,
3285              1.3848657645312111080L, CHOOSE(4e-18L, 3e-16, 2e-7));
3286   check_eps ("imag(ccos(0.7 + i 1.2)) = -0.972421703...", __imag__ result,
3287              -0.97242170335830028619L, CHOOSE(2e-16L, 2e-16, 0));
3288
3289   result = FUNC(ccos) (BUILD_COMPLEX (-2, -3));
3290   check_eps ("real(ccos(-2 - i 3)) == -4.18962...", __real__ result,
3291              -4.1896256909688072301L, CHOOSE(2e-17L, 0, 5e-7));
3292   check_eps ("imag(ccos(-2 - i 3)) == -9.10922...", __imag__ result,
3293              -9.1092278937553365979L, CHOOSE(3e-18L, 0, 1e-6));
3294 }
3295
3296
3297 static void
3298 ccosh_test (void)
3299 {
3300   __complex__ MATHTYPE result;
3301
3302   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, 0.0));
3303   check ("real(ccosh(0 + 0i)) = 1.0", __real__ result, 1.0);
3304   check ("imag(ccosh(0 + 0i)) = 0", __imag__ result, 0);
3305   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, 0.0));
3306   check ("real(ccosh(-0 + 0i)) = 1.0", __real__ result, 1.0);
3307   check ("imag(ccosh(-0 + 0i)) = -0", __imag__ result, minus_zero);
3308   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_zero));
3309   check ("real(ccosh(0 - 0i)) = 1.0", __real__ result, 1.0);
3310   check ("imag(ccosh(0 - 0i)) = -0", __imag__ result, minus_zero);
3311   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_zero));
3312   check ("real(ccosh(-0 - 0i)) = 1.0", __real__ result, 1.0);
3313   check ("imag(ccosh(-0 - 0i)) = 0", __imag__ result, 0.0);
3314
3315   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, plus_infty));
3316   check_isnan_exc ("real(ccosh(0 + i Inf)) = NaN plus invalid exception",
3317                    __real__ result, INVALID_EXCEPTION);
3318   check ("imag(ccosh(0 + i Inf)) = +-0 plus invalid exception",
3319          FUNC(fabs) (__imag__ result), 0);
3320   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, plus_infty));
3321   check_isnan_exc ("real(ccosh(-0 + i Inf)) = NaN plus invalid exception",
3322                    __real__ result, INVALID_EXCEPTION);
3323   check ("imag(ccosh(-0 + i Inf)) = +-0 plus invalid exception",
3324          FUNC(fabs) (__imag__ result), 0);
3325   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_infty));
3326   check_isnan_exc ("real(ccosh(0 - i Inf)) = NaN plus invalid exception",
3327                    __real__ result, INVALID_EXCEPTION);
3328   check ("imag(ccosh(0 - i Inf)) = +-0 plus invalid exception",
3329          FUNC(fabs) (__imag__ result), 0);
3330   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_infty));
3331   check_isnan_exc ("real(ccosh(-0 - i Inf)) = NaN plus invalid exception",
3332                    __real__ result, INVALID_EXCEPTION);
3333   check ("imag(ccosh(-0 - i Inf)) = +-0 plus invalid exception",
3334          FUNC(fabs) (__imag__ result), 0);
3335
3336   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 0.0));
3337   check_isinfp ("real(ccosh(+Inf + 0i)) = +Inf", __real__ result);
3338   check ("imag(ccosh(+Inf + 0i)) = 0", __imag__ result, 0);
3339   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 0.0));
3340   check_isinfp ("real(ccosh(-Inf + 0i)) = +Inf", __real__ result);
3341   check ("imag(ccosh(-Inf + 0i)) = -0", __imag__ result, minus_zero);
3342   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_zero));
3343   check_isinfp ("real(ccosh(+Inf - 0i)) = +Inf", __real__ result);
3344   check ("imag(ccosh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
3345   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_zero));
3346   check_isinfp ("real(ccosh(-Inf - 0i)) = +Inf", __real__ result);
3347   check ("imag(ccosh(-Inf - 0i)) = 0", __imag__ result, 0.0);
3348
3349   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, plus_infty));
3350   check_isinfp_exc ("real(ccosh(+Inf + i Inf)) = +Inf plus invalid exception",
3351                     __real__ result, INVALID_EXCEPTION);
3352   check_isnan ("imag(ccosh(+Inf + i Inf)) = NaN plus invalid exception",
3353                __imag__ result);
3354   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, plus_infty));
3355   check_isinfp_exc ("real(ccosh(-Inf + i Inf)) = +Inf plus invalid exception",
3356                     __real__ result, INVALID_EXCEPTION);
3357   check_isnan ("imag(ccosh(-Inf + i Inf)) = NaN plus invalid exception",
3358                __imag__ result);
3359   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_infty));
3360   check_isinfp_exc ("real(ccosh(Inf - i Inf)) = +Inf plus invalid exception",
3361                     __real__ result, INVALID_EXCEPTION);
3362   check_isnan ("imag(ccosh(Inf - i Inf)) = NaN plus invalid exception",
3363                __imag__ result);
3364   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_infty));
3365   check_isinfp_exc ("real(ccosh(-Inf - i Inf)) = +Inf plus invalid exception",
3366                     __real__ result, INVALID_EXCEPTION);
3367   check_isnan ("imag(ccosh(-Inf - i Inf)) = NaN plus invalid exception",
3368                __imag__ result);
3369
3370   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 4.625));
3371   check_isinfn ("real(ccosh(+Inf + i4.625)) = -Inf", __real__ result);
3372   check_isinfn ("imag(ccosh(+Inf + i4.625)) = -Inf", __imag__ result);
3373   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 4.625));
3374   check_isinfn ("real(ccosh(-Inf + i4.625)) = -Inf", __real__ result);
3375   check_isinfp ("imag(ccosh(-Inf + i4.625)) = Inf", __imag__ result);
3376   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, -4.625));
3377   check_isinfn ("real(ccosh(+Inf - i4.625)) = -Inf", __real__ result);
3378   check_isinfp ("imag(ccosh(+Inf - i4.625)) = +Inf", __imag__ result);
3379   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, -4.625));
3380   check_isinfn ("real(ccosh(-Inf - i4.625)) = -Inf", __real__ result);
3381   check_isinfn ("imag(ccosh(-Inf - i4.625)) = -Inf", __imag__ result);
3382
3383   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, plus_infty));
3384   check_isnan_exc ("real(ccosh(6.75 + i Inf)) = NaN plus invalid exception",
3385                    __real__ result, INVALID_EXCEPTION);
3386   check_isnan ("imag(ccosh(6.75 + i Inf)) = NaN plus invalid exception",
3387                __imag__ result);
3388   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, plus_infty));
3389   check_isnan_exc ("real(ccosh(-6.75 + i Inf)) = NaN plus invalid exception",
3390                    __real__ result, INVALID_EXCEPTION);
3391   check_isnan ("imag(ccosh(-6.75 + i Inf)) = NaN plus invalid exception",
3392                __imag__ result);
3393   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, minus_infty));
3394   check_isnan_exc ("real(ccosh(6.75 - i Inf)) = NaN plus invalid exception",
3395                    __real__ result, INVALID_EXCEPTION);
3396   check_isnan ("imag(ccosh(6.75 - i Inf)) = NaN plus invalid exception",
3397                __imag__ result);
3398   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, minus_infty));
3399   check_isnan_exc ("real(ccosh(-6.75 - i Inf)) = NaN plus invalid exception",
3400                    __real__ result, INVALID_EXCEPTION);
3401   check_isnan ("imag(ccosh(-6.75 - i Inf)) = NaN plus invalid exception",
3402                __imag__ result);
3403
3404   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, nan_value));
3405   check_isnan ("real(ccosh(0 + i NaN)) = NaN", __real__ result);
3406   check ("imag(ccosh(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
3407   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, nan_value));
3408   check_isnan ("real(ccosh(-0 + i NaN)) = NaN", __real__ result);
3409   check ("imag(ccosh(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
3410
3411   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, nan_value));
3412   check_isinfp ("real(ccosh(+Inf + i NaN)) = +Inf", __real__ result);
3413   check_isnan ("imag(ccosh(+Inf + i NaN)) = NaN", __imag__ result);
3414   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, nan_value));
3415   check_isinfp ("real(ccosh(-Inf + i NaN)) = +Inf", __real__ result);
3416   check_isnan ("imag(ccosh(-Inf + i NaN)) = NaN", __imag__ result);
3417
3418   result = FUNC(ccosh) (BUILD_COMPLEX (9.0, nan_value));
3419   check_isnan_maybe_exc ("real(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3420                          __real__ result, INVALID_EXCEPTION);
3421   check_isnan ("imag(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3422                __imag__ result);
3423   result = FUNC(ccosh) (BUILD_COMPLEX (-9.0, nan_value));
3424   check_isnan_maybe_exc ("real(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3425                          __real__ result, INVALID_EXCEPTION);
3426   check_isnan ("imag(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3427                __imag__ result);
3428
3429   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 0.0));
3430   check_isnan ("real(ccosh(NaN + i0)) = NaN", __real__ result);
3431   check ("imag(ccosh(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3432   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_zero));
3433   check_isnan ("real(ccosh(NaN - i0)) = NaN", __real__ result);
3434   check ("imag(ccosh(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3435
3436   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 10.0));
3437   check_isnan_maybe_exc ("real(ccosh(NaN + i10)) = NaN plus maybe invalid exception",
3438                          __real__ result, INVALID_EXCEPTION);
3439   check_isnan ("imag(ccosh(NaN + i10)) = NaN plus maybe invalid exception",
3440                __imag__ result);
3441   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, -10.0));
3442   check_isnan_maybe_exc ("real(ccosh(NaN - i10)) = NaN plus maybe invalid exception",
3443                          __real__ result, INVALID_EXCEPTION);
3444   check_isnan ("imag(ccosh(NaN - i10)) = NaN plus maybe invalid exception",
3445                __imag__ result);
3446
3447   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, plus_infty));
3448   check_isnan_maybe_exc ("real(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception",
3449                          __real__ result, INVALID_EXCEPTION);
3450   check_isnan ("imag(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception",
3451                __imag__ result);
3452   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_infty));
3453   check_isnan_maybe_exc ("real(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception",
3454                          __real__ result, INVALID_EXCEPTION);
3455   check_isnan ("imag(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception",
3456                __imag__ result);
3457
3458   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, nan_value));
3459   check_isnan ("real(ccosh(NaN + i NaN)) = NaN", __real__ result);
3460   check_isnan ("imag(ccosh(NaN + i NaN)) = NaN", __imag__ result);
3461
3462   result = FUNC(ccosh) (BUILD_COMPLEX (0.7, 1.2));
3463   check_eps ("real(ccosh(0.7 + i 1.2)) == 0.45482...", __real__ result,
3464              0.4548202223691477654L, CHOOSE(5e-17L, 6e-17, 9e-8));
3465   check_eps ("imag(ccosh(0.7 + i 1.2)) == 0.70702...", __imag__ result,
3466              0.7070296600921537682L, CHOOSE(7e-17L, 2e-16, 0));
3467
3468   result = FUNC(ccosh) (BUILD_COMPLEX (-2, -3));
3469     check_eps ("real(ccosh(-2 - i 3)) == -3.72454...", __real__ result,
3470              -3.7245455049153225654L, CHOOSE(7e-19L, 0, 3e-7));
3471   check_eps ("imag(ccosh(-2 - i 3)) == -0.51182...", __imag__ result,
3472              0.5118225699873846088L, CHOOSE(3e-19L, 2e-16, 6e-8));
3473 }
3474
3475
3476 static void
3477 cacos_test (void)
3478 {
3479   __complex__ MATHTYPE result;
3480
3481   result = FUNC(cacos) (BUILD_COMPLEX (0, 0));
3482   check ("real(cacos(0 + i0)) = pi/2", __real__ result, M_PI_2l);
3483   check ("imag(cacos(0 + i0)) = -0", __imag__ result, minus_zero);
3484   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, 0));
3485   check ("real(cacos(-0 + i0)) = pi/2", __real__ result, M_PI_2l);
3486   check ("imag(cacos(-0 + i0)) = -0", __imag__ result, minus_zero);
3487   result = FUNC(cacos) (BUILD_COMPLEX (0, minus_zero));
3488   check ("real(cacos(0 - i0)) = pi/2", __real__ result, M_PI_2l);
3489   check ("imag(cacos(0 - i0)) = 0", __imag__ result, 0);
3490   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, minus_zero));
3491   check ("real(cacos(-0 - i0)) = pi/2", __real__ result, M_PI_2l);
3492   check ("imag(cacos(-0 - i0)) = 0", __imag__ result, 0);
3493
3494   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, plus_infty));
3495   check ("real(cacos(-Inf + i Inf)) = 3*pi/4", __real__ result,
3496          M_PIl - M_PI_4l);
3497   check_isinfn ("imag(cacos(-Inf + i Inf)) = -Inf", __imag__ result);
3498   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_infty));
3499   check ("real(cacos(-Inf - i Inf)) = 3*pi/4", __real__ result,
3500  M_PIl - M_PI_4l);
3501   check_isinfp ("imag(cacos(-Inf - i Inf)) = +Inf", __imag__ result);
3502
3503   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, plus_infty));
3504   check ("real(cacos(+Inf + i Inf)) = pi/4", __real__ result, M_PI_4l);
3505   check_isinfn ("imag(cacos(+Inf + i Inf)) = -Inf", __imag__ result);
3506   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_infty));
3507   check ("real(cacos(+Inf - i Inf)) = pi/4", __real__ result, M_PI_4l);
3508   check_isinfp ("imag(cacos(+Inf - i Inf)) = +Inf", __imag__&n