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