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