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