Update.
[kopensolaris-gnu/glibc.git] / math / libm-test.c
1 /* Copyright (C) 1997, 1998 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3    Contributed by Andreas Jaeger <aj@arthur.rhein-neckar.de>, 1997.
4
5    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Library General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    The GNU C Library is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    Library General Public License for more details.
14
15    You should have received a copy of the GNU Library General Public
16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18    Boston, MA 02111-1307, USA.  */
19
20
21 /*
22    Part of testsuite for libm.
23
24    This file has to be included by a master file that defines:
25
26    Makros:
27    FUNC(function): converts general function name (like cos) to
28    name with correct suffix (e.g. cosl or cosf)
29    MATHCONST(x):   like FUNC but for constants (e.g convert 0.0 to 0.0L)
30    MATHTYPE:       floating point type to test
31    TEST_MSG:       informal message to be displayed
32    CHOOSE(Clongdouble,Cdouble,Cfloat):
33    chooses one of the parameters as epsilon for testing
34    equality
35    PRINTF_EXPR     Floating point conversion specification to print a variable
36    of type MATHTYPE with printf. PRINTF_EXPR just contains
37    the specifier, not the percent and width arguments,
38    e.g. "f".
39    PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.
40  */
41
42 /* This program isn't finished yet.
43    It has tests for:
44    acos, acosh, asin, asinh, atan, atan2, atanh,
45    cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,
46    fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,
47    frexp, gamma, hypot,
48    ilogb, isfinite, isinf, isnan, isnormal,
49    isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,
50    ldexp, lgamma, log, log10, log1p, log2, logb,
51    modf, nearbyint, nextafter,
52    pow, remainder, remquo, rint, lrint, llrint,
53    round, lround, llround,
54    scalb, scalbn, signbit, sin, sincos, sinh, sqrt, tan, tanh, 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, 2e-16, 0));
1076   check_eps ("cbrt (0.7) == .8879040017...", FUNC(cbrt) (0.7),
1077              0.8879040017426007084L, CHOOSE(2e-17L, 6e-16, 0));
1078
1079 }
1080
1081
1082 static void
1083 ceil_test (void)
1084 {
1085   check ("ceil (+0) == +0", FUNC(ceil) (0.0), 0.0);
1086   check ("ceil (-0) == -0", FUNC(ceil) (minus_zero), minus_zero);
1087   check_isinfp ("ceil (+inf) == +inf", FUNC(ceil) (plus_infty));
1088   check_isinfn ("ceil (-inf) == -inf", FUNC(ceil) (minus_infty));
1089
1090   check ("ceil (pi) == 4", FUNC(ceil) (M_PIl), 4.0);
1091   check ("ceil (-pi) == -3", FUNC(ceil) (-M_PIl), -3.0);
1092 }
1093
1094
1095 static void
1096 cos_test (void)
1097 {
1098
1099   check ("cos (+0) == 1", FUNC(cos) (0), 1);
1100   check ("cos (-0) == 1", FUNC(cos) (minus_zero), 1);
1101   check_isnan_exc ("cos (+inf) == NaN plus invalid exception",
1102                    FUNC(cos) (plus_infty),
1103                    INVALID_EXCEPTION);
1104   check_isnan_exc ("cos (-inf) == NaN plus invalid exception",
1105                    FUNC(cos) (minus_infty),
1106                    INVALID_EXCEPTION);
1107
1108   check_eps ("cos (pi/3) == 0.5", FUNC(cos) (M_PI_6l * 2.0),
1109              0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L));
1110   check_eps ("cos (2*pi/3) == -0.5", FUNC(cos) (M_PI_6l * 4.0),
1111              -0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L));
1112   check_eps ("cos (pi/2) == 0", FUNC(cos) (M_PI_2l),
1113              0, CHOOSE (1e-19L, 1e-16L, 1e-7L));
1114
1115   check_eps ("cos (0.7) == 0.7648421872...", FUNC(cos) (0.7),
1116              0.7648421872844884262L, CHOOSE(3e-17, 2e-16, 6e-8));
1117 }
1118
1119 static void
1120 cosh_test (void)
1121 {
1122   check ("cosh (+0) == 1", FUNC(cosh) (0), 1);
1123   check ("cosh (-0) == 1", FUNC(cosh) (minus_zero), 1);
1124
1125 #ifndef TEST_INLINE
1126   check_isinfp ("cosh (+inf) == +inf", FUNC(cosh) (plus_infty));
1127   check_isinfp ("cosh (-inf) == +inf", FUNC(cosh) (minus_infty));
1128 #endif
1129
1130   check_eps ("cosh (0.7) ==  1.2551690056...", FUNC(cosh) (0.7),
1131              1.255169005630943018L, CHOOSE(4e-17L, 0, 0));
1132 }
1133
1134
1135 static void
1136 erf_test (void)
1137 {
1138   errno = 0;
1139   FUNC(erf) (0);
1140   if (errno == ENOSYS)
1141     /* Function not implemented.  */
1142     return;
1143
1144   check ("erf (+0) == +0", FUNC(erf) (0), 0);
1145   check ("erf (-0) == -0", FUNC(erf) (minus_zero), minus_zero);
1146   check ("erf (+inf) == +1", FUNC(erf) (plus_infty), 1);
1147   check ("erf (-inf) == -1", FUNC(erf) (minus_infty), -1);
1148
1149   check_eps ("erf (0.7) == 0.6778011938...", FUNC(erf) (0.7),
1150              0.67780119383741847297L, CHOOSE(0, 2e-16, 0));
1151 }
1152
1153
1154 static void
1155 erfc_test (void)
1156 {
1157   errno = 0;
1158   FUNC(erfc) (0);
1159   if (errno == ENOSYS)
1160     /* Function not implemented.  */
1161     return;
1162
1163   check ("erfc (+inf) == 0", FUNC(erfc) (plus_infty), 0.0);
1164   check ("erfc (-inf) == 2", FUNC(erfc) (minus_infty), 2.0);
1165   check ("erfc (+0) == 1", FUNC(erfc) (0.0), 1.0);
1166   check ("erfc (-0) == 1", FUNC(erfc) (minus_zero), 1.0);
1167
1168   check_eps ("erfc (0.7) == 0.3221988061...", FUNC(erfc) (0.7),
1169              0.32219880616258152702L, CHOOSE(0, 6e-17, 0));
1170 }
1171
1172
1173 static void
1174 exp_test (void)
1175 {
1176   check ("exp (+0) == 1", FUNC(exp) (0), 1);
1177   check ("exp (-0) == 1", FUNC(exp) (minus_zero), 1);
1178
1179 #ifndef TEST_INLINE
1180   check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty));
1181   check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0);
1182 #endif
1183   check_eps ("exp (1) == e", FUNC(exp) (1), M_El, CHOOSE (4e-18L, 0, 0));
1184
1185   check_eps ("exp (2) == e^2", FUNC(exp) (2), M_E2l,
1186              CHOOSE (1e-18, 0, 0));
1187   check_eps ("exp (3) == e^3", FUNC(exp) (3), M_E3l,
1188              CHOOSE (1.5e-17, 0, 0));
1189   check_eps ("exp (0.7) == 2.0137527074...", FUNC(exp) (0.7),
1190              2.0137527074704765216L, CHOOSE(9e-17L, 0, 0));
1191 }
1192
1193
1194 static void
1195 exp10_test (void)
1196 {
1197   errno = 0;
1198   FUNC(exp10) (0);
1199   if (errno == ENOSYS)
1200     /* Function not implemented.  */
1201     return;
1202
1203   check ("exp10 (+0) == 1", FUNC(exp10) (0), 1);
1204   check ("exp10 (-0) == 1", FUNC(exp10) (minus_zero), 1);
1205
1206   check_isinfp ("exp10 (+inf) == +inf", FUNC(exp10) (plus_infty));
1207   check ("exp10 (-inf) == 0", FUNC(exp10) (minus_infty), 0);
1208   check_eps ("exp10 (3) == 1000", FUNC(exp10) (3), 1000,
1209              CHOOSE(5e-16, 0, 0));
1210   check_eps ("exp10 (-1) == 0.1", FUNC(exp10) (-1), 0.1,
1211              CHOOSE(6e-18, 0, 0));
1212   check_isinfp ("exp10 (1e6) == +inf", FUNC(exp10) (1e6));
1213   check ("exp10 (-1e6) == 0", FUNC(exp10) (-1e6), 0);
1214   check_eps ("exp10 (0.7) == 5.0118723...", FUNC(exp10) (0.7),
1215              5.0118723362727228500L, CHOOSE(6e-16, 9e-16, 0));
1216 }
1217
1218
1219 static void
1220 exp2_test (void)
1221 {
1222   errno = 0;
1223   FUNC(exp2) (0);
1224   if (errno == ENOSYS)
1225     /* Function not implemented.  */
1226     return;
1227
1228   check ("exp2 (+0) == 1", FUNC(exp2) (0), 1);
1229   check ("exp2 (-0) == 1", FUNC(exp2) (minus_zero), 1);
1230
1231   check_isinfp ("exp2 (+inf) == +inf", FUNC(exp2) (plus_infty));
1232   check ("exp2 (-inf) == 0", FUNC(exp2) (minus_infty), 0);
1233   check ("exp2 (10) == 1024", FUNC(exp2) (10), 1024);
1234   check ("exp2 (-1) == 0.5", FUNC(exp2) (-1), 0.5);
1235   check_isinfp ("exp2 (1e6) == +inf", FUNC(exp2) (1e6));
1236   check ("exp2 (-1e6) == 0", FUNC(exp2) (-1e6), 0);
1237   check_eps ("exp2 (0.7) == 1.6245047927...", FUNC(exp2) (0.7),
1238              1.6245047927124710452L, CHOOSE(6e-17L, 0, 6e-8));
1239 }
1240
1241
1242 static void
1243 expm1_test (void)
1244 {
1245   check ("expm1 (+0) == 0", FUNC(expm1) (0), 0);
1246 #ifndef TEST_INLINE
1247   check ("expm1 (-0) == -0", FUNC(expm1) (minus_zero), minus_zero);
1248
1249   check_isinfp ("expm1 (+inf) == +inf", FUNC(expm1) (plus_infty));
1250   check ("expm1 (-inf) == -1", FUNC(expm1) (minus_infty), -1);
1251 #endif
1252
1253   check_eps ("expm1 (1) == e-1", FUNC(expm1) (1), M_El - 1.0,
1254              CHOOSE (4e-18L, 0, 2e-7));
1255
1256   check_eps ("expm1 (0.7) == 1.01375...", FUNC(expm1) (0.7),
1257              1.0137527074704765216L, CHOOSE(9e-17L, 0, 0));
1258 }
1259
1260
1261
1262
1263 static void
1264 check_frexp (const char *test_name, MATHTYPE computed, MATHTYPE expected,
1265              int comp_int, int exp_int)
1266 {
1267   MATHTYPE diff;
1268   int result;
1269
1270   result = (check_equal (computed, expected, 0, &diff)
1271             && (comp_int == exp_int));
1272
1273   if (result)
1274     {
1275       if (verbose > 2)
1276         printf ("Pass: %s\n", test_name);
1277     }
1278   else
1279     {
1280       if (verbose)
1281         printf ("Fail: %s\n", test_name);
1282       if (verbose > 1)
1283         {
1284           printf ("Result:\n");
1285           printf (" is:         %.20" PRINTF_EXPR " *2^%d  %.20"
1286                   PRINTF_XEXPR "*2^%d\n",
1287                   computed, comp_int, computed, comp_int);
1288           printf (" should be:  %.20" PRINTF_EXPR " *2^%d  %.20"
1289                   PRINTF_XEXPR "*2^%d\n",
1290                   expected, exp_int, expected, exp_int);
1291           printf (" difference: %.20" PRINTF_EXPR "  %.20" PRINTF_XEXPR "\n",
1292                   diff, diff);
1293         }
1294       noErrors++;
1295     }
1296   fpstack_test (test_name);
1297   output_result (test_name, result,
1298                  computed, expected, diff, PRINT, PRINT);
1299 }
1300
1301
1302 static void
1303 frexp_test (void)
1304 {
1305   int x_int;
1306   MATHTYPE result;
1307
1308   result = FUNC(frexp) (plus_infty, &x_int);
1309   check_isinfp ("frexp (+inf, expr) == +inf", result);
1310
1311   result = FUNC(frexp) (minus_infty, &x_int);
1312   check_isinfn ("frexp (-inf, expr) == -inf", result);
1313
1314   result = FUNC(frexp) (nan_value, &x_int);
1315   check_isnan ("frexp (Nan, expr) == NaN", result);
1316
1317   result = FUNC(frexp) (0, &x_int);
1318   check_frexp ("frexp: +0 == 0 * 2^0", result, 0, x_int, 0);
1319
1320   result = FUNC(frexp) (minus_zero, &x_int);
1321   check_frexp ("frexp: -0 == -0 * 2^0", result, minus_zero, x_int, 0);
1322
1323   result = FUNC(frexp) (12.8L, &x_int);
1324   check_frexp ("frexp: 12.8 == 0.8 * 2^4", result, 0.8L, x_int, 4);
1325
1326   result = FUNC(frexp) (-27.34L, &x_int);
1327   check_frexp ("frexp: -27.34 == -0.854375 * 2^5", result, -0.854375L, x_int, 5);
1328
1329 }
1330
1331
1332 #if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1)
1333 /* All floating-point numbers can be put in one of these categories.  */
1334 enum
1335 {
1336   FP_NAN,
1337 #define FP_NAN FP_NAN
1338   FP_INFINITE,
1339 #define FP_INFINITE FP_INFINITE
1340   FP_ZERO,
1341 #define FP_ZERO FP_ZERO
1342   FP_SUBNORMAL,
1343 #define FP_SUBNORMAL FP_SUBNORMAL
1344   FP_NORMAL
1345 #define FP_NORMAL FP_NORMAL
1346 };
1347 #endif
1348
1349
1350 static void
1351 fpclassify_test (void)
1352 {
1353   MATHTYPE x;
1354
1355   /* fpclassify is a macro, don't give it constants as parameter */
1356   check_bool ("fpclassify (NaN) == FP_NAN", fpclassify (nan_value) == FP_NAN);
1357   check_bool ("fpclassify (+inf) == FP_INFINITE",
1358               fpclassify (plus_infty) == FP_INFINITE);
1359   check_bool ("fpclassify (-inf) == FP_INFINITE",
1360               fpclassify (minus_infty) == FP_INFINITE);
1361   check_bool ("fpclassify (+0) == FP_ZERO",
1362               fpclassify (plus_zero) == FP_ZERO);
1363   check_bool ("fpclassify (-0) == FP_ZERO",
1364               fpclassify (minus_zero) == FP_ZERO);
1365
1366   x = 1000.0;
1367   check_bool ("fpclassify (1000) == FP_NORMAL",
1368               fpclassify (x) == FP_NORMAL);
1369 }
1370
1371
1372 static void
1373 isfinite_test (void)
1374 {
1375   check_bool ("isfinite (0) != 0", isfinite (0));
1376   check_bool ("isfinite (-0) != 0", isfinite (minus_zero));
1377   check_bool ("isfinite (10) != 0", isfinite (10));
1378   check_bool ("isfinite (+inf) == 0", isfinite (plus_infty) == 0);
1379   check_bool ("isfinite (-inf) == 0", isfinite (minus_infty) == 0);
1380   check_bool ("isfinite (NaN) == 0", isfinite (nan_value) == 0);
1381 }
1382
1383
1384 static void
1385 isnormal_test (void)
1386 {
1387   check_bool ("isnormal (0) == 0", isnormal (0) == 0);
1388   check_bool ("isnormal (-0) == 0", isnormal (minus_zero) == 0);
1389   check_bool ("isnormal (10) != 0", isnormal (10));
1390   check_bool ("isnormal (+inf) == 0", isnormal (plus_infty) == 0);
1391   check_bool ("isnormal (-inf) == 0", isnormal (minus_infty) == 0);
1392   check_bool ("isnormal (NaN) == 0", isnormal (nan_value) == 0);
1393
1394 }
1395
1396
1397 static void
1398 signbit_test (void)
1399 {
1400   MATHTYPE x;
1401
1402   check_bool ("signbit (+0) == 0", signbit (0) == 0);
1403   check_bool ("signbit (-0) != 0", signbit (minus_zero));
1404   check_bool ("signbit (+inf) == 0", signbit (plus_infty) == 0);
1405   check_bool ("signbit (-inf) != 0", signbit (minus_infty));
1406
1407   x = random_less (0);
1408   check_bool ("signbit (x) != 0 for x < 0", signbit (x));
1409
1410   x = random_greater (0);
1411   check_bool ("signbit (x) == 0 for x > 0", signbit (x) == 0);
1412
1413 }
1414
1415
1416 /*
1417    gamma has different semantics depending on _LIB_VERSION:
1418    if _LIB_VERSION is _SVID, gamma is just an alias for lgamma,
1419    otherwise gamma is the real gamma function as definied in ISO C 9X.
1420 */
1421 static void
1422 gamma_test (void)
1423 {
1424   int save_lib_version = _LIB_VERSION;
1425   errno = 0;
1426   FUNC(gamma) (1);
1427   if (errno == ENOSYS)
1428     /* Function not implemented.  */
1429     return;
1430   feclearexcept (FE_ALL_EXCEPT);
1431
1432
1433   _LIB_VERSION = _SVID_;
1434
1435   check_isinfp ("gamma (+inf) == +inf", FUNC(gamma) (plus_infty));
1436   check_isinfp_exc ("gamma (0) == +inf plus divide by zero exception",
1437                     FUNC(gamma) (0), DIVIDE_BY_ZERO_EXCEPTION);
1438
1439   check_isinfp_exc ("gamma (x) == +inf plus divide by zero exception for integer x <= 0",
1440                     FUNC(gamma) (-3), DIVIDE_BY_ZERO_EXCEPTION);
1441   check_isnan_exc ("gamma (-inf) == NaN plus invalid exception",
1442                    FUNC(gamma) (minus_infty), INVALID_EXCEPTION);
1443
1444   signgam = 0;
1445   check ("gamma (1) == 0", FUNC(gamma) (1), 0);
1446   check_int ("gamma (0) sets signgam to 1", signgam, 1);
1447
1448   signgam = 0;
1449   check ("gamma (3) == M_LN2", FUNC(gamma) (3), M_LN2l);
1450   check_int ("gamma (3) sets signgam to 1", signgam, 1);
1451
1452   signgam = 0;
1453   check_eps ("gamma (0.5) == log(sqrt(pi))", FUNC(gamma) (0.5),
1454              FUNC(log) (FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 1e-7));
1455   check_int ("gamma (0.5) sets signgam to 1", signgam, 1);
1456
1457   signgam = 0;
1458   check_eps ("gamma (-0.5) == log(2*sqrt(pi))", FUNC(gamma) (-0.5),
1459              FUNC(log) (2*FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 0));
1460
1461   check_int ("gamma (-0.5) sets signgam to -1", signgam, -1);
1462
1463
1464   _LIB_VERSION = _IEEE_;
1465
1466   check_isinfp ("gamma (+inf) == +inf", FUNC(gamma) (plus_infty));
1467   check_isnan_exc ("gamma (0) == NaN plus invalid exception",
1468                     FUNC(gamma) (0), INVALID_EXCEPTION);
1469
1470   check_isnan_exc_ext ("gamma (x) == NaN plus invalid exception for integer x <= 0",
1471                         FUNC(gamma) (-2), INVALID_EXCEPTION, -2);
1472   check_isnan_exc ("gamma (-inf) == NaN plus invalid exception",
1473                    FUNC(gamma) (minus_infty), INVALID_EXCEPTION);
1474
1475 #ifdef TODO
1476   check_eps ("gamma (0.5) == sqrt(pi)", FUNC(gamma) (0.5), FUNC(sqrt) (M_PIl),
1477              CHOOSE (0, 5e-16, 2e-7));
1478 #endif
1479   check_eps ("gamma (-0.5) == -2*sqrt(pi)", FUNC(gamma) (-0.5),
1480              -2*FUNC(sqrt) (M_PIl), CHOOSE (0, 5e-16, 3e-7));
1481
1482   check ("gamma (1) == 1", FUNC(gamma) (1), 1);
1483   check ("gamma (4) == 6", FUNC(gamma) (4), 6);
1484
1485   check_eps ("gamma (0.7) == 1.29805...", FUNC(gamma) (0.7),
1486              1.29805533264755778568L, CHOOSE(0, 3e-16, 2e-7));
1487   check ("gamma (1.2) == 0.91816...", FUNC(gamma) (1.2), 0.91816874239976061064L);
1488
1489   _LIB_VERSION = save_lib_version;
1490 }
1491
1492
1493 static void
1494 lgamma_test (void)
1495 {
1496   errno = 0;
1497   FUNC(lgamma) (0);
1498   if (errno == ENOSYS)
1499     /* Function not implemented.  */
1500     return;
1501   feclearexcept (FE_ALL_EXCEPT);
1502
1503   check_isinfp ("lgamma (+inf) == +inf", FUNC(lgamma) (plus_infty));
1504   check_isinfp_exc ("lgamma (0) == +inf plus divide by zero exception",
1505                     FUNC(lgamma) (0), DIVIDE_BY_ZERO_EXCEPTION);
1506
1507   check_isinfp_exc ("lgamma (x) == +inf plus divide by zero exception for integer x <= 0",
1508                     FUNC(lgamma) (-3), DIVIDE_BY_ZERO_EXCEPTION);
1509   check_isnan_exc ("lgamma (-inf) == NaN plus invalid exception",
1510                    FUNC(lgamma) (minus_infty), INVALID_EXCEPTION);
1511
1512   signgam = 0;
1513   check ("lgamma (1) == 0", FUNC(lgamma) (1), 0);
1514   check_int ("lgamma (0) sets signgam to 1", signgam, 1);
1515
1516   signgam = 0;
1517   check ("lgamma (3) == M_LN2", FUNC(lgamma) (3), M_LN2l);
1518   check_int ("lgamma (3) sets signgam to 1", signgam, 1);
1519
1520   signgam = 0;
1521   check_eps ("lgamma (0.5) == log(sqrt(pi))", FUNC(lgamma) (0.5),
1522              FUNC(log) (FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 1e-7));
1523   check_int ("lgamma (0.5) sets signgam to 1", signgam, 1);
1524
1525   signgam = 0;
1526   check_eps ("lgamma (-0.5) == log(2*sqrt(pi))", FUNC(lgamma) (-0.5),
1527              FUNC(log) (2*FUNC(sqrt) (M_PIl)), CHOOSE (0, 1e-15, 0));
1528
1529   check_int ("lgamma (-0.5) sets signgam to -1", signgam, -1);
1530
1531   signgam = 0;
1532   check_eps ("lgamma (0.7) == 0.26086...", FUNC(lgamma) (0.7),
1533              0.26086724653166651439L, CHOOSE(0, 6e-17, 3e-8));
1534   check_int ("lgamma (0.7) sets signgam to 1", signgam, 1);
1535
1536   signgam = 0;
1537   check_eps ("lgamma (1.2) == -0.08537...", FUNC(lgamma) (1.2),
1538              -0.853740900033158497197e-1L, CHOOSE(0, 2e-17, 2e-8));
1539   check_int ("lgamma (1.2) sets signgam to 1", signgam, 1);
1540
1541 }
1542
1543
1544 static void
1545 ilogb_test (void)
1546 {
1547   int i;
1548
1549   check_int ("ilogb (1) == 0", FUNC(ilogb) (1), 0);
1550   check_int ("ilogb (e) == 1", FUNC(ilogb) (M_El), 1);
1551   check_int ("ilogb (1024) == 10", FUNC(ilogb) (1024), 10);
1552   check_int ("ilogb (-2000) == 10", FUNC(ilogb) (-2000), 10);
1553
1554   /* XXX We have a problem here: the standard does not tell us whether
1555      exceptions are allowed/required.  ignore them for now.  */
1556   i = FUNC (ilogb) (0.0);
1557   feclearexcept (FE_ALL_EXCEPT);
1558   check_int ("ilogb (0) == FP_ILOGB0", i, FP_ILOGB0);
1559   i = FUNC(ilogb) (nan_value);
1560   feclearexcept (FE_ALL_EXCEPT);
1561   check_int ("ilogb (NaN) == FP_ILOGBNAN", i, FP_ILOGBNAN);
1562
1563 }
1564
1565
1566 static void
1567 ldexp_test (void)
1568 {
1569   MATHTYPE x;
1570
1571   check ("ldexp (0, 0) == 0", FUNC(ldexp) (0, 0), 0);
1572
1573   check_isinfp ("ldexp (+inf, 1) == +inf", FUNC(ldexp) (plus_infty, 1));
1574   check_isinfn ("ldexp (-inf, 1) == -inf", FUNC(ldexp) (minus_infty, 1));
1575   check_isnan ("ldexp (NaN, 1) == NaN", FUNC(ldexp) (nan_value, 1));
1576
1577   check ("ldexp (0.8, 4) == 12.8", FUNC(ldexp) (0.8L, 4), 12.8L);
1578   check ("ldexp (-0.854375, 5) == -27.34", FUNC(ldexp) (-0.854375L, 5), -27.34L);
1579
1580   x = random_greater (0.0);
1581   check_ext ("ldexp (x, 0) == x", FUNC(ldexp) (x, 0L), x, x);
1582
1583 }
1584
1585
1586 static void
1587 log_test (void)
1588 {
1589   check_isinfn_exc ("log (+0) == -inf plus divide-by-zero exception",
1590                     FUNC(log) (0), DIVIDE_BY_ZERO_EXCEPTION);
1591   check_isinfn_exc ("log (-0) == -inf plus divide-by-zero exception",
1592                     FUNC(log) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1593
1594   check ("log (1) == 0", FUNC(log) (1), 0);
1595
1596   check_isnan_exc ("log (x) == NaN plus invalid exception if x < 0",
1597                    FUNC(log) (-1), INVALID_EXCEPTION);
1598   check_isinfp ("log (+inf) == +inf", FUNC(log) (plus_infty));
1599
1600   check_eps ("log (e) == 1", FUNC(log) (M_El), 1, CHOOSE (1e-18L, 0, 9e-8L));
1601   check_eps ("log (1/e) == -1", FUNC(log) (1.0 / M_El), -1,
1602              CHOOSE (2e-18L, 0, 0));
1603   check ("log (2) == M_LN2", FUNC(log) (2), M_LN2l);
1604   check_eps ("log (10) == M_LN10", FUNC(log) (10), M_LN10l,
1605              CHOOSE (1e-18L, 0, 0));
1606   check_eps ("log (0.7) == -0.3566749439...", FUNC(log) (0.7),
1607              -0.35667494393873237891L, CHOOSE(7e-17L, 6e-17, 3e-8));
1608 }
1609
1610
1611 static void
1612 log10_test (void)
1613 {
1614   check_isinfn_exc ("log10 (+0) == -inf plus divide-by-zero exception",
1615                     FUNC(log10) (0), DIVIDE_BY_ZERO_EXCEPTION);
1616   check_isinfn_exc ("log10 (-0) == -inf plus divide-by-zero exception",
1617                     FUNC(log10) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1618
1619   check ("log10 (1) == +0", FUNC(log10) (1), 0);
1620
1621   check_isnan_exc ("log10 (x) == NaN plus invalid exception if x < 0",
1622                    FUNC(log10) (-1), INVALID_EXCEPTION);
1623
1624   check_isinfp ("log10 (+inf) == +inf", FUNC(log10) (plus_infty));
1625
1626   check_eps ("log10 (0.1) == -1", FUNC(log10) (0.1L), -1,
1627              CHOOSE (1e-18L, 0, 0));
1628   check_eps ("log10 (10) == 1", FUNC(log10) (10.0), 1,
1629              CHOOSE (1e-18L, 0, 0));
1630   check_eps ("log10 (100) == 2", FUNC(log10) (100.0), 2,
1631              CHOOSE (1e-18L, 0, 0));
1632   check ("log10 (10000) == 4", FUNC(log10) (10000.0), 4);
1633   check_eps ("log10 (e) == M_LOG10E", FUNC(log10) (M_El), M_LOG10El,
1634              CHOOSE (1e-18, 0, 9e-8));
1635   check_eps ("log10 (0.7) == -0.1549019599...", FUNC(log10) (0.7),
1636              -0.15490195998574316929L, CHOOSE(3e-17L, 3e-17, 2e-8));
1637 }
1638
1639
1640 static void
1641 log1p_test (void)
1642 {
1643   check ("log1p (+0) == +0", FUNC(log1p) (0), 0);
1644   check ("log1p (-0) == -0", FUNC(log1p) (minus_zero), minus_zero);
1645
1646   check_isinfn_exc ("log1p (-1) == -inf plus divide-by-zero exception",
1647                     FUNC(log1p) (-1), DIVIDE_BY_ZERO_EXCEPTION);
1648   check_isnan_exc ("log1p (x) == NaN plus invalid exception if x < -1",
1649                    FUNC(log1p) (-2), INVALID_EXCEPTION);
1650
1651   check_isinfp ("log1p (+inf) == +inf", FUNC(log1p) (plus_infty));
1652
1653   check_eps ("log1p (e-1) == 1", FUNC(log1p) (M_El - 1.0), 1,
1654              CHOOSE (1e-18L, 0, 6e-8));
1655
1656   check_eps ("log1p (-0.3) == -0.35667...", FUNC(log1p) (-0.3),
1657              -0.35667494393873237891L, CHOOSE(2e-17L, 6e-17, 3e-8));
1658 }
1659
1660
1661 static void
1662 log2_test (void)
1663 {
1664   check_isinfn_exc ("log2 (+0) == -inf plus divide-by-zero exception",
1665                     FUNC(log2) (0), DIVIDE_BY_ZERO_EXCEPTION);
1666   check_isinfn_exc ("log2 (-0) == -inf plus divide-by-zero exception",
1667                     FUNC(log2) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1668
1669   check ("log2 (1) == +0", FUNC(log2) (1), 0);
1670
1671   check_isnan_exc ("log2 (x) == NaN plus invalid exception if x < 0",
1672                    FUNC(log2) (-1), INVALID_EXCEPTION);
1673
1674   check_isinfp ("log2 (+inf) == +inf", FUNC(log2) (plus_infty));
1675
1676   check_eps ("log2 (e) == M_LOG2E", FUNC(log2) (M_El), M_LOG2El,
1677              CHOOSE (1e-18L, 0, 0));
1678   check ("log2 (2) == 1", FUNC(log2) (2.0), 1);
1679   check_eps ("log2 (16) == 4", FUNC(log2) (16.0), 4, CHOOSE (1e-18L, 0, 0));
1680   check ("log2 (256) == 8", FUNC(log2) (256.0), 8);
1681   check_eps ("log2 (0.7) == -0.5145731728...", FUNC(log2) (0.7),
1682              -0.51457317282975824043L, CHOOSE(1e-16L, 2e-16, 6e-8));
1683
1684 }
1685
1686
1687 static void
1688 logb_test (void)
1689 {
1690   check_isinfp ("logb (+inf) == +inf", FUNC(logb) (plus_infty));
1691   check_isinfp ("logb (-inf) == +inf", FUNC(logb) (minus_infty));
1692
1693   check_isinfn_exc ("logb (+0) == -inf plus divide-by-zero exception",
1694                     FUNC(logb) (0), DIVIDE_BY_ZERO_EXCEPTION);
1695
1696   check_isinfn_exc ("logb (-0) == -inf plus divide-by-zero exception",
1697                     FUNC(logb) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
1698
1699   check ("logb (1) == 0", FUNC(logb) (1), 0);
1700   check ("logb (e) == 1", FUNC(logb) (M_El), 1);
1701   check ("logb (1024) == 10", FUNC(logb) (1024), 10);
1702   check ("logb (-2000) == 10", FUNC(logb) (-2000), 10);
1703
1704 }
1705
1706
1707 static void
1708 modf_test (void)
1709 {
1710   MATHTYPE result, intpart;
1711
1712   result = FUNC(modf) (plus_infty, &intpart);
1713   check ("modf (+inf, &x) returns +0", result, 0);
1714   check_isinfp ("modf (+inf, &x) set x to +inf", intpart);
1715
1716   result = FUNC(modf) (minus_infty, &intpart);
1717   check ("modf (-inf, &x) returns -0", result, minus_zero);
1718   check_isinfn ("modf (-inf, &x) sets x to -inf", intpart);
1719
1720   result = FUNC(modf) (nan_value, &intpart);
1721   check_isnan ("modf (NaN, &x) returns NaN", result);
1722   check_isnan ("modf (NaN, &x) sets x to NaN", intpart);
1723
1724   result = FUNC(modf) (0, &intpart);
1725   check ("modf (0, &x) returns 0", result, 0);
1726   check ("modf (0, &x) sets x to 0", intpart, 0);
1727
1728   result = FUNC(modf) (minus_zero, &intpart);
1729   check ("modf (-0, &x) returns -0", result, minus_zero);
1730   check ("modf (-0, &x) sets x to -0", intpart, minus_zero);
1731
1732   result = FUNC(modf) (1.5, &intpart);
1733   check ("modf (1.5, &x) returns 0.5", result, 0.5);
1734   check ("modf (1.5, &x) sets x to 1", intpart, 1);
1735
1736   result = FUNC(modf) (2.5, &intpart);
1737   check ("modf (2.5, &x) returns 0.5", result, 0.5);
1738   check ("modf (2.5, &x) sets x to 2", intpart, 2);
1739
1740   result = FUNC(modf) (-2.5, &intpart);
1741   check ("modf (-2.5, &x) returns -0.5", result, -0.5);
1742   check ("modf (-2.5, &x) sets x to -2", intpart, -2);
1743
1744   result = FUNC(modf) (20, &intpart);
1745   check ("modf (20, &x) returns 0", result, 0);
1746   check ("modf (20, &x) sets x to 20", intpart, 20);
1747
1748   result = FUNC(modf) (21, &intpart);
1749   check ("modf (21, &x) returns 0", result, 0);
1750   check ("modf (21, &x) sets x to 21", intpart, 21);
1751
1752   result = FUNC(modf) (89.6, &intpart);
1753   check_eps ("modf (89.6, &x) returns 0.6", result, 0.6,
1754              CHOOSE(6e-15L, 6e-15, 2e-6));
1755   check ("modf (89.6, &x) sets x to 89", intpart, 89);
1756 }
1757
1758
1759 static void
1760 scalb_test (void)
1761 {
1762   MATHTYPE x;
1763
1764   check_isnan ("scalb (2, 0.5) == NaN", FUNC(scalb) (2, 0.5));
1765   check_isnan ("scalb (3, -2.5) == NaN", FUNC(scalb) (3, -2.5));
1766
1767   check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value));
1768   check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value));
1769
1770   x = random_greater (0.0);
1771   check ("scalb (x, 0) == 0", FUNC(scalb) (x, 0), x);
1772   x = random_greater (0.0);
1773   check ("scalb (-x, 0) == 0", FUNC(scalb) (-x, 0), -x);
1774
1775   check_isnan_exc ("scalb (+0, +inf) == NaN plus invalid exception",
1776                    FUNC(scalb) (0, plus_infty), INVALID_EXCEPTION);
1777   check_isnan_exc ("scalb (-0, +inf) == NaN plus invalid exception",
1778                    FUNC(scalb) (minus_zero, plus_infty), INVALID_EXCEPTION);
1779
1780   check ("scalb (+0, 2) == +0", FUNC(scalb) (0, 2), 0);
1781   check ("scalb (-0, 4) == -0", FUNC(scalb) (minus_zero, -4), minus_zero);
1782   check ("scalb (+0, 0) == +0", FUNC(scalb) (0, 0), 0);
1783   check ("scalb (-0, 0) == -0", FUNC(scalb) (minus_zero, 0), minus_zero);
1784   check ("scalb (+0, -1) == +0", FUNC(scalb) (0, -1), 0);
1785   check ("scalb (-0, -10) == -0", FUNC(scalb) (minus_zero, -10), minus_zero);
1786   check ("scalb (+0, -inf) == +0", FUNC(scalb) (0, minus_infty), 0);
1787   check ("scalb (-0, -inf) == -0", FUNC(scalb) (minus_zero, minus_infty),
1788          minus_zero);
1789
1790   check_isinfp ("scalb (+inf, -1) == +inf", FUNC(scalb) (plus_infty, -1));
1791   check_isinfn ("scalb (-inf, -10) == -inf", FUNC(scalb) (minus_infty, -10));
1792   check_isinfp ("scalb (+inf, 0) == +inf", FUNC(scalb) (plus_infty, 0));
1793   check_isinfn ("scalb (-inf, 0) == -inf", FUNC(scalb) (minus_infty, 0));
1794   check_isinfp ("scalb (+inf, 2) == +inf", FUNC(scalb) (plus_infty, 2));
1795   check_isinfn ("scalb (-inf, 100) == -inf", FUNC(scalb) (minus_infty, 100));
1796
1797   x = random_greater (0.0);
1798   check ("scalb (x, -inf) == 0", FUNC(scalb) (x, minus_infty), 0.0);
1799   check ("scalb (-x, -inf) == -0", FUNC(scalb) (-x, minus_infty), minus_zero);
1800
1801   x = random_greater (0.0);
1802   check_isinfp ("scalb (x, +inf) == +inf", FUNC(scalb) (x, plus_infty));
1803   x = random_greater (0.0);
1804   check_isinfn ("scalb (-x, +inf) == -inf", FUNC(scalb) (-x, plus_infty));
1805   check_isinfp ("scalb (+inf, +inf) == +inf",
1806                 FUNC(scalb) (plus_infty, plus_infty));
1807   check_isinfn ("scalb (-inf, +inf) == -inf",
1808                 FUNC(scalb) (minus_infty, plus_infty));
1809
1810   check_isnan ("scalb (+inf, -inf) == NaN",
1811                FUNC(scalb) (plus_infty, minus_infty));
1812   check_isnan ("scalb (-inf, -inf) == NaN",
1813                FUNC(scalb) (minus_infty, minus_infty));
1814
1815   check_isnan ("scalb (NaN, 1) == NaN", FUNC(scalb) (nan_value, 1));
1816   check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value));
1817   check_isnan ("scalb (NaN, 0) == NaN", FUNC(scalb) (nan_value, 0));
1818   check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value));
1819   check_isnan ("scalb (NaN, +inf) == NaN",
1820                FUNC(scalb) (nan_value, plus_infty));
1821   check_isnan ("scalb (+inf, NaN) == NaN",
1822                FUNC(scalb) (plus_infty, nan_value));
1823   check_isnan ("scalb (NaN, NaN) == NaN", FUNC(scalb) (nan_value, nan_value));
1824
1825   check ("scalb (0.8, 4) == 12.8", FUNC(scalb) (0.8L, 4), 12.8L);
1826   check ("scalb (-0.854375, 5) == -27.34", FUNC(scalb) (-0.854375L, 5), -27.34L);
1827 }
1828
1829
1830 static void
1831 scalbn_test (void)
1832 {
1833   MATHTYPE x;
1834
1835   check ("scalbn (0, 0) == 0", FUNC(scalbn) (0, 0), 0);
1836
1837   check_isinfp ("scalbn (+inf, 1) == +inf", FUNC(scalbn) (plus_infty, 1));
1838   check_isinfn ("scalbn (-inf, 1) == -inf", FUNC(scalbn) (minus_infty, 1));
1839   check_isnan ("scalbn (NaN, 1) == NaN", FUNC(scalbn) (nan_value, 1));
1840
1841   check ("scalbn (0.8, 4) == 12.8", FUNC(scalbn) (0.8L, 4), 12.8L);
1842   check ("scalbn (-0.854375, 5) == -27.34", FUNC(scalbn) (-0.854375L, 5), -27.34L);
1843
1844   x = random_greater (0.0);
1845   check_ext ("scalbn (x, 0) == x", FUNC(scalbn) (x, 0L), x, x);
1846 }
1847
1848
1849 static void
1850 sin_test (void)
1851 {
1852   check ("sin (+0) == +0", FUNC(sin) (0), 0);
1853   check ("sin (-0) == -0", FUNC(sin) (minus_zero), minus_zero);
1854   check_isnan_exc ("sin (+inf) == NaN plus invalid exception",
1855                    FUNC(sin) (plus_infty),
1856                    INVALID_EXCEPTION);
1857   check_isnan_exc ("sin (-inf) == NaN plus invalid exception",
1858                    FUNC(sin) (minus_infty),
1859                    INVALID_EXCEPTION);
1860
1861   check_eps ("sin (pi/6) == 0.5", FUNC(sin) (M_PI_6l),
1862              0.5, CHOOSE (4e-18L, 0, 0));
1863   check_eps ("sin (-pi/6) == -0.5", FUNC(sin) (-M_PI_6l),
1864              -0.5, CHOOSE (4e-18L, 0, 0));
1865   check ("sin (pi/2) == 1", FUNC(sin) (M_PI_2l), 1);
1866   check ("sin (-pi/2) == -1", FUNC(sin) (-M_PI_2l), -1);
1867   check_eps ("sin (0.7) == 0.6442176872...", FUNC(sin) (0.7),
1868              0.64421768723769105367L, CHOOSE(4e-17L, 0, 0));
1869 }
1870
1871
1872 static void
1873 sinh_test (void)
1874 {
1875   check ("sinh (+0) == +0", FUNC(sinh) (0), 0);
1876
1877 #ifndef TEST_INLINE
1878   check ("sinh (-0) == -0", FUNC(sinh) (minus_zero), minus_zero);
1879
1880   check_isinfp ("sinh (+inf) == +inf", FUNC(sinh) (plus_infty));
1881   check_isinfn ("sinh (-inf) == -inf", FUNC(sinh) (minus_infty));
1882 #endif
1883
1884   check_eps ("sinh (0.7) == 0.7585837018...", FUNC(sinh) (0.7),
1885              0.75858370183953350346L, CHOOSE(6e-17L, 2e-16, 6e-8));
1886 }
1887
1888
1889 static void
1890 sincos_test (void)
1891 {
1892   MATHTYPE sin_res, cos_res;
1893   fenv_t fenv;
1894
1895   FUNC(sincos) (0, &sin_res, &cos_res);
1896   fegetenv (&fenv);
1897   check ("sincos (+0, &sin, &cos) puts +0 in sin", sin_res, 0);
1898   fesetenv (&fenv);
1899   check ("sincos (+0, &sin, &cos) puts 1 in cos", cos_res, 1);
1900
1901   FUNC(sincos) (minus_zero, &sin_res, &cos_res);
1902   fegetenv (&fenv);
1903   check ("sincos (-0, &sin, &cos) puts -0 in sin", sin_res, minus_zero);
1904   fesetenv (&fenv);
1905   check ("sincos (-0, &sin, &cos) puts 1 in cos", cos_res, 1);
1906
1907   FUNC(sincos) (plus_infty, &sin_res, &cos_res);
1908   fegetenv (&fenv);
1909   check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in sin plus invalid exception",
1910                    sin_res, INVALID_EXCEPTION);
1911   fesetenv (&fenv);
1912   check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in cos plus invalid exception",
1913                    cos_res, INVALID_EXCEPTION);
1914
1915   FUNC(sincos) (minus_infty, &sin_res, &cos_res);
1916   fegetenv (&fenv);
1917   check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in sin plus invalid exception",
1918                    sin_res, INVALID_EXCEPTION);
1919   fesetenv (&fenv);
1920   check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in cos plus invalid exception",
1921                    cos_res, INVALID_EXCEPTION);
1922
1923   FUNC(sincos) (M_PI_2l, &sin_res, &cos_res);
1924   fegetenv (&fenv);
1925   check ("sincos (pi/2, &sin, &cos) puts 1 in sin", sin_res, 1);
1926   fesetenv (&fenv);
1927   check_eps ("sincos (pi/2, &sin, &cos) puts 0 in cos", cos_res, 0,
1928              CHOOSE (1e-18L, 1e-16, 1e-7));
1929
1930   FUNC(sincos) (M_PI_6l, &sin_res, &cos_res);
1931   check_eps ("sincos (pi/6, &sin, &cos) puts 0.5 in sin", sin_res, 0.5,
1932              CHOOSE (5e-18L, 0, 0));
1933
1934   FUNC(sincos) (M_PI_6l*2.0, &sin_res, &cos_res);
1935   check_eps ("sincos (pi/3, &sin, &cos) puts 0.5 in cos", cos_res, 0.5,
1936              CHOOSE (5e-18L, 1e-15, 1e-7));
1937
1938   FUNC(sincos) (0.7, &sin_res, &cos_res);
1939   check_eps ("sincos (0.7, &sin, &cos) puts 0.6442176872... in sin", sin_res,
1940              0.64421768723769105367L, CHOOSE(4e-17L, 0, 0));
1941   check_eps ("sincos (0.7, &sin, &cos) puts 0.7648421872... in cos", cos_res,
1942              0.76484218728448842626L, CHOOSE(3e-17L, 2e-16, 6e-8));
1943 }
1944
1945
1946 static void
1947 tan_test (void)
1948 {
1949   check ("tan (+0) == +0", FUNC(tan) (0), 0);
1950   check ("tan (-0) == -0", FUNC(tan) (minus_zero), minus_zero);
1951   check_isnan_exc ("tan (+inf) == NaN plus invalid exception",
1952                    FUNC(tan) (plus_infty), INVALID_EXCEPTION);
1953   check_isnan_exc ("tan (-inf) == NaN plus invalid exception",
1954                    FUNC(tan) (minus_infty), INVALID_EXCEPTION);
1955
1956   check_eps ("tan (pi/4) == 1", FUNC(tan) (M_PI_4l), 1,
1957              CHOOSE (2e-18L, 1e-15L, 2e-7));
1958   check_eps ("tan (0.7) == 0.8422883804...", FUNC(tan) (0.7),
1959              0.84228838046307944813L, CHOOSE(8e-17L, 0, 0));
1960 }
1961
1962
1963 static void
1964 tanh_test (void)
1965 {
1966   check ("tanh (+0) == +0", FUNC(tanh) (0), 0);
1967 #ifndef TEST_INLINE
1968   check ("tanh (-0) == -0", FUNC(tanh) (minus_zero), minus_zero);
1969
1970   check ("tanh (+inf) == +1", FUNC(tanh) (plus_infty), 1);
1971   check ("tanh (-inf) == -1", FUNC(tanh) (minus_infty), -1);
1972 #endif
1973   check_eps ("tanh (0.7) == 0.6043677771...", FUNC(tanh) (0.7),
1974              0.60436777711716349631L, CHOOSE(3e-17L, 2e-16, 6e-8));
1975 }
1976
1977
1978 static void
1979 fabs_test (void)
1980 {
1981   check ("fabs (+0) == +0", FUNC(fabs) (0), 0);
1982   check ("fabs (-0) == +0", FUNC(fabs) (minus_zero), 0);
1983
1984   check_isinfp ("fabs (+inf) == +inf", FUNC(fabs) (plus_infty));
1985   check_isinfp ("fabs (-inf) == +inf", FUNC(fabs) (minus_infty));
1986
1987   check ("fabs (+38) == 38", FUNC(fabs) (38.0), 38.0);
1988   check ("fabs (-e) == e", FUNC(fabs) (-M_El), M_El);
1989 }
1990
1991
1992 static void
1993 floor_test (void)
1994 {
1995   check ("floor (+0) == +0", FUNC(floor) (0.0), 0.0);
1996   check ("floor (-0) == -0", FUNC(floor) (minus_zero), minus_zero);
1997   check_isinfp ("floor (+inf) == +inf", FUNC(floor) (plus_infty));
1998   check_isinfn ("floor (-inf) == -inf", FUNC(floor) (minus_infty));
1999
2000   check ("floor (pi) == 3", FUNC(floor) (M_PIl), 3.0);
2001   check ("floor (-pi) == -4", FUNC(floor) (-M_PIl), -4.0);
2002 }
2003
2004
2005 static void
2006 hypot_test (void)
2007 {
2008   MATHTYPE a;
2009
2010   a = random_greater (0);
2011   check_isinfp_ext ("hypot (+inf, x) == +inf", FUNC(hypot) (plus_infty, a), a);
2012   check_isinfp_ext ("hypot (-inf, x) == +inf", FUNC(hypot) (minus_infty, a), a);
2013
2014 #ifndef TEST_INLINE
2015   check_isinfp ("hypot (+inf, NaN) == +inf", FUNC(hypot) (plus_infty, nan_value));
2016   check_isinfp ("hypot (-inf, NaN) == +inf", FUNC(hypot) (minus_infty, nan_value));
2017 #endif
2018
2019   check_isnan ("hypot (NaN, NaN) == NaN", FUNC(hypot) (nan_value, nan_value));
2020
2021   a = FUNC(hypot) (12.4L, 0.7L);
2022   check ("hypot (x,y) == hypot (y,x)", FUNC(hypot) (0.7L, 12.4L), a);
2023   check ("hypot (x,y) == hypot (-x,y)", FUNC(hypot) (-12.4L, 0.7L), a);
2024   check ("hypot (x,y) == hypot (-y,x)", FUNC(hypot) (-0.7L, 12.4L), a);
2025   check ("hypot (x,y) == hypot (-x,-y)", FUNC(hypot) (-12.4L, -0.7L), a);
2026   check ("hypot (x,y) == hypot (-y,-x)", FUNC(hypot) (-0.7L, -12.4L), a);
2027   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-0.7L, 0), 0.7L);
2028   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (0.7L, 0), 0.7L);
2029   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-1.0L, 0), 1.0L);
2030   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (1.0L, 0), 1.0L);
2031   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-5.7e7L, 0), 5.7e7L);
2032   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (5.7e7L, 0), 5.7e7L);
2033
2034   check_eps ("hypot (0.7,1.2) == 1.38924...", FUNC(hypot) (0.7, 1.2),
2035              1.3892443989449804508L, CHOOSE(7e-17L, 3e-16, 0));
2036 }
2037
2038
2039 static void
2040 pow_test (void)
2041 {
2042   MATHTYPE x;
2043
2044   check ("pow (+0, +0) == 1", FUNC(pow) (0, 0), 1);
2045   check ("pow (+0, -0) == 1", FUNC(pow) (0, minus_zero), 1);
2046   check ("pow (-0, +0) == 1", FUNC(pow) (minus_zero, 0), 1);
2047   check ("pow (-0, -0) == 1", FUNC(pow) (minus_zero, minus_zero), 1);
2048
2049   check ("pow (+10, +0) == 1", FUNC(pow) (10, 0), 1);
2050   check ("pow (+10, -0) == 1", FUNC(pow) (10, minus_zero), 1);
2051   check ("pow (-10, +0) == 1", FUNC(pow) (-10, 0), 1);
2052   check ("pow (-10, -0) == 1", FUNC(pow) (-10, minus_zero), 1);
2053
2054   check ("pow (NaN, +0) == 1", FUNC(pow) (nan_value, 0), 1);
2055   check ("pow (NaN, -0) == 1", FUNC(pow) (nan_value, minus_zero), 1);
2056
2057 #ifndef TEST_INLINE
2058   check_isinfp ("pow (+1.1, +inf) == +inf", FUNC(pow) (1.1, plus_infty));
2059   check_isinfp ("pow (+inf, +inf) == +inf", FUNC(pow) (plus_infty, plus_infty));
2060   check_isinfp ("pow (-1.1, +inf) == +inf", FUNC(pow) (-1.1, plus_infty));
2061   check_isinfp ("pow (-inf, +inf) == +inf", FUNC(pow) (minus_infty, plus_infty));
2062
2063   check ("pow (0.9, +inf) == +0", FUNC(pow) (0.9L, plus_infty), 0);
2064   check ("pow (1e-7, +inf) == +0", FUNC(pow) (1e-7L, plus_infty), 0);
2065   check ("pow (-0.9, +inf) == +0", FUNC(pow) (-0.9L, plus_infty), 0);
2066   check ("pow (-1e-7, +inf) == +0", FUNC(pow) (-1e-7L, plus_infty), 0);
2067
2068   check ("pow (+1.1, -inf) == 0", FUNC(pow) (1.1, minus_infty), 0);
2069   check ("pow (+inf, -inf) == 0", FUNC(pow) (plus_infty, minus_infty), 0);
2070   check ("pow (-1.1, -inf) == 0", FUNC(pow) (-1.1, minus_infty), 0);
2071   check ("pow (-inf, -inf) == 0", FUNC(pow) (minus_infty, minus_infty), 0);
2072
2073   check_isinfp ("pow (0.9, -inf) == +inf", FUNC(pow) (0.9L, minus_infty));
2074   check_isinfp ("pow (1e-7, -inf) == +inf", FUNC(pow) (1e-7L, minus_infty));
2075   check_isinfp ("pow (-0.9, -inf) == +inf", FUNC(pow) (-0.9L, minus_infty));
2076   check_isinfp ("pow (-1e-7, -inf) == +inf", FUNC(pow) (-1e-7L, minus_infty));
2077
2078   check_isinfp ("pow (+inf, 1e-7) == +inf", FUNC(pow) (plus_infty, 1e-7L));
2079   check_isinfp ("pow (+inf, 1) == +inf", FUNC(pow) (plus_infty, 1));
2080   check_isinfp ("pow (+inf, 1e7) == +inf", FUNC(pow) (plus_infty, 1e7L));
2081
2082   check ("pow (+inf, -1e-7) == 0", FUNC(pow) (plus_infty, -1e-7L), 0);
2083   check ("pow (+inf, -1) == 0", FUNC(pow) (plus_infty, -1), 0);
2084   check ("pow (+inf, -1e7) == 0", FUNC(pow) (plus_infty, -1e7L), 0);
2085
2086   check_isinfn ("pow (-inf, 1) == -inf", FUNC(pow) (minus_infty, 1));
2087   check_isinfn ("pow (-inf, 11) == -inf", FUNC(pow) (minus_infty, 11));
2088   check_isinfn ("pow (-inf, 1001) == -inf", FUNC(pow) (minus_infty, 1001));
2089
2090   check_isinfp ("pow (-inf, 2) == +inf", FUNC(pow) (minus_infty, 2));
2091   check_isinfp ("pow (-inf, 12) == +inf", FUNC(pow) (minus_infty, 12));
2092   check_isinfp ("pow (-inf, 1002) == +inf", FUNC(pow) (minus_infty, 1002));
2093   check_isinfp ("pow (-inf, 0.1) == +inf", FUNC(pow) (minus_infty, 0.1));
2094   check_isinfp ("pow (-inf, 1.1) == +inf", FUNC(pow) (minus_infty, 1.1));
2095   check_isinfp ("pow (-inf, 11.1) == +inf", FUNC(pow) (minus_infty, 11.1));
2096   check_isinfp ("pow (-inf, 1001.1) == +inf", FUNC(pow) (minus_infty, 1001.1));
2097
2098   check ("pow (-inf, -1) == -0", FUNC(pow) (minus_infty, -1), minus_zero);
2099   check ("pow (-inf, -11) == -0", FUNC(pow) (minus_infty, -11), minus_zero);
2100   check ("pow (-inf, -1001) == -0", FUNC(pow) (minus_infty, -1001), minus_zero);
2101
2102   check ("pow (-inf, -2) == +0", FUNC(pow) (minus_infty, -2), 0);
2103   check ("pow (-inf, -12) == +0", FUNC(pow) (minus_infty, -12), 0);
2104   check ("pow (-inf, -1002) == +0", FUNC(pow) (minus_infty, -1002), 0);
2105   check ("pow (-inf, -0.1) == +0", FUNC(pow) (minus_infty, -0.1), 0);
2106   check ("pow (-inf, -1.1) == +0", FUNC(pow) (minus_infty, -1.1), 0);
2107   check ("pow (-inf, -11.1) == +0", FUNC(pow) (minus_infty, -11.1), 0);
2108   check ("pow (-inf, -1001.1) == +0", FUNC(pow) (minus_infty, -1001.1), 0);
2109
2110   check_isnan ("pow (NaN, NaN) == NaN", FUNC(pow) (nan_value, nan_value));
2111   check_isnan ("pow (0, NaN) == NaN", FUNC(pow) (0, nan_value));
2112   check_isnan ("pow (1, NaN) == NaN", FUNC(pow) (1, nan_value));
2113   check_isnan ("pow (-1, NaN) == NaN", FUNC(pow) (-1, nan_value));
2114   check_isnan ("pow (NaN, 1) == NaN", FUNC(pow) (nan_value, 1));
2115   check_isnan ("pow (NaN, -1) == NaN", FUNC(pow) (nan_value, -1));
2116
2117   x = random_greater (0.0);
2118   check_isnan_ext ("pow (x, NaN) == NaN", FUNC(pow) (x, nan_value), x);
2119
2120   check_isnan_exc ("pow (+1, +inf) == NaN plus invalid exception",
2121                    FUNC(pow) (1, plus_infty), INVALID_EXCEPTION);
2122   check_isnan_exc ("pow (-1, +inf) == NaN plus invalid exception",
2123                    FUNC(pow) (-1, plus_infty), INVALID_EXCEPTION);
2124   check_isnan_exc ("pow (+1, -inf) == NaN plus invalid exception",
2125                    FUNC(pow) (1, minus_infty), INVALID_EXCEPTION);
2126   check_isnan_exc ("pow (-1, -inf) == NaN plus invalid exception",
2127                    FUNC(pow) (-1, minus_infty), INVALID_EXCEPTION);
2128
2129   check_isnan_exc ("pow (-0.1, 1.1) == NaN plus invalid exception",
2130                    FUNC(pow) (-0.1, 1.1), INVALID_EXCEPTION);
2131   check_isnan_exc ("pow (-0.1, -1.1) == NaN plus invalid exception",
2132                    FUNC(pow) (-0.1, -1.1), INVALID_EXCEPTION);
2133   check_isnan_exc ("pow (-10.1, 1.1) == NaN plus invalid exception",
2134                    FUNC(pow) (-10.1, 1.1), INVALID_EXCEPTION);
2135   check_isnan_exc ("pow (-10.1, -1.1) == NaN plus invalid exception",
2136                    FUNC(pow) (-10.1, -1.1), INVALID_EXCEPTION);
2137
2138   check_isinfp_exc ("pow (+0, -1) == +inf plus divide-by-zero exception",
2139                     FUNC(pow) (0, -1), DIVIDE_BY_ZERO_EXCEPTION);
2140   check_isinfp_exc ("pow (+0, -11) == +inf plus divide-by-zero exception",
2141                     FUNC(pow) (0, -11), DIVIDE_BY_ZERO_EXCEPTION);
2142   check_isinfn_exc ("pow (-0, -1) == -inf plus divide-by-zero exception",
2143                     FUNC(pow) (minus_zero, -1), DIVIDE_BY_ZERO_EXCEPTION);
2144   check_isinfn_exc ("pow (-0, -11) == -inf plus divide-by-zero exception",
2145                     FUNC(pow) (minus_zero, -11), DIVIDE_BY_ZERO_EXCEPTION);
2146
2147   check_isinfp_exc ("pow (+0, -2) == +inf plus divide-by-zero exception",
2148                     FUNC(pow) (0, -2), DIVIDE_BY_ZERO_EXCEPTION);
2149   check_isinfp_exc ("pow (+0, -11.1) == +inf plus divide-by-zero exception",
2150                     FUNC(pow) (0, -11.1), DIVIDE_BY_ZERO_EXCEPTION);
2151   check_isinfp_exc ("pow (-0, -2) == +inf plus divide-by-zero exception",
2152                     FUNC(pow) (minus_zero, -2), DIVIDE_BY_ZERO_EXCEPTION);
2153   check_isinfp_exc ("pow (-0, -11.1) == +inf plus divide-by-zero exception",
2154                     FUNC(pow) (minus_zero, -11.1), DIVIDE_BY_ZERO_EXCEPTION);
2155 #endif
2156
2157   check ("pow (+0, 1) == +0", FUNC(pow) (0, 1), 0);
2158   check ("pow (+0, 11) == +0", FUNC(pow) (0, 11), 0);
2159 #ifndef TEST_INLINE
2160   check ("pow (-0, 1) == -0", FUNC(pow) (minus_zero, 1), minus_zero);
2161   check ("pow (-0, 11) == -0", FUNC(pow) (minus_zero, 11), minus_zero);
2162 #endif
2163
2164   check ("pow (+0, 2) == +0", FUNC(pow) (0, 2), 0);
2165   check ("pow (+0, 11.1) == +0", FUNC(pow) (0, 11.1), 0);
2166
2167 #ifndef TEST_INLINE
2168   check ("pow (-0, 2) == +0", FUNC(pow) (minus_zero, 2), 0);
2169   check ("pow (-0, 11.1) == +0", FUNC(pow) (minus_zero, 11.1), 0);
2170
2171   x = random_greater (1.0);
2172   check_isinfp_ext ("pow (x, +inf) == +inf for |x| > 1",
2173                     FUNC(pow) (x, plus_infty), x);
2174
2175   x = random_value (-1.0, 1.0);
2176   check_ext ("pow (x, +inf) == +0 for |x| < 1",
2177              FUNC(pow) (x, plus_infty), 0.0, x);
2178
2179   x = random_greater (1.0);
2180   check_ext ("pow (x, -inf) == +0 for |x| > 1",
2181              FUNC(pow) (x, minus_infty), 0.0, x);
2182
2183   x = random_value (-1.0, 1.0);
2184   check_isinfp_ext ("pow (x, -inf) == +inf for |x| < 1",
2185                     FUNC(pow) (x, minus_infty), x);
2186
2187   x = random_greater (0.0);
2188   check_isinfp_ext ("pow (+inf, y) == +inf for y > 0",
2189                     FUNC(pow) (plus_infty, x), x);
2190
2191   x = random_less (0.0);
2192   check_ext ("pow (+inf, y) == +0 for y < 0",
2193              FUNC(pow) (plus_infty, x), 0.0, x);
2194
2195   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2196   check_isinfn_ext ("pow (-inf, y) == -inf for y an odd integer > 0",
2197                     FUNC(pow) (minus_infty, x), x);
2198
2199   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2200   check_isinfp_ext ("pow (-inf, y) == +inf for y > 0 and not an odd integer",
2201                     FUNC(pow) (minus_infty, x), x);
2202
2203   x = -((rand () % 1000000) * 2.0 + 1); /* Get random odd integer < 0 */
2204   check_ext ("pow (-inf, y) == -0 for y an odd integer < 0",
2205              FUNC(pow) (minus_infty, x), minus_zero, x);
2206
2207   x = ((rand () % 1000000) + 1) * -2.0; /* Get random even integer < 0 */
2208   check_ext ("pow (-inf, y) == +0 for y < 0 and not an odd integer",
2209              FUNC(pow) (minus_infty, x), 0.0, x);
2210 #endif
2211
2212   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2213   check_ext ("pow (+0, y) == +0 for y an odd integer > 0",
2214              FUNC(pow) (0.0, x), 0.0, x);
2215 #ifndef TEST_INLINE
2216   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
2217   check_ext ("pow (-0, y) == -0 for y an odd integer > 0",
2218              FUNC(pow) (minus_zero, x), minus_zero, x);
2219 #endif
2220
2221   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2222   check_ext ("pow (+0, y) == +0 for y > 0 and not an odd integer",
2223              FUNC(pow) (0.0, x), 0.0, x);
2224
2225   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
2226   check_ext ("pow (-0, y) == +0 for y > 0 and not an odd integer",
2227              FUNC(pow) (minus_zero, x), 0.0, x);
2228
2229   check_eps ("pow (0.7, 1.2) == 0.65180...", FUNC(pow) (0.7, 1.2),
2230              0.65180494056638638188L, CHOOSE(4e-17L, 0, 0));
2231
2232 #ifdef TEST_DOUBLE
2233   check ("pow (-7.49321e+133, -9.80818e+16) == 0",
2234          FUNC(pow) (-7.49321e+133, -9.80818e+16), 0);
2235 #endif
2236 }
2237
2238
2239 static void
2240 fdim_test (void)
2241 {
2242   check ("fdim (+0, +0) = +0", FUNC(fdim) (0, 0), 0);
2243   check ("fdim (9, 0) = 9", FUNC(fdim) (9, 0), 9);
2244   check ("fdim (0, 9) = 0", FUNC(fdim) (0, 9), 0);
2245   check ("fdim (-9, 0) = 9", FUNC(fdim) (-9, 0), 0);
2246   check ("fdim (0, -9) = 9", FUNC(fdim) (0, -9), 9);
2247
2248   check_isinfp ("fdim (+inf, 9) = +inf", FUNC(fdim) (plus_infty, 9));
2249   check_isinfp ("fdim (+inf, -9) = +inf", FUNC(fdim) (plus_infty, -9));
2250   check ("fdim (-inf, 9) = 0", FUNC(fdim) (minus_infty, 9), 0);
2251   check ("fdim (-inf, -9) = 0", FUNC(fdim) (minus_infty, -9), 0);
2252   check_isinfp ("fdim (+9, -inf) = +inf", FUNC(fdim) (9, minus_infty));
2253   check_isinfp ("fdim (-9, -inf) = +inf", FUNC(fdim) (-9, minus_infty));
2254   check ("fdim (9, inf) = 0", FUNC(fdim) (9, plus_infty), 0);
2255   check ("fdim (-9, inf) = 0", FUNC(fdim) (-9, plus_infty), 0);
2256
2257   check_isnan ("fdim (0, NaN) = NaN", FUNC(fdim) (0, nan_value));
2258   check_isnan ("fdim (9, NaN) = NaN", FUNC(fdim) (9, nan_value));
2259   check_isnan ("fdim (-9, NaN) = NaN", FUNC(fdim) (-9, nan_value));
2260   check_isnan ("fdim (NaN, 9) = NaN", FUNC(fdim) (nan_value, 9));
2261   check_isnan ("fdim (NaN, -9) = NaN", FUNC(fdim) (nan_value, -9));
2262   check_isnan ("fdim (+inf, NaN) = NaN", FUNC(fdim) (plus_infty, nan_value));
2263   check_isnan ("fdim (-inf, NaN) = NaN", FUNC(fdim) (minus_infty, nan_value));
2264   check_isnan ("fdim (NaN, +inf) = NaN", FUNC(fdim) (nan_value, plus_infty));
2265   check_isnan ("fdim (NaN, -inf) = NaN", FUNC(fdim) (nan_value, minus_infty));
2266   check_isnan ("fdim (NaN, NaN) = NaN", FUNC(fdim) (nan_value, nan_value));
2267 }
2268
2269
2270 static void
2271 fmin_test (void)
2272 {
2273   check ("fmin (+0, +0) = +0", FUNC(fmin) (0, 0), 0);
2274   check ("fmin (9, 0) = 0", FUNC(fmin) (9, 0), 0);
2275   check ("fmin (0, 9) = 0", FUNC(fmin) (0, 9), 0);
2276   check ("fmin (-9, 0) = -9", FUNC(fmin) (-9, 0), -9);
2277   check ("fmin (0, -9) = -9", FUNC(fmin) (0, -9), -9);
2278
2279   check ("fmin (+inf, 9) = 9", FUNC(fmin) (plus_infty, 9), 9);
2280   check ("fmin (9, +inf) = 9", FUNC(fmin) (9, plus_infty), 9);
2281   check ("fmin (+inf, -9) = -9", FUNC(fmin) (plus_infty, -9), -9);
2282   check ("fmin (-9, +inf) = -9", FUNC(fmin) (-9, plus_infty), -9);
2283   check_isinfn ("fmin (-inf, 9) = -inf", FUNC(fmin) (minus_infty, 9));
2284   check_isinfn ("fmin (-inf, -9) = -inf", FUNC(fmin) (minus_infty, -9));
2285   check_isinfn ("fmin (+9, -inf) = -inf", FUNC(fmin) (9, minus_infty));
2286   check_isinfn ("fmin (-9, -inf) = -inf", FUNC(fmin) (-9, minus_infty));
2287
2288   check ("fmin (0, NaN) = 0", FUNC(fmin) (0, nan_value), 0);
2289   check ("fmin (9, NaN) = 9", FUNC(fmin) (9, nan_value), 9);
2290   check ("fmin (-9, NaN) = 9", FUNC(fmin) (-9, nan_value), -9);
2291   check ("fmin (NaN, 0) = 0", FUNC(fmin) (nan_value, 0), 0);
2292   check ("fmin (NaN, 9) = NaN", FUNC(fmin) (nan_value, 9), 9);
2293   check ("fmin (NaN, -9) = NaN", FUNC(fmin) (nan_value, -9), -9);
2294   check_isinfp ("fmin (+inf, NaN) = +inf", FUNC(fmin) (plus_infty, nan_value));
2295   check_isinfn ("fmin (-inf, NaN) = -inf", FUNC(fmin) (minus_infty, nan_value));
2296   check_isinfp ("fmin (NaN, +inf) = +inf", FUNC(fmin) (nan_value, plus_infty));
2297   check_isinfn ("fmin (NaN, -inf) = -inf", FUNC(fmin) (nan_value, minus_infty));
2298   check_isnan ("fmin (NaN, NaN) = NaN", FUNC(fmin) (nan_value, nan_value));
2299 }
2300
2301
2302 static void
2303 fmax_test (void)
2304 {
2305   check ("fmax (+0, +0) = +0", FUNC(fmax) (0, 0), 0);
2306   check ("fmax (9, 0) = 9", FUNC(fmax) (9, 0), 9);
2307   check ("fmax (0, 9) = 9", FUNC(fmax) (0, 9), 9);
2308   check ("fmax (-9, 0) = 0", FUNC(fmax) (-9, 0), 0);
2309   check ("fmax (0, -9) = 0", FUNC(fmax) (0, -9), 0);
2310
2311   check_isinfp ("fmax (+inf, 9) = +inf", FUNC(fmax) (plus_infty, 9));
2312   check_isinfp ("fmax (9, +inf) = +inf", FUNC(fmax) (0, plus_infty));
2313   check_isinfp ("fmax (-9, +inf) = +inf", FUNC(fmax) (-9, plus_infty));
2314   check_isinfp ("fmax (+inf, -9) = +inf", FUNC(fmax) (plus_infty, -9));
2315   check ("fmax (-inf, 9) = 9", FUNC(fmax) (minus_infty, 9), 9);
2316   check ("fmax (-inf, -9) = -9", FUNC(fmax) (minus_infty, -9), -9);
2317   check ("fmax (+9, -inf) = 9", FUNC(fmax) (9, minus_infty), 9);
2318   check ("fmax (-9, -inf) = -9", FUNC(fmax) (-9, minus_infty), -9);
2319
2320   check ("fmax (0, NaN) = 0", FUNC(fmax) (0, nan_value), 0);
2321   check ("fmax (9, NaN) = 9", FUNC(fmax) (9, nan_value), 9);
2322   check ("fmax (-9, NaN) = 9", FUNC(fmax) (-9, nan_value), -9);
2323   check ("fmax (NaN, 0) = 0", FUNC(fmax) (nan_value, 0), 0);
2324   check ("fmax (NaN, 9) = NaN", FUNC(fmax) (nan_value, 9), 9);
2325   check ("fmax (NaN, -9) = NaN", FUNC(fmax) (nan_value, -9), -9);
2326   check_isinfp ("fmax (+inf, NaN) = +inf", FUNC(fmax) (plus_infty, nan_value));
2327   check_isinfn ("fmax (-inf, NaN) = -inf", FUNC(fmax) (minus_infty, nan_value));
2328   check_isinfp ("fmax (NaN, +inf) = +inf", FUNC(fmax) (nan_value, plus_infty));
2329   check_isinfn ("fmax (NaN, -inf) = -inf", FUNC(fmax) (nan_value, minus_infty));
2330   check_isnan ("fmax (NaN, NaN) = NaN", FUNC(fmax) (nan_value, nan_value));
2331 }
2332
2333
2334 static void
2335 fmod_test (void)
2336 {
2337   MATHTYPE x;
2338
2339   x = random_greater (0);
2340   check_ext ("fmod (+0, y) == +0 for y != 0", FUNC(fmod) (0, x), 0, x);
2341
2342   x = random_greater (0);
2343   check_ext ("fmod (-0, y) == -0 for y != 0", FUNC(fmod) (minus_zero, x),
2344              minus_zero, x);
2345
2346   check_isnan_exc_ext ("fmod (+inf, y) == NaN plus invalid exception",
2347                        FUNC(fmod) (plus_infty, x), INVALID_EXCEPTION, x);
2348   check_isnan_exc_ext ("fmod (-inf, y) == NaN plus invalid exception",
2349                        FUNC(fmod) (minus_infty, x), INVALID_EXCEPTION, x);
2350   check_isnan_exc_ext ("fmod (x, +0) == NaN plus invalid exception",
2351                        FUNC(fmod) (x, 0), INVALID_EXCEPTION, x);
2352   check_isnan_exc_ext ("fmod (x, -0) == NaN plus invalid exception",
2353                        FUNC(fmod) (x, minus_zero), INVALID_EXCEPTION, x);
2354
2355   x = random_greater (0);
2356   check_ext ("fmod (x, +inf) == x for x not infinite",
2357              FUNC(fmod) (x, plus_infty), x, x);
2358   x = random_greater (0);
2359   check_ext ("fmod (x, -inf) == x for x not infinite",
2360              FUNC(fmod) (x, minus_infty), x, x);
2361
2362   check_eps ("fmod (6.5, 2.3) == 1.9", FUNC(fmod) (6.5, 2.3), 1.9,
2363              CHOOSE(5e-16, 1e-15, 2e-7));
2364   check_eps ("fmod (-6.5, 2.3) == -1.9", FUNC(fmod) (-6.5, 2.3), -1.9,
2365              CHOOSE(5e-16, 1e-15, 2e-7));
2366   check_eps ("fmod (6.5, -2.3) == 1.9", FUNC(fmod) (6.5, -2.3), 1.9,
2367              CHOOSE(5e-16, 1e-15, 2e-7));
2368   check_eps ("fmod (-6.5, -2.3) == -1.9", FUNC(fmod) (-6.5, -2.3), -1.9,
2369              CHOOSE(5e-16, 1e-15, 2e-7));
2370
2371
2372 }
2373
2374
2375 static void
2376 nextafter_test (void)
2377 {
2378   MATHTYPE x;
2379
2380   check ("nextafter (+0, +0) = +0", FUNC(nextafter) (0, 0), 0);
2381   check ("nextafter (-0, +0) = +0", FUNC(nextafter) (minus_zero, 0), 0);
2382   check ("nextafter (+0, -0) = -0", FUNC(nextafter) (0, minus_zero),
2383          minus_zero);
2384   check ("nextafter (-0, -0) = -0", FUNC(nextafter) (minus_zero, minus_zero),
2385          minus_zero);
2386
2387   check ("nextafter (9, 9) = 9",  FUNC(nextafter) (9, 9), 9);
2388   check ("nextafter (-9, -9) = -9",  FUNC(nextafter) (-9, -9), -9);
2389   check_isinfp ("nextafter (+inf, +inf) = +inf",
2390                 FUNC(nextafter) (plus_infty, plus_infty));
2391   check_isinfn ("nextafter (-inf, -inf) = -inf",
2392                 FUNC(nextafter) (minus_infty, minus_infty));
2393
2394   x = rand () * 1.1;
2395   check_isnan ("nextafter (NaN, x) = NaN", FUNC(nextafter) (nan_value, x));
2396   check_isnan ("nextafter (x, NaN) = NaN", FUNC(nextafter) (x, nan_value));
2397   check_isnan ("nextafter (NaN, NaN) = NaN", FUNC(nextafter) (nan_value,
2398                                                               nan_value));
2399
2400   /* XXX We need the hexadecimal FP number representation here for further
2401      tests.  */
2402 }
2403
2404
2405 static void
2406 copysign_test (void)
2407 {
2408   check ("copysign (0, 4) = 0", FUNC(copysign) (0, 4), 0);
2409   check ("copysign (0, -4) = -0", FUNC(copysign) (0, -4), minus_zero);
2410   check ("copysign (-0, 4) = 0", FUNC(copysign) (minus_zero, 4), 0);
2411   check ("copysign (-0, -4) = -0", FUNC(copysign) (minus_zero, -4),
2412          minus_zero);
2413
2414   check_isinfp ("copysign (+inf, 0) = +inf", FUNC(copysign) (plus_infty, 0));
2415   check_isinfn ("copysign (+inf, -0) = -inf", FUNC(copysign) (plus_infty,
2416                                                               minus_zero));
2417   check_isinfp ("copysign (-inf, 0) = +inf", FUNC(copysign) (minus_infty, 0));
2418   check_isinfn ("copysign (-inf, -0) = -inf", FUNC(copysign) (minus_infty,
2419                                                               minus_zero));
2420
2421   check ("copysign (0, +inf) = 0", FUNC(copysign) (0, plus_infty), 0);
2422   check ("copysign (0, -inf) = -0", FUNC(copysign) (0, minus_zero),
2423          minus_zero);
2424   check ("copysign (-0, +inf) = 0", FUNC(copysign) (minus_zero, plus_infty),
2425          0);
2426   check ("copysign (-0, -inf) = -0", FUNC(copysign) (minus_zero, minus_zero),
2427          minus_zero);
2428
2429   /* XXX More correctly we would have to check the sign of the NaN.  */
2430   check_isnan ("copysign (+NaN, 0) = +NaN", FUNC(copysign) (nan_value, 0));
2431   check_isnan ("copysign (+NaN, -0) = -NaN", FUNC(copysign) (nan_value,
2432                                                              minus_zero));
2433   check_isnan ("copysign (-NaN, 0) = +NaN", FUNC(copysign) (-nan_value, 0));
2434   check_isnan ("copysign (-NaN, -0) = -NaN", FUNC(copysign) (-nan_value,
2435                                                              minus_zero));
2436 }
2437
2438
2439 static void
2440 trunc_test (void)
2441 {
2442   check ("trunc(0) = 0", FUNC(trunc) (0), 0);
2443   check ("trunc(-0) = -0", FUNC(trunc) (minus_zero), minus_zero);
2444   check ("trunc(0.625) = 0", FUNC(trunc) (0.625), 0);
2445   check ("trunc(-0.625) = -0", FUNC(trunc) (-0.625), minus_zero);
2446   check ("trunc(1) = 1", FUNC(trunc) (1), 1);
2447   check ("trunc(-1) = -1", FUNC(trunc) (-1), -1);
2448   check ("trunc(1.625) = 1", FUNC(trunc) (1.625), 1);
2449   check ("trunc(-1.625) = -1", FUNC(trunc) (-1.625), -1);
2450
2451   check ("trunc(1048580.625) = 1048580", FUNC(trunc) (1048580.625L),
2452          1048580L);
2453   check ("trunc(-1048580.625) = -1048580", FUNC(trunc) (-1048580.625L),
2454          -1048580L);
2455
2456   check ("trunc(8388610.125) = 8388610", FUNC(trunc) (8388610.125L),
2457          8388610.0L);
2458   check ("trunc(-8388610.125) = -8388610", FUNC(trunc) (-8388610.125L),
2459          -8388610.0L);
2460
2461   check ("trunc(4294967296.625) = 4294967296", FUNC(trunc) (4294967296.625L),
2462          4294967296.0L);
2463   check ("trunc(-4294967296.625) = -4294967296",
2464          FUNC(trunc) (-4294967296.625L), -4294967296.0L);
2465
2466   check_isinfp ("trunc(+inf) = +inf", FUNC(trunc) (plus_infty));
2467   check_isinfn ("trunc(-inf) = -inf", FUNC(trunc) (minus_infty));
2468   check_isnan ("trunc(NaN) = NaN", FUNC(trunc) (nan_value));
2469 }
2470
2471
2472 static void
2473 sqrt_test (void)
2474 {
2475   MATHTYPE x;
2476
2477
2478   /* XXX Tests fuer negative x are missing */
2479   check ("sqrt (0) == 0", FUNC(sqrt) (0), 0);
2480   check_isnan ("sqrt (NaN) == NaN", FUNC(sqrt) (nan_value));
2481   check_isinfp ("sqrt (+inf) == +inf", FUNC(sqrt) (plus_infty));
2482
2483   check ("sqrt (-0) == -0", FUNC(sqrt) (0), 0);
2484
2485   x = random_less (0.0);
2486   check_isnan_exc_ext ("sqrt (x) == NaN plus invalid exception for x < 0",
2487                        FUNC(sqrt) (x), INVALID_EXCEPTION, x);
2488
2489   x = random_value (0, 10000);
2490   check_ext ("sqrt (x*x) == x", FUNC(sqrt) (x*x), x, x);
2491   check ("sqrt (4) == 2", FUNC(sqrt) (4), 2);
2492   check ("sqrt (2) == 1.14142...", FUNC(sqrt) (2), M_SQRT2l);
2493   check ("sqrt (0.25) == 0.5", FUNC(sqrt) (0.25), 0.5);
2494   check ("sqrt (6642.25) == 81.5", FUNC(sqrt) (6642.25), 81.5);
2495   check_eps ("sqrt (15239.903) == 123.45", FUNC(sqrt) (15239.903), 123.45,
2496              CHOOSE (3e-6L, 3e-6, 8e-6));
2497   check_eps ("sqrt (0.7) == 0.8366600265", FUNC(sqrt) (0.7),
2498              0.83666002653407554798L, CHOOSE(3e-17L, 0, 0));
2499 }
2500
2501 static void
2502 remainder_test (void)
2503 {
2504   MATHTYPE result;
2505
2506   result = FUNC(remainder) (1, 0);
2507   check_isnan_exc ("remainder(1, +0) == NaN plus invalid exception",
2508                    result, INVALID_EXCEPTION);
2509
2510   result = FUNC(remainder) (1, minus_zero);
2511   check_isnan_exc ("remainder(1, -0) == NaN plus invalid exception",
2512                    result, INVALID_EXCEPTION);
2513
2514   result = FUNC(remainder) (plus_infty, 1);
2515   check_isnan_exc ("remainder(+inf, 1) == NaN plus invalid exception",
2516                    result, INVALID_EXCEPTION);
2517
2518   result = FUNC(remainder) (minus_infty, 1);
2519   check_isnan_exc ("remainder(-inf, 1) == NaN plus invalid exception",
2520                    result, INVALID_EXCEPTION);
2521
2522   result = FUNC(remainder) (1.625, 1.0);
2523   check ("remainder(1.625, 1.0) == -0.375", result, -0.375);
2524
2525   result = FUNC(remainder) (-1.625, 1.0);
2526   check ("remainder(-1.625, 1.0) == 0.375", result, 0.375);
2527
2528   result = FUNC(remainder) (1.625, -1.0);
2529   check ("remainder(1.625, -1.0) == -0.375", result, -0.375);
2530
2531   result = FUNC(remainder) (-1.625, -1.0);
2532   check ("remainder(-1.625, -1.0) == 0.375", result, 0.375);
2533
2534   result = FUNC(remainder) (5.0, 2.0);
2535   check ("remainder(5.0, 2.0) == 1.0", result, 1.0);
2536
2537   result = FUNC(remainder) (3.0, 2.0);
2538   check ("remainder(3.0, 2.0) == -1.0", result, -1.0);
2539 }
2540
2541
2542 static void
2543 remquo_test (void)
2544 {
2545   int quo;
2546   MATHTYPE result;
2547
2548   result = FUNC(remquo) (1, 0, &quo);
2549   check_isnan_exc ("remquo(1, +0, &x) == NaN plus invalid exception",
2550                    result, INVALID_EXCEPTION);
2551
2552   result = FUNC(remquo) (1, minus_zero, &quo);
2553   check_isnan_exc ("remquo(1, -0, &x) == NaN plus invalid exception",
2554                    result, INVALID_EXCEPTION);
2555
2556   result = FUNC(remquo) (plus_infty, 1, &quo);
2557   check_isnan_exc ("remquo(+inf, 1, &x) == NaN plus invalid exception",
2558                    result, INVALID_EXCEPTION);
2559
2560   result = FUNC(remquo) (minus_infty, 1, &quo);
2561   check_isnan_exc ("remquo(-inf, 1, &x) == NaN plus invalid exception",
2562                    result, INVALID_EXCEPTION);
2563
2564   result = FUNC(remquo) (1.625, 1.0, &quo);
2565   check ("remquo(1.625, 1.0, &x) == -0.375", result, -0.375);
2566   check_long ("remquo(1.625, 1.0, &x) puts 2 in x", quo, 2);
2567
2568   result = FUNC(remquo) (-1.625, 1.0, &quo);
2569   check ("remquo(-1.625, 1.0, &x) == 0.375", result, 0.375);
2570   check_long ("remquo(-1.625, 1.0, &x) puts -2 in x", quo, -2);
2571
2572   result = FUNC(remquo) (1.625, -1.0, &quo);
2573   check ("remquo(1.625, -1.0, &x) == -0.375", result, -0.375);
2574   check_long ("remquo(1.625, -1.0, &x) puts -2 in x", quo, -2);
2575
2576   result = FUNC(remquo) (-1.625, -1.0, &quo);
2577   check ("remquo(-1.625, -1.0, &x) == 0.375", result, 0.375);
2578   check_long ("remquo(-1.625, -1.0, &x) puts 2 in x", quo, 2);
2579
2580   result = FUNC(remquo) (5.0, 2.0, &quo);
2581   check ("remquo(5.0, 2.0, &x) == 1.0", result, 1.0);
2582   check_long ("remquo (5.0, 2.0, &x) puts 2 in x", quo, 2);
2583
2584   result = FUNC(remquo) (3.0, 2.0, &quo);
2585   check ("remquo(3.0, 2.0, &x) == -1.0", result, -1.0);
2586   check_long ("remquo (3.0, 2.0, &x) puts 2 in x", quo, 2);
2587 }
2588
2589
2590 static void
2591 cexp_test (void)
2592 {
2593   __complex__ MATHTYPE result;
2594
2595   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, plus_zero));
2596   check ("real(cexp(0 + 0i)) = 1", __real__ result, 1);
2597   check ("imag(cexp(0 + 0i)) = 0", __imag__ result, 0);
2598   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_zero));
2599   check ("real(cexp(-0 + 0i)) = 1", __real__ result, 1);
2600   check ("imag(cexp(-0 + 0i)) = 0", __imag__ result, 0);
2601   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, minus_zero));
2602   check ("real(cexp(0 - 0i)) = 1", __real__ result, 1);
2603   check ("imag(cexp(0 - 0i)) = -0", __imag__ result, minus_zero);
2604   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_zero));
2605   check ("real(cexp(-0 - 0i)) = 1", __real__ result, 1);
2606   check ("imag(cexp(-0 - 0i)) = -0", __imag__ result, minus_zero);
2607
2608   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_zero));
2609   check_isinfp ("real(cexp(+inf + 0i)) = +inf", __real__ result);
2610   check ("imag(cexp(+inf + 0i)) = 0", __imag__ result, 0);
2611   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_zero));
2612   check_isinfp ("real(cexp(+inf - 0i)) = +inf", __real__ result);
2613   check ("imag(cexp(+inf - 0i)) = -0", __imag__ result, minus_zero);
2614
2615   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_zero));
2616   check ("real(cexp(-inf + 0i)) = 0", __real__ result, 0);
2617   check ("imag(cexp(-inf + 0i)) = 0", __imag__ result, 0);
2618   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_zero));
2619   check ("real(cexp(-inf - 0i)) = 0", __real__ result, 0);
2620   check ("imag(cexp(-inf - 0i)) = -0", __imag__ result, minus_zero);
2621
2622
2623   result = FUNC(cexp) (BUILD_COMPLEX (0.0, plus_infty));
2624   check_isnan_exc ("real(cexp(0 + i inf)) = NaN plus invalid exception",
2625                    __real__ result, INVALID_EXCEPTION);
2626   check_isnan ("imag(cexp(0 + i inf)) = NaN plus invalid exception",
2627                __imag__ result);
2628
2629 #if defined __GNUC__ && __GNUC__ <= 2 && __GNUC_MINOR__ <= 7
2630   if (verbose)
2631     printf ("The following test for cexp might fail due to a gcc compiler error!\n");
2632 #endif
2633
2634   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_infty));
2635   check_isnan_exc ("real(cexp(-0 + i inf)) = NaN plus invalid exception",
2636                    __real__ result, INVALID_EXCEPTION);
2637   check_isnan ("imag(cexp(-0 + i inf)) = NaN plus invalid exception",
2638                __imag__ result);
2639   result = FUNC(cexp) (BUILD_COMPLEX (0.0, minus_infty));
2640   check_isnan_exc ("real(cexp(0 - i inf)) = NaN plus invalid exception",
2641                    __real__ result, INVALID_EXCEPTION);
2642   check_isnan ("imag(cexp(0 - i inf)) = NaN plus invalid exception",
2643                __imag__ result);
2644   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_infty));
2645   check_isnan_exc ("real(cexp(-0 - i inf)) = NaN plus invalid exception",
2646                    __real__ result, INVALID_EXCEPTION);
2647   check_isnan ("imag(cexp(-0 - i inf)) = NaN plus invalid exception",
2648                __imag__ result);
2649
2650   result = FUNC(cexp) (BUILD_COMPLEX (100.0, plus_infty));
2651   check_isnan_exc ("real(cexp(100.0 + i inf)) = NaN plus invalid exception",
2652                    __real__ result, INVALID_EXCEPTION);
2653   check_isnan ("imag(cexp(100.0 + i inf)) = NaN plus invalid exception",
2654                __imag__ result);
2655   result = FUNC(cexp) (BUILD_COMPLEX (-100.0, plus_infty));
2656   check_isnan_exc ("real(cexp(-100.0 + i inf)) = NaN plus invalid exception",
2657                    __real__ result, INVALID_EXCEPTION);
2658   check_isnan ("imag(cexp(-100.0 + i inf)) = NaN plus invalid exception",
2659                __imag__ result);
2660   result = FUNC(cexp) (BUILD_COMPLEX (100.0, minus_infty));
2661   check_isnan_exc ("real(cexp(100.0 - i inf)) = NaN plus invalid exception",
2662                    __real__ result, INVALID_EXCEPTION);
2663   check_isnan ("imag(cexp(100.0 - i inf)) = NaN plus invalid exception",
2664                __imag__ result);
2665   result = FUNC(cexp) (BUILD_COMPLEX (-100.0, minus_infty));
2666   check_isnan_exc ("real(cexp(-100.0 - i inf)) = NaN plus invalid exception",
2667                    __real__ result, INVALID_EXCEPTION);
2668   check_isnan ("imag(cexp(-100.0 - i inf)) = NaN", __imag__ result);
2669
2670   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 2.0));
2671   check ("real(cexp(-inf + 2.0i)) = -0", __real__ result, minus_zero);
2672   check ("imag(cexp(-inf + 2.0i)) = 0", __imag__ result, 0);
2673   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 4.0));
2674   check ("real(cexp(-inf + 4.0i)) = -0", __real__ result, minus_zero);
2675   check ("imag(cexp(-inf + 4.0i)) = -0", __imag__ result, minus_zero);
2676
2677   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 2.0));
2678   check_isinfn ("real(cexp(+inf + 2.0i)) = -inf", __real__ result);
2679   check_isinfp ("imag(cexp(+inf + 2.0i)) = +inf", __imag__ result);
2680   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 4.0));
2681   check_isinfn ("real(cexp(+inf + 4.0i)) = -inf", __real__ result);
2682   check_isinfn ("imag(cexp(+inf + 4.0i)) = -inf", __imag__ result);
2683
2684   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_infty));
2685   check_isinfp_exc ("real(cexp(+inf + i inf)) = +inf plus invalid exception",
2686                     __real__ result, INVALID_EXCEPTION);
2687   check_isnan ("imag(cexp(+inf + i inf)) = NaN plus invalid exception",
2688                __imag__ result);
2689   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_infty));
2690   check_isinfp_exc ("real(cexp(+inf - i inf)) = +inf plus invalid exception",
2691                     __real__ result, INVALID_EXCEPTION);
2692   check_isnan ("imag(cexp(+inf - i inf)) = NaN plus invalid exception",
2693                __imag__ result);
2694
2695   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_infty));
2696   check ("real(cexp(-inf + i inf)) = 0", __real__ result, 0);
2697   check ("imag(cexp(-inf + i inf)) = 0", __imag__ result, 0);
2698   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_infty));
2699   check ("real(cexp(-inf - i inf)) = 0", __real__ result, 0);
2700   check ("imag(cexp(-inf - i inf)) = -0", __imag__ result, minus_zero);
2701
2702   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, nan_value));
2703   check ("real(cexp(-inf + i NaN)) = 0", __real__ result, 0);
2704   check ("imag(cexp(-inf + i NaN)) = 0", fabs (__imag__ result), 0);
2705
2706   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, nan_value));
2707   check_isinfp ("real(cexp(+inf + i NaN)) = +inf", __real__ result);
2708   check_isnan ("imag(cexp(+inf + i NaN)) = NaN", __imag__ result);
2709
2710   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 0.0));
2711   check_isnan_maybe_exc ("real(cexp(NaN + i0)) = NaN plus maybe invalid exception",
2712                          __real__ result, INVALID_EXCEPTION);
2713   check_isnan ("imag(cexp(NaN + i0)) = NaN plus maybe invalid exception",
2714                __imag__ result);
2715   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0));
2716   check_isnan_maybe_exc ("real(cexp(NaN + 1i)) = NaN plus maybe invalid exception",
2717                          __real__ result, INVALID_EXCEPTION);
2718   check_isnan ("imag(cexp(NaN + 1i)) = NaN plus maybe invalid exception",
2719                __imag__ result);
2720   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, plus_infty));
2721   check_isnan_maybe_exc ("real(cexp(NaN + i inf)) = NaN plus maybe invalid exception",
2722                          __real__ result, INVALID_EXCEPTION);
2723   check_isnan ("imag(cexp(NaN + i inf)) = NaN plus maybe invalid exception",
2724                __imag__ result);
2725
2726   result = FUNC(cexp) (BUILD_COMPLEX (0, nan_value));
2727   check_isnan_maybe_exc ("real(cexp(0 + i NaN)) = NaN plus maybe invalid exception",
2728                          __real__ result, INVALID_EXCEPTION);
2729   check_isnan ("imag(cexp(0 + i NaN)) = NaN plus maybe invalid exception",
2730                __imag__ result);
2731   result = FUNC(cexp) (BUILD_COMPLEX (1, nan_value));
2732   check_isnan_maybe_exc ("real(cexp(1 + i NaN)) = NaN plus maybe invalid exception",
2733                          __real__ result, INVALID_EXCEPTION);
2734   check_isnan ("imag(cexp(1 + i NaN)) = NaN plus maybe invalid exception",
2735                __imag__ result);
2736
2737   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, nan_value));
2738   check_isnan ("real(cexp(NaN + i NaN)) = NaN", __real__ result);
2739   check_isnan ("imag(cexp(NaN + i NaN)) = NaN", __imag__ result);
2740
2741   result = FUNC(cexp) (BUILD_COMPLEX (0.7, 1.2));
2742   check_eps ("real(cexp(0.7 + i 1.2)) == 0.72969...", __real__ result,
2743              0.7296989091503236012L, CHOOSE(6e-17L, 2e-16, 2e-7));
2744   check_eps ("imag(cexp(0.7 + i 1.2)) == 1.87689...", __imag__ result,
2745              1.8768962328348102821L, CHOOSE(2e-16L, 0, 3e-7));
2746
2747   result = FUNC(cexp) (BUILD_COMPLEX (-2, -3));
2748   check_eps ("real(cexp(-2 - i 3)) == -0.13398...", __real__ result,
2749              -0.1339809149295426134L, CHOOSE(6e-20L, 0, 2e-8));
2750   check_eps ("imag(cexp(-2 - i 3)) == -0.01909...", __imag__ result,
2751              -0.0190985162611351964L, CHOOSE(4e-20L, 0, 2e-9));
2752 }
2753
2754
2755 static void
2756 csin_test (void)
2757 {
2758   __complex__ MATHTYPE result;
2759
2760   result = FUNC(csin) (BUILD_COMPLEX (0.0, 0.0));
2761   check ("real(csin(0 + 0i)) = 0", __real__ result, 0);
2762   check ("imag(csin(0 + 0i)) = 0", __imag__ result, 0);
2763   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, 0.0));
2764   check ("real(csin(-0 + 0i)) = -0", __real__ result, minus_zero);
2765   check ("imag(csin(-0 + 0i)) = 0", __imag__ result, 0);
2766   result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_zero));
2767   check ("real(csin(0 - 0i)) = 0", __real__ result, 0);
2768   check ("imag(csin(0 - 0i)) = -0", __imag__ result, minus_zero);
2769   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_zero));
2770   check ("real(csin(-0 - 0i)) = -0", __real__ result, minus_zero);
2771   check ("imag(csin(-0 - 0i)) = -0", __imag__ result, minus_zero);
2772
2773   result = FUNC(csin) (BUILD_COMPLEX (0.0, plus_infty));
2774   check ("real(csin(0 + i Inf)) = 0", __real__ result, 0);
2775   check_isinfp ("imag(csin(0 + i Inf)) = +Inf", __imag__ result);
2776   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, plus_infty));
2777   check ("real(csin(-0 + i Inf)) = -0", __real__ result, minus_zero);
2778   check_isinfp ("imag(csin(-0 + i Inf)) = +Inf", __imag__ result);
2779   result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_infty));
2780   check ("real(csin(0 - i Inf)) = 0", __real__ result, 0);
2781   check_isinfn ("imag(csin(0 - i Inf)) = -Inf", __imag__ result);
2782   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_infty));
2783   check ("real(csin(-0 - i Inf)) = -0", __real__ result, minus_zero);
2784   check_isinfn("imag(csin(-0 - i Inf)) = -Inf", __imag__ result);
2785
2786   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 0.0));
2787   check_isnan_exc ("real(csin(+Inf + 0i)) = NaN plus invalid exception",
2788                    __real__ result, INVALID_EXCEPTION);
2789   check ("imag(csin(+Inf + 0i)) = +-0 plus invalid exception",
2790          FUNC(fabs) (__imag__ result), 0);
2791   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 0.0));
2792   check_isnan_exc ("real(csin(-Inf + 0i)) = NaN plus invalid exception",
2793                    __real__ result, INVALID_EXCEPTION);
2794   check ("imag(csin(-Inf + 0i)) = +-0 plus invalid exception",
2795          FUNC(fabs) (__imag__ result), 0);
2796   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_zero));
2797   check_isnan_exc ("real(csin(+Inf - 0i)) = NaN plus invalid exception",
2798                    __real__ result, INVALID_EXCEPTION);
2799   check ("imag(csin(+Inf - 0i)) = +-0 plus invalid exception",
2800          FUNC(fabs) (__imag__ result), 0.0);
2801   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_zero));
2802   check_isnan_exc ("real(csin(-Inf - 0i)) = NaN plus invalid exception",
2803                    __real__ result, INVALID_EXCEPTION);
2804   check ("imag(csin(-Inf - 0i)) = +-0 plus invalid exception",
2805          FUNC(fabs) (__imag__ result), 0.0);
2806
2807   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, plus_infty));
2808   check_isnan_exc ("real(csin(+Inf + i Inf)) = NaN plus invalid exception",
2809                    __real__ result, INVALID_EXCEPTION);
2810   check_isinfp ("imag(csin(+Inf + i Inf)) = +-Inf plus invalid exception",
2811                 FUNC(fabs) (__imag__ result));
2812   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, plus_infty));
2813   check_isnan_exc ("real(csin(-Inf + i Inf)) = NaN plus invalid exception",
2814                    __real__ result, INVALID_EXCEPTION);
2815   check_isinfp ("imag(csin(-Inf + i Inf)) = +-Inf plus invalid exception",
2816                 FUNC(fabs) (__imag__ result));
2817   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_infty));
2818   check_isnan_exc ("real(csin(Inf - i Inf)) = NaN plus invalid exception",
2819                    __real__ result, INVALID_EXCEPTION);
2820   check_isinfp ("imag(csin(Inf - i Inf)) = +-Inf plus invalid exception",
2821                 FUNC(fabs) (__imag__ result));
2822   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_infty));
2823   check_isnan_exc ("real(csin(-Inf - i Inf)) = NaN plus invalid exception",
2824                    __real__ result, INVALID_EXCEPTION);
2825   check_isinfp ("imag(csin(-Inf - i Inf)) = +-Inf plus invalid exception",
2826                 FUNC(fabs) (__imag__ result));
2827
2828   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 6.75));
2829   check_isnan_exc ("real(csin(+Inf + i 6.75)) = NaN plus invalid exception",
2830                    __real__ result, INVALID_EXCEPTION);
2831   check_isnan ("imag(csin(+Inf + i6.75)) = NaN plus invalid exception",
2832                __imag__ result);
2833   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, -6.75));
2834   check_isnan_exc ("real(csin(+Inf - i 6.75)) = NaN plus invalid exception",
2835                    __real__ result, INVALID_EXCEPTION);
2836   check_isnan ("imag(csin(+Inf - i6.75)) = NaN plus invalid exception",
2837                __imag__ result);
2838   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 6.75));
2839   check_isnan_exc ("real(csin(-Inf + i6.75)) = NaN plus invalid exception",
2840                    __real__ result, INVALID_EXCEPTION);
2841   check_isnan ("imag(csin(-Inf + i6.75)) = NaN plus invalid exception",
2842                __imag__ result);
2843   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, -6.75));
2844   check_isnan_exc ("real(csin(-Inf - i6.75)) = NaN plus invalid exception",
2845                    __real__ result, INVALID_EXCEPTION);
2846   check_isnan ("imag(csin(-Inf - i6.75)) = NaN plus invalid exception",
2847                __imag__ result);
2848
2849   result = FUNC(csin) (BUILD_COMPLEX (4.625, plus_infty));
2850   check_isinfn ("real(csin(4.625 + i Inf)) = -Inf", __real__ result);
2851   check_isinfn ("imag(csin(4.625 + i Inf)) = -Inf", __imag__ result);
2852   result = FUNC(csin) (BUILD_COMPLEX (4.625, minus_infty));
2853   check_isinfn ("real(csin(4.625 - i Inf)) = -Inf", __real__ result);
2854   check_isinfp ("imag(csin(4.625 - i Inf)) = +Inf", __imag__ result);
2855   result = FUNC(csin) (BUILD_COMPLEX (-4.625, plus_infty));
2856   check_isinfp ("real(csin(-4.625 + i Inf)) = +Inf", __real__ result);
2857   check_isinfn ("imag(csin(-4.625 + i Inf)) = -Inf", __imag__ result);
2858   result = FUNC(csin) (BUILD_COMPLEX (-4.625, minus_infty));
2859   check_isinfp ("real(csin(-4.625 - i Inf)) = +Inf", __real__ result);
2860   check_isinfp ("imag(csin(-4.625 - i Inf)) = +Inf", __imag__ result);
2861
2862   result = FUNC(csin) (BUILD_COMPLEX (nan_value, 0.0));
2863   check_isnan ("real(csin(NaN + i0)) = NaN", __real__ result);
2864   check ("imag(csin(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
2865   result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_zero));
2866   check_isnan ("real(csin(NaN - i0)) = NaN", __real__ result);
2867   check ("imag(csin(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
2868
2869   result = FUNC(csin) (BUILD_COMPLEX (nan_value, plus_infty));
2870   check_isnan ("real(csin(NaN + i Inf)) = NaN", __real__ result);
2871   check_isinfp ("imag(csin(NaN + i Inf)) = +-Inf",
2872                 FUNC(fabs) (__imag__ result));
2873   result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_infty));
2874   check_isnan ("real(csin(NaN - i Inf)) = NaN", __real__ result);
2875   check_isinfp ("real(csin(NaN - i Inf)) = +-Inf",
2876                 FUNC(fabs) (__imag__ result));
2877
2878   result = FUNC(csin) (BUILD_COMPLEX (nan_value, 9.0));
2879   check_isnan_maybe_exc ("real(csin(NaN + i9.0)) = NaN plus maybe invalid exception",
2880                          __real__ result, INVALID_EXCEPTION);
2881   check_isnan ("imag(csin(NaN + i9.0)) = NaN plus maybe invalid exception",
2882                __imag__ result);
2883   result = FUNC(csin) (BUILD_COMPLEX (nan_value, -9.0));
2884   check_isnan_maybe_exc ("real(csin(NaN - i9.0)) = NaN plus maybe invalid exception",
2885                          __real__ result, INVALID_EXCEPTION);
2886   check_isnan ("imag(csin(NaN - i9.0)) = NaN plus maybe invalid exception",
2887                __imag__ result);
2888
2889   result = FUNC(csin) (BUILD_COMPLEX (0.0, nan_value));
2890   check ("real(csin(0 + i NaN))", __real__ result, 0.0);
2891   check_isnan ("imag(csin(0 + i NaN)) = NaN", __imag__ result);
2892   result = FUNC(csin) (BUILD_COMPLEX (minus_zero, nan_value));
2893   check ("real(csin(-0 + i NaN)) = -0", __real__ result, minus_zero);
2894   check_isnan ("imag(csin(-0 + NaN)) = NaN", __imag__ result);
2895
2896   result = FUNC(csin) (BUILD_COMPLEX (10.0, nan_value));
2897   check_isnan_maybe_exc ("real(csin(10 + i NaN)) = NaN plus maybe invalid exception",
2898                          __real__ result, INVALID_EXCEPTION);
2899   check_isnan ("imag(csin(10 + i NaN)) = NaN plus maybe invalid exception",
2900                __imag__ result);
2901   result = FUNC(csin) (BUILD_COMPLEX (nan_value, -10.0));
2902   check_isnan_maybe_exc ("real(csin(-10 + i NaN)) = NaN plus maybe invalid exception",
2903                          __real__ result, INVALID_EXCEPTION);
2904   check_isnan ("imag(csin(-10 + i NaN)) = NaN plus maybe invalid exception",
2905                __imag__ result);
2906
2907   result = FUNC(csin) (BUILD_COMPLEX (plus_infty, nan_value));
2908   check_isnan_maybe_exc ("real(csin(+Inf + i NaN)) = NaN plus maybe invalid exception",
2909                          __real__ result, INVALID_EXCEPTION);
2910   check_isnan ("imag(csin(+Inf + i NaN)) = NaN plus maybe invalid exception",
2911                __imag__ result);
2912   result = FUNC(csin) (BUILD_COMPLEX (minus_infty, nan_value));
2913   check_isnan_maybe_exc ("real(csin(-Inf + i NaN)) = NaN plus maybe invalid exception",
2914                          __real__ result, INVALID_EXCEPTION);
2915   check_isnan ("imag(csin(-Inf + i NaN)) = NaN plus maybe invalid exception",
2916                __imag__ result);
2917
2918   result = FUNC(csin) (BUILD_COMPLEX (nan_value, nan_value));
2919   check_isnan ("real(csin(NaN + i NaN)) = NaN", __real__ result);
2920   check_isnan ("imag(csin(NaN + i NaN)) = NaN", __imag__ result);
2921
2922   result = FUNC(csin) (BUILD_COMPLEX (0.7, 1.2));
2923   check_eps ("real(csin(0.7 + i 1.2)) = 1.166456341...", __real__ result,
2924              1.1664563419657581376L, CHOOSE(2e-16L, 0, 0));
2925   check_eps ("imag(csin(0.7 + i 1.2)) = 1.154499724...", __imag__ result,
2926              1.1544997246948547371L, CHOOSE(2e-17L, 0, 2e-7));
2927
2928   result = FUNC(csin) (BUILD_COMPLEX (-2, -3));
2929   check_eps ("real(csin(-2 - i 3)) == -9.15449...", __real__ result,
2930              -9.1544991469114295734L, CHOOSE(4e-18L, 0, 1e-6));
2931   check_eps ("imag(csin(-2 - i 3)) == -4.16890...", __imag__ result,
2932              4.1689069599665643507L, CHOOSE(2e-17L, 0, 5e-7));
2933 }
2934
2935
2936 static void
2937 csinh_test (void)
2938 {
2939   __complex__ MATHTYPE result;
2940
2941   result = FUNC(csinh) (BUILD_COMPLEX (0.0, 0.0));
2942   check ("real(csinh(0 + 0i)) = 0", __real__ result, 0);
2943   check ("imag(csinh(0 + 0i)) = 0", __imag__ result, 0);
2944   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, 0.0));
2945   check ("real(csinh(-0 + 0i)) = -0", __real__ result, minus_zero);
2946   check ("imag(csinh(-0 + 0i)) = 0", __imag__ result, 0);
2947   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_zero));
2948   check ("real(csinh(0 - 0i)) = 0", __real__ result, 0);
2949   check ("imag(csinh(0 - 0i)) = -0", __imag__ result, minus_zero);
2950   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_zero));
2951   check ("real(csinh(-0 - 0i)) = -0", __real__ result, minus_zero);
2952   check ("imag(csinh(-0 - 0i)) = -0", __imag__ result, minus_zero);
2953
2954   result = FUNC(csinh) (BUILD_COMPLEX (0.0, plus_infty));
2955   check_exc ("real(csinh(0 + i Inf)) = +-0 plus invalid exception",
2956              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2957   check_isnan ("imag(csinh(0 + i Inf)) = NaN plus invalid exception",
2958                __imag__ result);
2959   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, plus_infty));
2960   check_exc ("real(csinh(-0 + i Inf)) = +-0 plus invalid exception",
2961              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2962   check_isnan ("imag(csinh(-0 + i Inf)) = NaN plus invalid exception",
2963                __imag__ result);
2964   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_infty));
2965   check_exc ("real(csinh(0 - i Inf)) = +-0 plus invalid exception",
2966              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2967   check_isnan ("imag(csinh(0 - i Inf)) = NaN plus invalid exception",
2968                __imag__ result);
2969   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_infty));
2970   check_exc ("real(csinh(-0 - i Inf)) = +-0 plus invalid exception",
2971              FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION);
2972   check_isnan ("imag(csinh(-0 - i Inf)) = NaN plus invalid exception",
2973                __imag__ result);
2974
2975   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 0.0));
2976   check_isinfp ("real(csinh(+Inf + 0i)) = +Inf", __real__ result);
2977   check ("imag(csinh(+Inf + 0i)) = 0", __imag__ result, 0);
2978   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 0.0));
2979   check_isinfn ("real(csinh(-Inf + 0i)) = -Inf", __real__ result);
2980   check ("imag(csinh(-Inf + 0i)) = 0", __imag__ result, 0);
2981   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_zero));
2982   check_isinfp ("real(csinh(+Inf - 0i)) = +Inf", __real__ result);
2983   check ("imag(csinh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
2984   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_zero));
2985   check_isinfn ("real(csinh(-Inf - 0i)) = -Inf", __real__ result);
2986   check ("imag(csinh(-Inf - 0i)) = -0", __imag__ result, minus_zero);
2987
2988   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, plus_infty));
2989   check_isinfp_exc ("real(csinh(+Inf + i Inf)) = +-Inf plus invalid exception",
2990                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
2991   check_isnan ("imag(csinh(+Inf + i Inf)) = NaN plus invalid exception",
2992                __imag__ result);
2993   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, plus_infty));
2994   check_isinfp_exc ("real(csinh(-Inf + i Inf)) = +-Inf plus invalid exception",
2995                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
2996   check_isnan ("imag(csinh(-Inf + i Inf)) = NaN plus invalid exception",
2997                __imag__ result);
2998   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_infty));
2999   check_isinfp_exc ("real(csinh(Inf - i Inf)) = +-Inf plus invalid exception",
3000                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
3001   check_isnan ("imag(csinh(Inf - i Inf)) = NaN plus invalid exception",
3002                __imag__ result);
3003   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_infty));
3004   check_isinfp_exc ("real(csinh(-Inf - i Inf)) = +-Inf plus invalid exception",
3005                     FUNC(fabs) (__real__ result), INVALID_EXCEPTION);
3006   check_isnan ("imag(csinh(-Inf - i Inf)) = NaN plus invalid exception",
3007                __imag__ result);
3008
3009   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 4.625));
3010   check_isinfn ("real(csinh(+Inf + i4.625)) = -Inf", __real__ result);
3011   check_isinfn ("imag(csinh(+Inf + i4.625)) = -Inf", __imag__ result);
3012   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 4.625));
3013   check_isinfp ("real(csinh(-Inf + i4.625)) = +Inf", __real__ result);
3014   check_isinfn ("imag(csinh(-Inf + i4.625)) = -Inf", __imag__ result);
3015   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, -4.625));
3016   check_isinfn ("real(csinh(+Inf - i4.625)) = -Inf", __real__ result);
3017   check_isinfp ("imag(csinh(+Inf - i4.625)) = +Inf", __imag__ result);
3018   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, -4.625));
3019   check_isinfp ("real(csinh(-Inf - i4.625)) = +Inf", __real__ result);
3020   check_isinfp ("imag(csinh(-Inf - i4.625)) = +Inf", __imag__ result);
3021
3022   result = FUNC(csinh) (BUILD_COMPLEX (6.75, plus_infty));
3023   check_isnan_exc ("real(csinh(6.75 + i Inf)) = NaN plus invalid exception",
3024                    __real__ result, INVALID_EXCEPTION);
3025   check_isnan ("imag(csinh(6.75 + i Inf)) = NaN plus invalid exception",
3026                __imag__ result);
3027   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, plus_infty));
3028   check_isnan_exc ("real(csinh(-6.75 + i Inf)) = NaN plus invalid exception",
3029                    __real__ result, INVALID_EXCEPTION);
3030   check_isnan ("imag(csinh(-6.75 + i Inf)) = NaN plus invalid exception",
3031                __imag__ result);
3032   result = FUNC(csinh) (BUILD_COMPLEX (6.75, minus_infty));
3033   check_isnan_exc ("real(csinh(6.75 - i Inf)) = NaN plus invalid exception",
3034                    __real__ result, INVALID_EXCEPTION);
3035   check_isnan ("imag(csinh(6.75 - i Inf)) = NaN plus invalid exception",
3036                __imag__ result);
3037   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, minus_infty));
3038   check_isnan_exc ("real(csinh(-6.75 - i Inf)) = NaN plus invalid exception",
3039                    __real__ result, INVALID_EXCEPTION);
3040   check_isnan ("imag(csinh(-6.75 - i Inf)) = NaN plus invalid exception",
3041                __imag__ result);
3042
3043   result = FUNC(csinh) (BUILD_COMPLEX (0.0, nan_value));
3044   check ("real(csinh(0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0);
3045   check_isnan ("imag(csinh(0 + i NaN)) = NaN", __imag__ result);
3046   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, nan_value));
3047   check ("real(csinh(-0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0);
3048   check_isnan ("imag(csinh(-0 + i NaN)) = NaN", __imag__ result);
3049
3050   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, nan_value));
3051   check_isinfp ("real(csinh(+Inf + i NaN)) = +-Inf",
3052                 FUNC(fabs) (__real__ result));
3053   check_isnan ("imag(csinh(+Inf + i NaN)) = NaN", __imag__ result);
3054   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, nan_value));
3055   check_isinfp ("real(csinh(-Inf + i NaN)) = +-Inf",
3056                 FUNC(fabs) (__real__ result));
3057   check_isnan ("imag(csinh(-Inf + i NaN)) = NaN", __imag__ result);
3058
3059   result = FUNC(csinh) (BUILD_COMPLEX (9.0, nan_value));
3060   check_isnan_maybe_exc ("real(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3061                          __real__ result, INVALID_EXCEPTION);
3062   check_isnan ("imag(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3063                __imag__ result);
3064   result = FUNC(csinh) (BUILD_COMPLEX (-9.0, nan_value));
3065   check_isnan_maybe_exc ("real(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3066                          __real__ result, INVALID_EXCEPTION);
3067   check_isnan ("imag(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3068                __imag__ result);
3069
3070   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 0.0));
3071   check_isnan ("real(csinh(NaN + i0)) = NaN", __real__ result);
3072   check ("imag(csinh(NaN + i0)) = 0", __imag__ result, 0.0);
3073   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_zero));
3074   check_isnan ("real(csinh(NaN - i0)) = NaN", __real__ result);
3075   check ("imag(csinh(NaN - i0)) = -0", __imag__ result, minus_zero);
3076
3077   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 10.0));
3078   check_isnan_maybe_exc ("real(csinh(NaN + i10)) = NaN plus maybe invalid exception",
3079                          __real__ result, INVALID_EXCEPTION);
3080   check_isnan ("imag(csinh(NaN + i10)) = NaN plus maybe invalid exception",
3081                __imag__ result);
3082   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, -10.0));
3083   check_isnan_maybe_exc ("real(csinh(NaN - i10)) = NaN plus maybe invalid exception",
3084                          __real__ result, INVALID_EXCEPTION);
3085   check_isnan ("imag(csinh(NaN - i10)) = NaN plus maybe invalid exception",
3086                __imag__ result);
3087
3088   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, plus_infty));
3089   check_isnan_maybe_exc ("real(csinh(NaN + i Inf)) = NaN plus maybe invalid exception",
3090                          __real__ result, INVALID_EXCEPTION);
3091   check_isnan ("imag(csinh(NaN + i Inf)) = NaN plus maybe invalid exception",
3092                __imag__ result);
3093   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_infty));
3094   check_isnan_maybe_exc ("real(csinh(NaN - i Inf)) = NaN plus maybe invalid exception",
3095                          __real__ result, INVALID_EXCEPTION);
3096   check_isnan ("imag(csinh(NaN - i Inf)) = NaN plus maybe invalid exception",
3097                __imag__ result);
3098
3099   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, nan_value));
3100   check_isnan ("real(csinh(NaN + i NaN)) = NaN", __real__ result);
3101   check_isnan ("imag(csinh(NaN + i NaN)) = NaN", __imag__ result);
3102
3103   result = FUNC(csinh) (BUILD_COMPLEX (0.7, 1.2));
3104   check_eps ("real(csinh(0.7 + i 1.2)) = 0.274878686...", __real__ result,
3105              0.27487868678117583582L, CHOOSE(2e-17L, 6e-17, 3e-8));
3106   check_eps ("imag(csinh(0.7 + i 1.2)) = 1.169866572...", __imag__ result,
3107              1.1698665727426565139L, CHOOSE(6e-17L, 0, 2e-7));
3108
3109   result = FUNC(csinh) (BUILD_COMPLEX (-2, -3));
3110   check_eps ("real(csinh(-2 - i 3)) == -3.59056...", __real__ result,
3111              3.5905645899857799520L, CHOOSE(7e-19L, 5e-16, 3e-7));
3112   check_eps ("imag(csinh(-2 - i 3)) == -0.53092...", __imag__ result,
3113              -0.5309210862485198052L, CHOOSE(3e-19L, 2e-16, 6e-8));
3114 }
3115
3116
3117 static void
3118 ccos_test (void)
3119 {
3120   __complex__ MATHTYPE result;
3121
3122   result = FUNC(ccos) (BUILD_COMPLEX (0.0, 0.0));
3123   check ("real(ccos(0 + 0i)) = 1.0", __real__ result, 1.0);
3124   check ("imag(ccos(0 + 0i)) = -0", __imag__ result, minus_zero);
3125   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, 0.0));
3126   check ("real(ccos(-0 + 0i)) = 1.0", __real__ result, 1.0);
3127   check ("imag(ccos(-0 + 0i)) = 0", __imag__ result, 0.0);
3128   result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_zero));
3129   check ("real(ccos(0 - 0i)) = 1.0", __real__ result, 1.0);
3130   check ("imag(ccos(0 - 0i)) = 0", __imag__ result, 0.0);
3131   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_zero));
3132   check ("real(ccos(-0 - 0i)) = 1.0", __real__ result, 1.0);
3133   check ("imag(ccos(-0 - 0i)) = -0", __imag__ result, minus_zero);
3134
3135   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 0.0));
3136   check_isnan_exc ("real(ccos(+Inf + i0)) = NaN plus invalid exception",
3137                    __real__ result, INVALID_EXCEPTION);
3138   check ("imag(ccos(Inf + i0)) = +-0 plus invalid exception",
3139          FUNC(fabs) (__imag__ result), 0);
3140   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_zero));
3141   check_isnan_exc ("real(ccos(Inf - i0)) = NaN plus invalid exception",
3142                    __real__ result, INVALID_EXCEPTION);
3143   check ("imag(ccos(Inf - i0)) = +-0 plus invalid exception",
3144          FUNC(fabs) (__imag__ result), 0);
3145   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 0.0));
3146   check_isnan_exc ("real(ccos(-Inf + i0)) = NaN plus invalid exception",
3147                    __real__ result, INVALID_EXCEPTION);
3148   check ("imag(ccos(-Inf + i0)) = +-0 plus invalid exception",
3149          FUNC(fabs) (__imag__ result), 0);
3150   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_zero));
3151   check_isnan_exc ("real(ccos(-Inf - i0)) = NaN plus invalid exception",
3152                    __real__ result, INVALID_EXCEPTION);
3153   check ("imag(ccos(-Inf - i0)) = +-0 plus invalid exception",
3154          FUNC(fabs) (__imag__ result), 0);
3155
3156   result = FUNC(ccos) (BUILD_COMPLEX (0.0, plus_infty));
3157   check_isinfp ("real(ccos(0 + i Inf)) = +Inf", __real__ result);
3158   check ("imag(ccos(0 + i Inf)) = -0", __imag__ result, minus_zero);
3159   result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_infty));
3160   check_isinfp ("real(ccos(0 - i Inf)) = +Inf", __real__ result);
3161   check ("imag(ccos(0 - i Inf)) = 0", __imag__ result, 0);
3162   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, plus_infty));
3163   check_isinfp ("real(ccos(-0 + i Inf)) = +Inf", __real__ result);
3164   check ("imag(ccos(-0 + i Inf)) = 0", __imag__ result, 0.0);
3165   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_infty));
3166   check_isinfp ("real(ccos(-0 - i Inf)) = +Inf", __real__ result);
3167   check ("imag(ccos(-0 - i Inf)) = -0", __imag__ result, minus_zero);
3168
3169   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, plus_infty));
3170   check_isinfp_exc ("real(ccos(+Inf + i Inf)) = +Inf plus invalid exception",
3171                     __real__ result, INVALID_EXCEPTION);
3172   check_isnan ("imag(ccos(+Inf + i Inf)) = NaN plus invalid exception",
3173                __imag__ result);
3174   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, plus_infty));
3175   check_isinfp_exc ("real(ccos(-Inf + i Inf)) = +Inf plus invalid exception",
3176                     __real__ result, INVALID_EXCEPTION);
3177   check_isnan ("imag(ccos(-Inf + i Inf)) = NaN plus invalid exception",
3178                __imag__ result);
3179   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_infty));
3180   check_isinfp_exc ("real(ccos(Inf - i Inf)) = +Inf plus invalid exception",
3181                     __real__ result, INVALID_EXCEPTION);
3182   check_isnan ("imag(ccos(Inf - i Inf)) = NaN plus invalid exception",
3183                __imag__ result);
3184   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_infty));
3185   check_isinfp_exc ("real(ccos(-Inf - i Inf)) = +Inf plus invalid exception",
3186                     __real__ result, INVALID_EXCEPTION);
3187   check_isnan ("imag(ccos(-Inf - i Inf)) = NaN plus invalid exception",
3188                __imag__ result);
3189
3190   result = FUNC(ccos) (BUILD_COMPLEX (4.625, plus_infty));
3191   check_isinfn ("real(ccos(4.625 + i Inf)) = -Inf", __real__ result);
3192   check_isinfp ("imag(ccos(4.625 + i Inf)) = +Inf", __imag__ result);
3193   result = FUNC(ccos) (BUILD_COMPLEX (4.625, minus_infty));
3194   check_isinfn ("real(ccos(4.625 - i Inf)) = -Inf", __real__ result);
3195   check_isinfn ("imag(ccos(4.625 - i Inf)) = -Inf", __imag__ result);
3196   result = FUNC(ccos) (BUILD_COMPLEX (-4.625, plus_infty));
3197   check_isinfn ("real(ccos(-4.625 + i Inf)) = -Inf", __real__ result);
3198   check_isinfn ("imag(ccos(-4.625 + i Inf)) = -Inf", __imag__ result);
3199   result = FUNC(ccos) (BUILD_COMPLEX (-4.625, minus_infty));
3200   check_isinfn ("real(ccos(-4.625 - i Inf)) = -Inf", __real__ result);
3201   check_isinfp ("imag(ccos(-4.625 - i Inf)) = +Inf", __imag__ result);
3202
3203   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 6.75));
3204   check_isnan_exc ("real(ccos(+Inf + i6.75)) = NaN plus invalid exception",
3205                    __real__ result, INVALID_EXCEPTION);
3206   check_isnan ("imag(ccos(+Inf + i6.75)) = NaN plus invalid exception",
3207                __imag__ result);
3208   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, -6.75));
3209   check_isnan_exc ("real(ccos(+Inf - i6.75)) = NaN plus invalid exception",
3210                    __real__ result, INVALID_EXCEPTION);
3211   check_isnan ("imag(ccos(+Inf - i6.75)) = NaN plus invalid exception",
3212                __imag__ result);
3213   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 6.75));
3214   check_isnan_exc ("real(ccos(-Inf + i6.75)) = NaN plus invalid exception",
3215                    __real__ result, INVALID_EXCEPTION);
3216   check_isnan ("imag(ccos(-Inf + i6.75)) = NaN plus invalid exception",
3217                __imag__ result);
3218   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, -6.75));
3219   check_isnan_exc ("real(ccos(-Inf - i6.75)) = NaN plus invalid exception",
3220                    __real__ result, INVALID_EXCEPTION);
3221   check_isnan ("imag(ccos(-Inf - i6.75)) = NaN plus invalid exception",
3222                __imag__ result);
3223
3224   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 0.0));
3225   check_isnan ("real(ccos(NaN + i0)) = NaN", __real__ result);
3226   check ("imag(ccos(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
3227   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_zero));
3228   check_isnan ("real(ccos(NaN - i0)) = NaN", __real__ result);
3229   check ("imag(ccos(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0);
3230
3231   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, plus_infty));
3232   check_isinfp ("real(ccos(NaN + i Inf)) = +Inf", __real__ result);
3233   check_isnan ("imag(ccos(NaN + i Inf)) = NaN", __imag__ result);
3234   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_infty));
3235   check_isinfp ("real(ccos(NaN - i Inf)) = +Inf", __real__ result);
3236   check_isnan ("imag(ccos(NaN - i Inf)) = NaN", __imag__ result);
3237
3238   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 9.0));
3239   check_isnan_maybe_exc ("real(ccos(NaN + i9.0)) = NaN plus maybe invalid exception",
3240                          __real__ result, INVALID_EXCEPTION);
3241   check_isnan ("imag(ccos(NaN + i9.0)) = NaN plus maybe invalid exception",
3242                __imag__ result);
3243   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, -9.0));
3244   check_isnan_maybe_exc ("real(ccos(NaN - i9.0)) = NaN plus maybe invalid exception",
3245                          __real__ result, INVALID_EXCEPTION);
3246   check_isnan ("imag(ccos(NaN - i9.0)) = NaN plus maybe invalid exception",
3247                __imag__ result);
3248
3249   result = FUNC(ccos) (BUILD_COMPLEX (0.0, nan_value));
3250   check_isnan ("real(ccos(0 + i NaN)) = NaN", __real__ result);
3251   check ("imag(ccos(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3252   result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, nan_value));
3253   check_isnan ("real(ccos(-0 + i NaN)) = NaN", __real__ result);
3254   check ("imag(ccos(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3255
3256   result = FUNC(ccos) (BUILD_COMPLEX (10.0, nan_value));
3257   check_isnan_maybe_exc ("real(ccos(10 + i NaN)) = NaN plus maybe invalid exception",
3258                          __real__ result, INVALID_EXCEPTION);
3259   check_isnan ("imag(ccos(10 + i NaN)) = NaN plus maybe invalid exception",
3260                __imag__ result);
3261   result = FUNC(ccos) (BUILD_COMPLEX (-10.0, nan_value));
3262   check_isnan_maybe_exc ("real(ccos(-10 + i NaN)) = NaN plus maybe invalid exception",
3263                          __real__ result, INVALID_EXCEPTION);
3264   check_isnan ("imag(ccos(-10 + i NaN)) = NaN plus maybe invalid exception",
3265                __imag__ result);
3266
3267   result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, nan_value));
3268   check_isnan_maybe_exc ("real(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception",
3269                          __real__ result, INVALID_EXCEPTION);
3270   check_isnan ("imag(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception",
3271                __imag__ result);
3272   result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, nan_value));
3273   check_isnan_maybe_exc ("real(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception",
3274                          __real__ result, INVALID_EXCEPTION);
3275   check_isnan ("imag(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception",
3276                __imag__ result);
3277
3278   result = FUNC(ccos) (BUILD_COMPLEX (nan_value, nan_value));
3279   check_isnan ("real(ccos(NaN + i NaN)) = NaN", __real__ result);
3280   check_isnan ("imag(ccos(NaN + i NaN)) = NaN", __imag__ result);
3281
3282   result = FUNC(ccos) (BUILD_COMPLEX (0.7, 1.2));
3283   check_eps ("real(ccos(0.7 + i 1.2)) = 1.384865764...", __real__ result,
3284              1.3848657645312111080L, CHOOSE(4e-18L, 3e-16, 2e-7));
3285   check_eps ("imag(ccos(0.7 + i 1.2)) = -0.972421703...", __imag__ result,
3286              -0.97242170335830028619L, CHOOSE(2e-16L, 2e-16, 0));
3287
3288   result = FUNC(ccos) (BUILD_COMPLEX (-2, -3));
3289   check_eps ("real(ccos(-2 - i 3)) == -4.18962...", __real__ result,
3290              -4.1896256909688072301L, CHOOSE(2e-17L, 0, 5e-7));
3291   check_eps ("imag(ccos(-2 - i 3)) == -9.10922...", __imag__ result,
3292              -9.1092278937553365979L, CHOOSE(3e-18L, 0, 1e-6));
3293 }
3294
3295
3296 static void
3297 ccosh_test (void)
3298 {
3299   __complex__ MATHTYPE result;
3300
3301   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, 0.0));
3302   check ("real(ccosh(0 + 0i)) = 1.0", __real__ result, 1.0);
3303   check ("imag(ccosh(0 + 0i)) = 0", __imag__ result, 0);
3304   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, 0.0));
3305   check ("real(ccosh(-0 + 0i)) = 1.0", __real__ result, 1.0);
3306   check ("imag(ccosh(-0 + 0i)) = -0", __imag__ result, minus_zero);
3307   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_zero));
3308   check ("real(ccosh(0 - 0i)) = 1.0", __real__ result, 1.0);
3309   check ("imag(ccosh(0 - 0i)) = -0", __imag__ result, minus_zero);
3310   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_zero));
3311   check ("real(ccosh(-0 - 0i)) = 1.0", __real__ result, 1.0);
3312   check ("imag(ccosh(-0 - 0i)) = 0", __imag__ result, 0.0);
3313
3314   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, plus_infty));
3315   check_isnan_exc ("real(ccosh(0 + i Inf)) = NaN plus invalid exception",
3316                    __real__ result, INVALID_EXCEPTION);
3317   check ("imag(ccosh(0 + i Inf)) = +-0 plus invalid exception",
3318          FUNC(fabs) (__imag__ result), 0);
3319   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, plus_infty));
3320   check_isnan_exc ("real(ccosh(-0 + i Inf)) = NaN plus invalid exception",
3321                    __real__ result, INVALID_EXCEPTION);
3322   check ("imag(ccosh(-0 + i Inf)) = +-0 plus invalid exception",
3323          FUNC(fabs) (__imag__ result), 0);
3324   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_infty));
3325   check_isnan_exc ("real(ccosh(0 - i Inf)) = NaN plus invalid exception",
3326                    __real__ result, INVALID_EXCEPTION);
3327   check ("imag(ccosh(0 - i Inf)) = +-0 plus invalid exception",
3328          FUNC(fabs) (__imag__ result), 0);
3329   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_infty));
3330   check_isnan_exc ("real(ccosh(-0 - i Inf)) = NaN plus invalid exception",
3331                    __real__ result, INVALID_EXCEPTION);
3332   check ("imag(ccosh(-0 - i Inf)) = +-0 plus invalid exception",
3333          FUNC(fabs) (__imag__ result), 0);
3334
3335   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 0.0));
3336   check_isinfp ("real(ccosh(+Inf + 0i)) = +Inf", __real__ result);
3337   check ("imag(ccosh(+Inf + 0i)) = 0", __imag__ result, 0);
3338   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 0.0));
3339   check_isinfp ("real(ccosh(-Inf + 0i)) = +Inf", __real__ result);
3340   check ("imag(ccosh(-Inf + 0i)) = -0", __imag__ result, minus_zero);
3341   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_zero));
3342   check_isinfp ("real(ccosh(+Inf - 0i)) = +Inf", __real__ result);
3343   check ("imag(ccosh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
3344   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_zero));
3345   check_isinfp ("real(ccosh(-Inf - 0i)) = +Inf", __real__ result);
3346   check ("imag(ccosh(-Inf - 0i)) = 0", __imag__ result, 0.0);
3347
3348   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, plus_infty));
3349   check_isinfp_exc ("real(ccosh(+Inf + i Inf)) = +Inf plus invalid exception",
3350                     __real__ result, INVALID_EXCEPTION);
3351   check_isnan ("imag(ccosh(+Inf + i Inf)) = NaN plus invalid exception",
3352                __imag__ result);
3353   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, plus_infty));
3354   check_isinfp_exc ("real(ccosh(-Inf + i Inf)) = +Inf plus invalid exception",
3355                     __real__ result, INVALID_EXCEPTION);
3356   check_isnan ("imag(ccosh(-Inf + i Inf)) = NaN plus invalid exception",
3357                __imag__ result);
3358   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_infty));
3359   check_isinfp_exc ("real(ccosh(Inf - i Inf)) = +Inf plus invalid exception",
3360                     __real__ result, INVALID_EXCEPTION);
3361   check_isnan ("imag(ccosh(Inf - i Inf)) = NaN plus invalid exception",
3362                __imag__ result);
3363   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_infty));
3364   check_isinfp_exc ("real(ccosh(-Inf - i Inf)) = +Inf plus invalid exception",
3365                     __real__ result, INVALID_EXCEPTION);
3366   check_isnan ("imag(ccosh(-Inf - i Inf)) = NaN plus invalid exception",
3367                __imag__ result);
3368
3369   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 4.625));
3370   check_isinfn ("real(ccosh(+Inf + i4.625)) = -Inf", __real__ result);
3371   check_isinfn ("imag(ccosh(+Inf + i4.625)) = -Inf", __imag__ result);
3372   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 4.625));
3373   check_isinfn ("real(ccosh(-Inf + i4.625)) = -Inf", __real__ result);
3374   check_isinfp ("imag(ccosh(-Inf + i4.625)) = Inf", __imag__ result);
3375   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, -4.625));
3376   check_isinfn ("real(ccosh(+Inf - i4.625)) = -Inf", __real__ result);
3377   check_isinfp ("imag(ccosh(+Inf - i4.625)) = +Inf", __imag__ result);
3378   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, -4.625));
3379   check_isinfn ("real(ccosh(-Inf - i4.625)) = -Inf", __real__ result);
3380   check_isinfn ("imag(ccosh(-Inf - i4.625)) = -Inf", __imag__ result);
3381
3382   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, plus_infty));
3383   check_isnan_exc ("real(ccosh(6.75 + i Inf)) = NaN plus invalid exception",
3384                    __real__ result, INVALID_EXCEPTION);
3385   check_isnan ("imag(ccosh(6.75 + i Inf)) = NaN plus invalid exception",
3386                __imag__ result);
3387   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, plus_infty));
3388   check_isnan_exc ("real(ccosh(-6.75 + i Inf)) = NaN plus invalid exception",
3389                    __real__ result, INVALID_EXCEPTION);
3390   check_isnan ("imag(ccosh(-6.75 + i Inf)) = NaN plus invalid exception",
3391                __imag__ result);
3392   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, minus_infty));
3393   check_isnan_exc ("real(ccosh(6.75 - i Inf)) = NaN plus invalid exception",
3394                    __real__ result, INVALID_EXCEPTION);
3395   check_isnan ("imag(ccosh(6.75 - i Inf)) = NaN plus invalid exception",
3396                __imag__ result);
3397   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, minus_infty));
3398   check_isnan_exc ("real(ccosh(-6.75 - i Inf)) = NaN plus invalid exception",
3399                    __real__ result, INVALID_EXCEPTION);
3400   check_isnan ("imag(ccosh(-6.75 - i Inf)) = NaN plus invalid exception",
3401                __imag__ result);
3402
3403   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, nan_value));
3404   check_isnan ("real(ccosh(0 + i NaN)) = NaN", __real__ result);
3405   check ("imag(ccosh(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
3406   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, nan_value));
3407   check_isnan ("real(ccosh(-0 + i NaN)) = NaN", __real__ result);
3408   check ("imag(ccosh(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
3409
3410   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, nan_value));
3411   check_isinfp ("real(ccosh(+Inf + i NaN)) = +Inf", __real__ result);
3412   check_isnan ("imag(ccosh(+Inf + i NaN)) = NaN", __imag__ result);
3413   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, nan_value));
3414   check_isinfp ("real(ccosh(-Inf + i NaN)) = +Inf", __real__ result);
3415   check_isnan ("imag(ccosh(-Inf + i NaN)) = NaN", __imag__ result);
3416
3417   result = FUNC(ccosh) (BUILD_COMPLEX (9.0, nan_value));
3418   check_isnan_maybe_exc ("real(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3419                          __real__ result, INVALID_EXCEPTION);
3420   check_isnan ("imag(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception",
3421                __imag__ result);
3422   result = FUNC(ccosh) (BUILD_COMPLEX (-9.0, nan_value));
3423   check_isnan_maybe_exc ("real(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3424                          __real__ result, INVALID_EXCEPTION);
3425   check_isnan ("imag(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception",
3426                __imag__ result);
3427
3428   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 0.0));
3429   check_isnan ("real(ccosh(NaN + i0)) = NaN", __real__ result);
3430   check ("imag(ccosh(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3431   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_zero));
3432   check_isnan ("real(ccosh(NaN - i0)) = NaN", __real__ result);
3433   check ("imag(ccosh(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0);
3434
3435   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 10.0));
3436   check_isnan_maybe_exc ("real(ccosh(NaN + i10)) = NaN plus maybe invalid exception",
3437                          __real__ result, INVALID_EXCEPTION);
3438   check_isnan ("imag(ccosh(NaN + i10)) = NaN plus maybe invalid exception",
3439                __imag__ result);
3440   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, -10.0));
3441   check_isnan_maybe_exc ("real(ccosh(NaN - i10)) = NaN plus maybe invalid exception",
3442                          __real__ result, INVALID_EXCEPTION);
3443   check_isnan ("imag(ccosh(NaN - i10)) = NaN plus maybe invalid exception",
3444                __imag__ result);
3445
3446   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, plus_infty));
3447   check_isnan_maybe_exc ("real(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception",
3448                          __real__ result, INVALID_EXCEPTION);
3449   check_isnan ("imag(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception",
3450                __imag__ result);
3451   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_infty));
3452   check_isnan_maybe_exc ("real(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception",
3453                          __real__ result, INVALID_EXCEPTION);
3454   check_isnan ("imag(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception",
3455                __imag__ result);
3456
3457   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, nan_value));
3458   check_isnan ("real(ccosh(NaN + i NaN)) = NaN", __real__ result);
3459   check_isnan ("imag(ccosh(NaN + i NaN)) = NaN", __imag__ result);
3460
3461   result = FUNC(ccosh) (BUILD_COMPLEX (0.7, 1.2));
3462   check_eps ("real(ccosh(0.7 + i 1.2)) == 0.45482...", __real__ result,
3463              0.4548202223691477654L, CHOOSE(5e-17L, 6e-17, 9e-8));
3464   check_eps ("imag(ccosh(0.7 + i 1.2)) == 0.70702...", __imag__ result,
3465              0.7070296600921537682L, CHOOSE(7e-17L, 2e-16, 0));
3466
3467   result = FUNC(ccosh) (BUILD_COMPLEX (-2, -3));
3468     check_eps ("real(ccosh(-2 - i 3)) == -3.72454...", __real__ result,
3469              -3.7245455049153225654L, CHOOSE(7e-19L, 0, 3e-7));
3470   check_eps ("imag(ccosh(-2 - i 3)) == -0.51182...", __imag__ result,
3471              0.5118225699873846088L, CHOOSE(3e-19L, 2e-16, 6e-8));
3472 }
3473
3474
3475 static void
3476 cacos_test (void)
3477 {
3478   __complex__ MATHTYPE result;
3479
3480   result = FUNC(cacos) (BUILD_COMPLEX (0, 0));
3481   check ("real(cacos(0 + i0)) = pi/2", __real__ result, M_PI_2l);
3482   check ("imag(cacos(0 + i0)) = -0", __imag__ result, minus_zero);
3483   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, 0));
3484   check ("real(cacos(-0 + i0)) = pi/2", __real__ result, M_PI_2l);
3485   check ("imag(cacos(-0 + i0)) = -0", __imag__ result, minus_zero);
3486   result = FUNC(cacos) (BUILD_COMPLEX (0, minus_zero));
3487   check ("real(cacos(0 - i0)) = pi/2", __real__ result, M_PI_2l);
3488   check ("imag(cacos(0 - i0)) = 0", __imag__ result, 0);
3489   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, minus_zero));
3490   check ("real(cacos(-0 - i0)) = pi/2", __real__ result, M_PI_2l);
3491   check ("imag(cacos(-0 - i0)) = 0", __imag__ result, 0);
3492
3493   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, plus_infty));
3494   check ("real(cacos(-Inf + i Inf)) = 3*pi/4", __real__ result,
3495          M_PIl - M_PI_4l);
3496   check_isinfn ("imag(cacos(-Inf + i Inf)) = -Inf", __imag__ result);
3497   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_infty));
3498   check ("real(cacos(-Inf - i Inf)) = 3*pi/4", __real__ result,
3499  M_PIl - M_PI_4l);
3500   check_isinfp ("imag(cacos(-Inf - i Inf)) = +Inf", __imag__ result);
3501
3502   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, plus_infty));
3503   check ("real(cacos(+Inf + i Inf)) = pi/4", __real__ result, M_PI_4l);
3504   check_isinfn ("imag(cacos(+Inf + i Inf)) = -Inf", __imag__ result);
3505   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_infty));
3506   check ("real(cacos(+Inf - i Inf)) = pi/4", __real__ result, M_PI_4l);
3507   check_isinfp ("imag(cacos(+Inf - i Inf)) = +Inf", __imag__ result);