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