a7a53cb6bcee7b6382779a9150fe5c536fee35aa
[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.pfalz.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 acos, acosh, asin, asinh, atan, atan2, atanh,
43    cbrt, ceil, copysign, cos, cosh, exp, exp2, expm1,
44    fabs, fdim, floor, fmin, fmax, fpclassify,
45    frexp, hypot, ilogb, ldexp,
46    log, log10, log1p, log2, logb, modf, nextafter,
47    pow, scalb, scalbn, sin, sinh, sqrt, tan, tanh, trunc.
48    Tests for the other libm-functions will come later.
49
50    The routines using random variables are still under construction. I don't
51    like it the way it's working now and will change it.
52
53    Exception handling has not been implemented so far so don't get fooled
54    that these tests pass.
55
56    Parameter handling is primitive in the moment:
57    --verbose=[0..3] for different levels of output:
58    0: only error count
59    1: basic report on failed tests
60    2: full report on failed tests
61    3: full report on failed and passed tests (default)
62    -v for full output (equals --verbose=3)
63    -s,--silent outputs only the error count (equals --verbose=0)
64  */
65
66 #ifndef _GNU_SOURCE
67 # define _GNU_SOURCE
68 #endif
69
70 #include <complex.h>
71 #include <math.h>
72 #include <float.h>
73
74 #include <errno.h>
75 #include <stdlib.h>
76 #include <stdio.h>
77 #include <time.h>
78 #include <getopt.h>
79
80 /* TEST_EXCEPTION: tests if an exception as occured */
81 /* for the moment: does nothing */
82 /* Possible exceptions */
83 #define NO_EXCEPTION             0x0
84 #define INVALID_EXCEPTION        0x1
85 #define DIVIDE_BY_ZERO_EXCEPTION 0x2
86
87 #define PRINT 1
88 #define NO_PRINT 0
89
90 #define TEST_EXCEPTION(test) do {} while (0);
91 /* As long as no exception code is available prevent warnings.  */
92 #define UNUSED __attribute__ ((unused))
93
94 static int noErrors;
95
96 static int verbose = 3;
97 static MATHTYPE minus_zero, plus_zero;
98 static MATHTYPE plus_infty, minus_infty, nan_value;
99
100 typedef MATHTYPE (*mathfunc) (MATHTYPE);
101
102 #define BUILD_COMPLEX(real, imag) \
103   ({ __complex__ MATHTYPE __retval;                                           \
104      __real__ __retval = (real);                                              \
105      __imag__ __retval = (imag);                                              \
106      __retval; })
107
108
109 #define ISINF(x) \
110 (sizeof (x) == sizeof (float) ?                                               \
111  isinff (x)                                                                   \
112  : sizeof (x) == sizeof (double) ?                                            \
113  isinf (x) : isinfl (x))
114
115
116      /*
117         Test if Floating-Point stack hasn't changed
118       */
119 static void
120 fpstack_test (const char *test_name)
121 {
122 #ifdef i386
123   static int old_stack;
124   int sw;
125 asm ("fnstsw":"=a" (sw));
126   sw >>= 11;
127   sw &= 7;
128   if (sw != old_stack)
129     {
130       printf ("FP-Stack wrong after test %s\n", test_name);
131       if (verbose > 2)
132         printf ("=======> stack = %d\n", sw);
133       ++noErrors;
134       old_stack = sw;
135     }
136 #endif
137 }
138
139
140 /*
141    Get a random value x with min_value < x < max_value
142    and min_value, max_value finite,
143    max_value and min_value shouldn't be too close together
144  */
145 static MATHTYPE
146 random_value (MATHTYPE min_value, MATHTYPE max_value)
147 {
148   int r;
149   MATHTYPE x;
150
151   r = rand ();
152
153   x = (max_value - min_value) / RAND_MAX * (MATHTYPE) r + min_value;
154
155   if ((x <= min_value) || (x >= max_value) || !isfinite (x))
156     x = (max_value - min_value) / 2 + min_value;
157
158   return x;
159 }
160
161 /* Get a random value x with x > min_value.  */
162 static MATHTYPE
163 random_greater (MATHTYPE min_value)
164 {
165   return random_value (min_value, 1e6);         /* CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX) */
166 }
167
168 /* Get a random value x with x < max_value.  */
169 static MATHTYPE
170 random_less (MATHTYPE max_value)
171 {
172   return random_value (-1e6, max_value);
173 }
174
175
176 /* Test if two floating point numbers are equal.  */
177 static int
178 check_equal (MATHTYPE computed, MATHTYPE supplied, MATHTYPE eps, MATHTYPE * diff)
179 {
180   /* Both plus Infinity or both minus infinity.  */
181   if (ISINF (computed) && (ISINF (computed) == ISINF (supplied)))
182     return 1;
183
184   if (isnan (computed) && isnan (supplied))     /* isnan works for all types */
185     return 1;
186
187   *diff = FUNC(fabs) (computed - supplied);
188
189   if (*diff <= eps && (signbit (computed) == signbit (supplied) || eps != 0.0))
190     return 1;
191
192   return 0;
193 }
194
195
196 static void
197 output_result_bool (const char *test_name, int result)
198 {
199   if (result)
200     {
201       if (verbose > 2)
202         printf ("Pass: %s\n", test_name);
203     }
204   else
205     {
206       if (verbose)
207         printf ("Fail: %s\n", test_name);
208       ++noErrors;
209     }
210
211   fpstack_test (test_name);
212 }
213
214
215 static void
216 output_isvalue (const char *test_name, int result,
217                 MATHTYPE value)
218 {
219   if (result)
220     {
221       if (verbose > 2)
222         printf ("Pass: %s\n", test_name);
223     }
224   else
225     {
226       if (verbose)
227         printf ("Fail: %s\n", test_name);
228       if (verbose > 1)
229         printf (" Value: %.20" PRINTF_EXPR "\n", value);
230       noErrors++;
231     }
232
233   fpstack_test (test_name);
234 }
235
236
237 static void
238 output_isvalue_ext (const char *test_name, int result,
239                     MATHTYPE value, MATHTYPE parameter)
240 {
241   if (result)
242     {
243       if (verbose > 2)
244         printf ("Pass: %s\n", test_name);
245     }
246   else
247     {
248       if (verbose)
249         printf ("Fail: %s\n", test_name);
250       if (verbose > 1)
251         {
252           printf (" Value:     %.20" PRINTF_EXPR "\n", value);
253           printf (" Parameter: %.20" PRINTF_EXPR "\n", parameter);
254         }
255       noErrors++;
256     }
257
258   fpstack_test (test_name);
259 }
260
261
262 static void
263 output_result (const char *test_name, int result,
264                MATHTYPE computed, MATHTYPE expected,
265                MATHTYPE difference,
266                int print_values, int print_diff)
267 {
268   if (result)
269     {
270       if (verbose > 2)
271         printf ("Pass: %s\n", test_name);
272     }
273   else
274     {
275       if (verbose)
276         printf ("Fail: %s\n", test_name);
277       if (verbose > 1 && print_values)
278         {
279           printf ("Result:\n");
280           printf (" is:         %.20" PRINTF_EXPR "\n", computed);
281           printf (" should be:  %.20" PRINTF_EXPR "\n", expected);
282           if (print_diff)
283             printf (" difference: %.20" PRINTF_EXPR "\n", difference);
284         }
285       noErrors++;
286     }
287
288   fpstack_test (test_name);
289 }
290
291
292 static void
293 output_result_ext (const char *test_name, int result,
294                    MATHTYPE computed, MATHTYPE expected,
295                    MATHTYPE difference,
296                    MATHTYPE parameter,
297                    int print_values, int print_diff)
298 {
299   if (result)
300     {
301       if (verbose > 2)
302         printf ("Pass: %s\n", test_name);
303     }
304   else
305     {
306       if (verbose)
307         printf ("Fail: %s\n", test_name);
308       if (verbose > 1 && print_values)
309         {
310           printf ("Result:\n");
311           printf (" is:         %.20" PRINTF_EXPR "\n", computed);
312           printf (" should be:  %.20" PRINTF_EXPR "\n", expected);
313           if (print_diff)
314             printf (" difference: %.20" PRINTF_EXPR "\n", difference);
315           printf ("Parameter:   %.20" PRINTF_EXPR "\n", parameter);
316         }
317       noErrors++;
318     }
319
320   fpstack_test (test_name);
321 }
322
323
324 static void
325 check (const char *test_name, MATHTYPE computed, MATHTYPE expected)
326 {
327   MATHTYPE diff;
328   int result;
329
330   result = check_equal (computed, expected, 0, &diff);
331   output_result (test_name, result,
332                  computed, expected, diff, PRINT, PRINT);
333 }
334
335
336 static void
337 check_ext (const char *test_name, MATHTYPE computed, MATHTYPE expected,
338            MATHTYPE parameter)
339 {
340   MATHTYPE diff;
341   int result;
342
343   result = check_equal (computed, expected, 0, &diff);
344   output_result_ext (test_name, result,
345                      computed, expected, diff, parameter, PRINT, PRINT);
346 }
347
348
349 static void
350 check_eps (const char *test_name, MATHTYPE computed, MATHTYPE expected,
351            MATHTYPE epsilon)
352 {
353   MATHTYPE diff;
354   int result;
355
356   result = check_equal (computed, expected, epsilon, &diff);
357   output_result (test_name, result,
358                  computed, expected, diff, PRINT, PRINT);
359 }
360
361
362 static void
363 check_bool (const char *test_name, int computed)
364 {
365   output_result_bool (test_name, computed);
366 }
367
368
369 static void
370 check_isnan (const char *test_name, MATHTYPE computed)
371 {
372   output_isvalue (test_name, isnan (computed), computed);
373 }
374
375
376 static void
377 check_isnan_exc (const char *test_name, MATHTYPE computed,
378                  short exception UNUSED)
379 {
380   output_isvalue (test_name, isnan (computed), computed);
381 }
382
383
384 static void
385 check_isnan_ext (const char *test_name, MATHTYPE computed,
386                  MATHTYPE parameter)
387 {
388   output_isvalue_ext (test_name, isnan (computed), computed, parameter);
389 }
390
391
392 /* Tests if computed is +Inf */
393 static void
394 check_isinfp (const char *test_name, MATHTYPE computed)
395 {
396   output_isvalue (test_name, (ISINF (computed) == +1), computed);
397 }
398
399
400 static void
401 check_isinfp_ext (const char *test_name, MATHTYPE computed,
402                   MATHTYPE parameter)
403 {
404   output_isvalue_ext (test_name, (ISINF (computed) == +1), computed, parameter);
405 }
406
407
408 /* Tests if computed is +Inf */
409 static void
410 check_isinfp_exc (const char *test_name, MATHTYPE computed,
411                   int exception UNUSED)
412 {
413   output_isvalue (test_name, (ISINF (computed) == +1), computed);
414 }
415
416 /* Tests if computed is -Inf */
417 static void
418 check_isinfn (const char *test_name, MATHTYPE computed)
419 {
420   output_isvalue (test_name, (ISINF (computed) == -1), computed);
421 }
422
423
424 static void
425 check_isinfn_ext (const char *test_name, MATHTYPE computed,
426                   MATHTYPE parameter)
427 {
428   output_isvalue_ext (test_name, (ISINF (computed) == -1), computed, parameter);
429 }
430
431
432 /* Tests if computed is -Inf */
433 static void
434 check_isinfn_exc (const char *test_name, MATHTYPE computed,
435                   int exception UNUSED)
436 {
437   output_isvalue (test_name, (ISINF (computed) == -1), computed);
438 }
439
440
441 /****************************************************************************
442   Test for single functions of libm
443 ****************************************************************************/
444
445 static void
446 acos_test (void)
447 {
448   MATHTYPE x;
449
450   check ("acos (1) == 0", FUNC(acos) (1), 0);
451
452   x = random_greater (1);
453   check_isnan_exc ("acos (x) == NaN + invalid exception for |x| > 1",
454                    FUNC(acos) (x),
455                    INVALID_EXCEPTION);
456 }
457
458 static void
459 acosh_test (void)
460 {
461   MATHTYPE x;
462
463   check ("acosh(1) == 0", FUNC(acosh) (1), 0);
464   check_isinfp ("acosh(+inf) == +inf", FUNC(acosh) (plus_infty));
465
466   x = random_less (1);
467   check_isnan_exc ("acosh(x) == NaN plus invalid exception if x < 1",
468                    FUNC(acosh) (x), INVALID_EXCEPTION);
469 }
470
471
472 static void
473 asin_test (void)
474 {
475   MATHTYPE x;
476   check ("asin (0) == 0", FUNC(asin) (0), 0);
477
478   x = random_greater (1);
479   check_isnan_exc ("asin x == NaN + invalid exception for |x| > 1",
480                    FUNC(asin) (x),
481                    INVALID_EXCEPTION);
482 }
483
484 static void
485 asinh_test (void)
486 {
487
488   check ("asinh(+0) == +0", FUNC(asinh) (0), 0);
489   check ("asinh(-0) == -0", FUNC(asinh) (minus_zero), minus_zero);
490 }
491
492
493 static void
494 atan_test (void)
495 {
496   check ("atan (0) == 0", FUNC(atan) (0), 0);
497   check ("atan (-0) == -0", FUNC(atan) (minus_zero), minus_zero);
498
499   check ("atan (+inf) == pi/2", FUNC(atan) (plus_infty), M_PI_2);
500   check ("atan (-inf) == -pi/2", FUNC(atan) (minus_infty), -M_PI_2);
501
502 }
503
504 static void
505 atan2_test (void)
506 {
507   MATHTYPE x;
508
509   x = random_greater (0);
510   check ("atan2 (0,x) == 0 for x > 0",
511          FUNC(atan2) (0, x), 0);
512   x = random_greater (0);
513   check ("atan2 (-0,x) == -0 for x > 0",
514          FUNC(atan2) (minus_zero, x), minus_zero);
515
516   check ("atan2 (+0,+0) == +0", FUNC(atan2) (0, 0), 0);
517   check ("atan2 (-0,+0) == -0", FUNC(atan2) (minus_zero, 0), minus_zero);
518
519   x = -random_greater (0);
520   check ("atan2 (+0,x) == +pi for x < 0", FUNC(atan2) (0, x), M_PI);
521
522   x = -random_greater (0);
523   check ("atan2 (-0,x) == -pi for x < 0", FUNC(atan2) (minus_zero, x), -M_PI);
524
525   check ("atan2 (+0,-0) == +pi", FUNC(atan2) (0, minus_zero), M_PI);
526   check ("atan2 (-0,-0) == -pi", FUNC(atan2) (minus_zero, minus_zero), -M_PI);
527
528   x = random_greater (0);
529   check ("atan2 (y,+0) == pi/2 for y > 0", FUNC(atan2) (x, 0), M_PI_2);
530
531   x = random_greater (0);
532   check ("atan2 (y,-0) == pi/2 for y > 0", FUNC(atan2) (x, minus_zero), M_PI_2);
533
534   x = random_greater (0);
535   check ("atan2 (y,-inf) == +pi for finite y > 0",
536          FUNC(atan2) (x, minus_infty), M_PI);
537
538   x = -random_greater (0);
539   check ("atan2 (y,-inf) == -pi for finite y < 0",
540          FUNC(atan2) (x, minus_infty), -M_PI);
541
542   check ("atan2 (+inf,+inf) == +pi/4",
543          FUNC(atan2) (plus_infty, plus_infty), M_PI_4);
544
545   check ("atan2 (-inf,+inf) == -pi/4",
546          FUNC(atan2) (minus_infty, plus_infty), -M_PI_4);
547
548   check ("atan2 (+inf,-inf) == +3*pi/4",
549          FUNC(atan2) (plus_infty, minus_infty), 3 * M_PI_4);
550
551   check ("atan2 (-inf,-inf) == -3*pi/4",
552          FUNC(atan2) (minus_infty, minus_infty), -3 * M_PI_4);
553 }
554
555
556 static void
557 atanh_test (void)
558 {
559
560   check ("atanh(+0) == +0", FUNC(atanh) (0), 0);
561   check ("atanh(-0) == -0", FUNC(atanh) (minus_zero), minus_zero);
562   check_isinfp_exc ("atanh(+1) == +inf plus divide-by-zero exception",
563                     FUNC(atanh) (1), DIVIDE_BY_ZERO_EXCEPTION);
564   check_isinfn_exc ("atanh(-1) == -inf plus divide-by-zero exception",
565                     FUNC(atanh) (-1), DIVIDE_BY_ZERO_EXCEPTION);
566 }
567
568
569 static void
570 cbrt_test (void)
571 {
572   check ("cbrt (+0) == +0", FUNC(cbrt) (0.0), 0.0);
573   check ("cbrt (-0) == -0", FUNC(cbrt) (minus_zero), minus_zero);
574
575   check ("cbrt (8) == 2", FUNC(cbrt) (8), 2);
576   check ("cbrt (-27) == -3", FUNC(cbrt) (-27.0), -3.0);
577 }
578
579
580 static void
581 ceil_test (void)
582 {
583   check ("ceil (+0) == +0", FUNC(ceil) (0.0), 0.0);
584   check ("ceil (-0) == -0", FUNC(ceil) (minus_zero), minus_zero);
585   check_isinfp ("ceil (+inf) == +inf", FUNC(ceil) (plus_infty));
586   check_isinfn ("ceil (-inf) == -inf", FUNC(ceil) (minus_infty));
587
588   check ("ceil (pi) == 4", FUNC(ceil) (M_PI), 4.0);
589   check ("ceil (-pi) == -3", FUNC(ceil) (-M_PI), -3.0);
590 }
591
592
593 static void
594 cos_test (void)
595 {
596
597   check ("cos (+0) == 1", FUNC(cos) (0), 1);
598   check ("cos (-0) == 1", FUNC(cos) (minus_zero), 1);
599   check_isnan_exc ("cos (+inf) == NaN plus invalid exception",
600                    FUNC(cos) (plus_infty),
601                    INVALID_EXCEPTION);
602   check_isnan_exc ("cos (-inf) == NaN plus invalid exception",
603                    FUNC(cos) (minus_infty),
604                    INVALID_EXCEPTION);
605
606   check_eps ("cos (pi/3) == 0.5", FUNC(cos) (M_PI / 3.0),
607              0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L));
608   check_eps ("cos (pi/2) == 0", FUNC(cos) (M_PI_2),
609              0, CHOOSE (1e-19L, 1e-16L, 1e-7L));
610
611 }
612
613 static void
614 cosh_test (void)
615 {
616   check ("cosh (+0) == 1", FUNC(cosh) (0), 1);
617   check ("cosh (-0) == 1", FUNC(cosh) (minus_zero), 1);
618
619   check_isinfp ("cosh (+inf) == +inf", FUNC(cosh) (plus_infty));
620   check_isinfp ("cosh (-inf) == +inf", FUNC(cosh) (minus_infty));
621 }
622
623
624 static void
625 exp_test (void)
626 {
627   check ("exp (+0) == 1", FUNC(exp) (0), 1);
628   check ("exp (-0) == 1", FUNC(exp) (minus_zero), 1);
629
630   check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty));
631   check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0);
632
633   check_eps ("exp (1) == e", FUNC(exp) (1), M_E, CHOOSE (4e-18L, 0, 0));
634 }
635
636
637 static void
638 exp2_test (void)
639 {
640   errno = 0;
641   exp2(0);
642   if (errno == ENOSYS)
643     /* Function not implemented.  */
644     return;
645
646   check ("exp2 (+0) == 1", FUNC(exp2) (0), 1);
647   check ("exp2 (-0) == 1", FUNC(exp2) (minus_zero), 1);
648
649   check_isinfp ("exp2 (+inf) == +inf", FUNC(exp2) (plus_infty));
650   check ("exp2 (-inf) == 0", FUNC(exp2) (minus_infty), 0);
651   check ("exp2 (10) == 1024", FUNC(exp2) (10), 1024);
652 }
653
654
655 static void
656 expm1_test (void)
657 {
658   check ("expm1 (+0) == 0", FUNC(expm1) (0), 0);
659   check ("expm1 (-0) == -0", FUNC(expm1) (minus_zero), minus_zero);
660
661   check_isinfp ("expm1 (+inf) == +inf", FUNC(expm1) (plus_infty));
662   check ("expm1 (-inf) == -1", FUNC(expm1) (minus_infty), -1);
663
664   check_eps ("expm1 (1) == e-1", FUNC(expm1) (1), M_E - 1.0,
665              CHOOSE (4e-18L, 0, 0));
666 }
667
668
669
670
671 static void
672 check_frexp (const char *test_name, MATHTYPE computed, MATHTYPE expected,
673              int comp_int, int exp_int)
674 {
675   MATHTYPE diff;
676   int result;
677
678   result = (check_equal (computed, expected, 0, &diff)
679             && (comp_int == exp_int));
680
681   if (result)
682     {
683       if (verbose > 2)
684         printf ("Pass: %s\n", test_name);
685     }
686   else
687     {
688       if (verbose)
689         printf ("Fail: %s\n", test_name);
690       if (verbose > 1)
691         {
692           printf ("Result:\n");
693           printf (" is:         %.20" PRINTF_EXPR " *2^%d\n", computed, comp_int);
694           printf (" should be:  %.20" PRINTF_EXPR " *2^%d\n", expected, exp_int);
695           printf (" difference: %.20" PRINTF_EXPR "\n", diff);
696         }
697       noErrors++;
698     }
699   fpstack_test (test_name);
700   output_result (test_name, result,
701                  computed, expected, diff, PRINT, PRINT);
702 }
703
704
705 static void
706 frexp_test (void)
707 {
708   int x_int;
709   MATHTYPE result;
710
711   result = FUNC(frexp) (plus_infty, &x_int);
712   check_isinfp ("frexp (+inf, expr) == +inf", result);
713
714   result = FUNC(frexp) (minus_infty, &x_int);
715   check_isinfn ("frexp (-inf, expr) == -inf", result);
716
717   result = FUNC(frexp) (nan_value, &x_int);
718   check_isnan ("frexp (Nan, expr) == NaN", result);
719
720   result = FUNC(frexp) (0, &x_int);
721   check_frexp ("frexp: +0 == 0 * 2^0", result, 0, x_int, 0);
722
723   result = FUNC(frexp) (minus_zero, &x_int);
724   check_frexp ("frexp: -0 == -0 * 2^0", result, minus_zero, x_int, 0);
725
726   result = FUNC(frexp) (12.8L, &x_int);
727   check_frexp ("frexp: 12.8 == 0.8 * 2^4", result, 0.8L, x_int, 4);
728
729   result = FUNC(frexp) (-27.34L, &x_int);
730   check_frexp ("frexp: -27.34 == -0.854375 * 2^5", result, -0.854375L, x_int, 5);
731
732 }
733
734
735 #if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1)
736 /* All floating-point numbers can be put in one of these categories.  */
737 enum
738 {
739   FP_NAN,
740 #define FP_NAN FP_NAN
741   FP_INFINITE,
742 #define FP_INFINITE FP_INFINITE
743   FP_ZERO,
744 #define FP_ZERO FP_ZERO
745   FP_SUBNORMAL,
746 #define FP_SUBNORMAL FP_SUBNORMAL
747   FP_NORMAL
748 #define FP_NORMAL FP_NORMAL
749 };
750 #endif
751
752
753 static void
754 fpclassify_test (void)
755 {
756   MATHTYPE x;
757
758   /* fpclassify is a macro, don't give it constants as parameter */
759   check_bool ("fpclassify (NaN) == FP_NAN", fpclassify (nan_value) == FP_NAN);
760   check_bool ("fpclassify (+inf) == FP_INFINITE",
761               fpclassify (plus_infty) == FP_INFINITE);
762   check_bool ("fpclassify (-inf) == FP_INFINITE",
763               fpclassify (minus_infty) == FP_INFINITE);
764   check_bool ("fpclassify (+0) == FP_ZERO",
765               fpclassify (plus_zero) == FP_ZERO);
766   check_bool ("fpclassify (-0) == FP_ZERO",
767               fpclassify (minus_zero) == FP_ZERO);
768
769   x = 1000.0;
770   check_bool ("fpclassify (1000) == FP_NORMAL",
771               fpclassify (x) == FP_NORMAL);
772 }
773
774
775 static void
776 ilogb_test (void)
777 {
778
779   /* XXX Are these tests correct? I couldn't find any specification */
780 #if 0
781   /* the source suggests that the following calls should fail -
782      but shall we test these special cases or just ignore them? */
783   check_isinfp ("ilogb (+inf) == +inf", FUNC(ilogb) (plus_infty));
784   check_isinfp ("ilogb (-inf) == +inf", FUNC(ilogb) (minus_infty));
785
786   check_isinfn_exc ("ilogb (+0) == -inf plus divide-by-zero exception",
787                     FUNC(ilogb) (0), DIVIDE_BY_ZERO_EXCEPTION);
788
789   check_isinfn_exc ("ilogb (-0) == -inf plus divide-by-zero exception",
790                     FUNC(ilogb) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
791 #endif
792   check ("ilogb (1) == 0", FUNC(ilogb) (1), 0);
793   check ("ilogb (e) == 1", FUNC(ilogb) (M_E), 1);
794   check ("ilogb (1024) == 10", FUNC(ilogb) (1024), 10);
795   check ("ilogb (-2000) == 10", FUNC(ilogb) (-2000), 10);
796
797 }
798
799
800 static void
801 ldexp_test (void)
802 {
803   MATHTYPE x;
804
805   check ("ldexp (0, 0) == 0", FUNC(ldexp) (0, 0), 0);
806
807   check_isinfp ("ldexp (+inf, 1) == +inf", FUNC(ldexp) (plus_infty, 1));
808   check_isinfn ("ldexp (-inf, 1) == -inf", FUNC(ldexp) (minus_infty, 1));
809   check_isnan ("ldexp (NaN, 1) == NaN", FUNC(ldexp) (nan_value, 1));
810
811   check ("ldexp (0.8, 4) == 12.8", FUNC(ldexp) (0.8L, 4), 12.8L);
812   check ("ldexp (-0.854375, 5) == -27.34", FUNC(ldexp) (-0.854375L, 5), -27.34L);
813
814   x = random_greater (0.0);
815   check_ext ("ldexp (x, 0) == x", FUNC(ldexp) (x, 0L), x, x);
816
817 }
818
819
820 static void
821 log_test (void)
822 {
823   check_isinfn_exc ("log (+0) == -inf", FUNC(log) (0),
824                     DIVIDE_BY_ZERO_EXCEPTION);
825   check_isinfn_exc ("log (-0) == -inf", FUNC(log) (minus_zero),
826                     DIVIDE_BY_ZERO_EXCEPTION);
827
828   check ("log (1) == 0", FUNC(log) (1), 0);
829
830   check_isnan_exc ("log (x) == NaN plus divide-by-zero exception if x < 0",
831                    FUNC(log) (-1), INVALID_EXCEPTION);
832   check_isinfp ("log (+inf) == +inf", FUNC(log) (plus_infty));
833
834   check_eps ("log (e) == 1", FUNC(log) (M_E), 1, CHOOSE (1e-18L, 0, 9e-8L));
835   check_eps ("log (1/e) == -1", FUNC(log) (1.0 / M_E), -1,
836              CHOOSE (2e-18L, 0, 0));
837   check ("log (2) == M_LN2", FUNC(log) (2), M_LN2);
838   check_eps ("log (10) == M_LN10", FUNC(log) (10), M_LN10,
839              CHOOSE (1e-18L, 0, 0));
840 }
841
842
843 static void
844 log10_test (void)
845 {
846   check_isinfn_exc ("log10 (+0) == -inf", FUNC(log10) (0),
847                     DIVIDE_BY_ZERO_EXCEPTION);
848   check_isinfn_exc ("log10 (-0) == -inf", FUNC(log10) (minus_zero),
849                     DIVIDE_BY_ZERO_EXCEPTION);
850
851   check ("log10 (1) == +0", FUNC(log10) (1), 0);
852
853   check_isnan_exc ("log10 (x) == NaN plus divide-by-zero exception if x < 0",
854                    FUNC(log10) (-1), INVALID_EXCEPTION);
855
856   check_isinfp ("log10 (+inf) == +inf", FUNC(log10) (plus_infty));
857
858   check_eps ("log10 (0.1) == -1", FUNC(log10) (0.1L), -1,
859              CHOOSE (1e-18L, 0, 0));
860   check_eps ("log10 (10) == 1", FUNC(log10) (10.0), 1,
861              CHOOSE (1e-18L, 0, 0));
862   check_eps ("log10 (100) == 2", FUNC(log10) (100.0), 2,
863              CHOOSE (1e-18L, 0, 0));
864   check ("log10 (10000) == 4", FUNC(log10) (10000.0), 4);
865   check_eps ("log10 (e) == M_LOG10E", FUNC(log10) (M_E), M_LOG10E,
866              CHOOSE (1e-18, 0, 9e-8));
867 }
868
869
870 static void
871 log1p_test (void)
872 {
873   check ("log1p (+0) == +0", FUNC(log1p) (0), 0);
874   check ("log1p (-0) == -0", FUNC(log1p) (minus_zero), minus_zero);
875
876   check_isinfn_exc ("log1p (-1) == -inf", FUNC(log1p) (-1),
877                     DIVIDE_BY_ZERO_EXCEPTION);
878   check_isnan_exc ("log1p (x) == NaN plus divide-by-zero exception if x < -1",
879                    FUNC(log1p) (-2), INVALID_EXCEPTION);
880
881   check_isinfp ("log1p (+inf) == +inf", FUNC(log1p) (plus_infty));
882
883   check_eps ("log1p (e-1) == 1", FUNC(log1p) (M_E - 1.0), 1,
884              CHOOSE (1e-18L, 0, 0));
885
886 }
887
888
889 static void
890 log2_test (void)
891 {
892   check_isinfn_exc ("log2 (+0) == -inf", FUNC(log2) (0),
893                     DIVIDE_BY_ZERO_EXCEPTION);
894   check_isinfn_exc ("log2 (-0) == -inf", FUNC(log2) (minus_zero),
895                     DIVIDE_BY_ZERO_EXCEPTION);
896
897   check ("log2 (1) == +0", FUNC(log2) (1), 0);
898
899   check_isnan_exc ("log2 (x) == NaN plus divide-by-zero exception if x < 0",
900                    FUNC(log2) (-1), INVALID_EXCEPTION);
901
902   check_isinfp ("log2 (+inf) == +inf", FUNC(log2) (plus_infty));
903
904   check_eps ("log2 (e) == M_LOG2E", FUNC(log2) (M_E), M_LOG2E,
905              CHOOSE (1e-18L, 0, 0));
906   check ("log2 (2) == 1", FUNC(log2) (2.0), 1);
907   check_eps ("log2 (16) == 4", FUNC(log2) (16.0), 4, CHOOSE (1e-18L, 0, 0));
908   check ("log2 (256) == 8", FUNC(log2) (256.0), 8);
909
910 }
911
912
913 static void
914 logb_test (void)
915 {
916   check_isinfp ("logb (+inf) == +inf", FUNC(logb) (plus_infty));
917   check_isinfp ("logb (-inf) == +inf", FUNC(logb) (minus_infty));
918
919   check_isinfn_exc ("logb (+0) == -inf plus divide-by-zero exception",
920                     FUNC(logb) (0), DIVIDE_BY_ZERO_EXCEPTION);
921
922   check_isinfn_exc ("logb (-0) == -inf plus divide-by-zero exception",
923                     FUNC(logb) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION);
924
925   check ("logb (1) == 0", FUNC(logb) (1), 0);
926   check ("logb (e) == 1", FUNC(logb) (M_E), 1);
927   check ("logb (1024) == 10", FUNC(logb) (1024), 10);
928   check ("logb (-2000) == 10", FUNC(logb) (-2000), 10);
929
930 }
931
932
933 static void
934 modf_test (void)
935 {
936   MATHTYPE result, intpart;
937
938   result = FUNC(modf) (plus_infty, &intpart);
939   check ("modf (+inf, &x) returns +0", result, 0);
940   check_isinfp ("modf (+inf, &x) set x to +inf", intpart);
941
942   result = FUNC(modf) (minus_infty, &intpart);
943   check ("modf (-inf, &x) returns -0", result, minus_zero);
944   check_isinfn ("modf (-inf, &x) sets x to -inf", intpart);
945
946   result = FUNC(modf) (nan_value, &intpart);
947   check_isnan ("modf (NaN, &x) returns NaN", result);
948   check_isnan ("modf (NaN, &x) sets x to NaN", intpart);
949
950   result = FUNC(modf) (0, &intpart);
951   check ("modf (0, &x) returns 0", result, 0);
952   check ("modf (0, &x) sets x to 0", intpart, 0);
953
954   result = FUNC(modf) (minus_zero, &intpart);
955   check ("modf (-0, &x) returns -0", result, minus_zero);
956   check ("modf (-0, &x) sets x to -0", intpart, minus_zero);
957
958   result = FUNC(modf) (2.5, &intpart);
959   check ("modf (2.5, &x) returns 0.5", result, 0.5);
960   check ("modf (2.5, &x) sets x to 2", intpart, 2);
961
962   result = FUNC(modf) (-2.5, &intpart);
963   check ("modf (-2.5, &x) returns -0.5", result, -0.5);
964   check ("modf (-2.5, &x) sets x to -2", intpart, -2);
965
966 }
967
968
969 static void
970 scalb_test (void)
971 {
972   MATHTYPE x;
973
974   check ("scalb (0, 0) == 0", FUNC(scalb) (0, 0), 0);
975
976   check_isinfp ("scalb (+inf, 1) == +inf", FUNC(scalb) (plus_infty, 1));
977   check_isinfn ("scalb (-inf, 1) == -inf", FUNC(scalb) (minus_infty, 1));
978   check_isnan ("scalb (NaN, 1) == NaN", FUNC(scalb) (nan_value, 1));
979
980   check ("scalb (0.8, 4) == 12.8", FUNC(scalb) (0.8L, 4), 12.8L);
981   check ("scalb (-0.854375, 5) == -27.34", FUNC(scalb) (-0.854375L, 5), -27.34L);
982
983   x = random_greater (0.0);
984   check_ext ("scalb (x, 0) == x", FUNC(scalb) (x, 0L), x, x);
985 }
986
987
988 static void
989 scalbn_test (void)
990 {
991   MATHTYPE x;
992
993   check ("scalbn (0, 0) == 0", FUNC(scalbn) (0, 0), 0);
994
995   check_isinfp ("scalbn (+inf, 1) == +inf", FUNC(scalbn) (plus_infty, 1));
996   check_isinfn ("scalbn (-inf, 1) == -inf", FUNC(scalbn) (minus_infty, 1));
997   check_isnan ("scalbn (NaN, 1) == NaN", FUNC(scalbn) (nan_value, 1));
998
999   check ("scalbn (0.8, 4) == 12.8", FUNC(scalbn) (0.8L, 4), 12.8L);
1000   check ("scalbn (-0.854375, 5) == -27.34", FUNC(scalbn) (-0.854375L, 5), -27.34L);
1001
1002   x = random_greater (0.0);
1003   check_ext ("scalbn (x, 0) == x", FUNC(scalbn) (x, 0L), x, x);
1004 }
1005
1006
1007 static void
1008 sin_test (void)
1009 {
1010   check ("sin (+0) == +0", FUNC(sin) (0), 0);
1011   check ("sin (-0) == -0", FUNC(sin) (minus_zero), minus_zero);
1012   check_isnan_exc ("sin (+inf) == NaN plus invalid exception",
1013                    FUNC(sin) (plus_infty),
1014                    INVALID_EXCEPTION);
1015   check_isnan_exc ("sin (-inf) == NaN plus invalid exception",
1016                    FUNC(sin) (minus_infty),
1017                    INVALID_EXCEPTION);
1018
1019   check_eps ("sin (pi/6) == 0.5", FUNC(sin) (M_PI / 6.0), 0.5,
1020              CHOOSE (4e-18L, 0, 0));
1021   check ("sin (pi/2) == 1", FUNC(sin) (M_PI_2), 1);
1022 }
1023
1024
1025 static void
1026 sinh_test (void)
1027 {
1028   check ("sinh (+0) == +0", FUNC(sinh) (0), 0);
1029   check ("sinh (-0) == -0", FUNC(sinh) (minus_zero), minus_zero);
1030
1031   check_isinfp ("sinh (+inf) == +inf", FUNC(sinh) (plus_infty));
1032   check_isinfn ("sinh (-inf) == -inf", FUNC(sinh) (minus_infty));
1033 }
1034
1035
1036 static void
1037 tan_test (void)
1038 {
1039   check ("tan (+0) == +0", FUNC(tan) (0), 0);
1040   check ("tan (-0) == -0", FUNC(tan) (minus_zero), minus_zero);
1041   check_isnan_exc ("tan (+inf) == NaN plus invalid exception",
1042                    FUNC(tan) (plus_infty), INVALID_EXCEPTION);
1043   check_isnan_exc ("tan (-inf) == NaN plus invalid exception",
1044                    FUNC(tan) (minus_infty), INVALID_EXCEPTION);
1045
1046   check_eps ("tan (pi/4) == 1", FUNC(tan) (M_PI_4), 1,
1047              CHOOSE (2e-18L, 1e-15L, 0));
1048 }
1049
1050
1051 static void
1052 tanh_test (void)
1053 {
1054   check ("tanh (+0) == +0", FUNC(tanh) (0), 0);
1055   check ("tanh (-0) == -0", FUNC(tanh) (minus_zero), minus_zero);
1056
1057   check ("tanh (+inf) == +1", FUNC(tanh) (plus_infty), 1);
1058   check ("tanh (-inf) == -1", FUNC(tanh) (minus_infty), -1);
1059 }
1060
1061
1062 static void
1063 fabs_test (void)
1064 {
1065   check ("fabs (+0) == +0", FUNC(fabs) (0), 0);
1066   check ("fabs (-0) == +0", FUNC(fabs) (minus_zero), 0);
1067
1068   check_isinfp ("fabs (+inf) == +inf", FUNC(fabs) (plus_infty));
1069   check_isinfp ("fabs (-inf) == +inf", FUNC(fabs) (minus_infty));
1070
1071   check ("fabs (+38) == 38", FUNC(fabs) (38.0), 38.0);
1072   check ("fabs (-e) == e", FUNC(fabs) (-M_E), M_E);
1073 }
1074
1075
1076 static void
1077 floor_test (void)
1078 {
1079   check ("floor (+0) == +0", FUNC(floor) (0.0), 0.0);
1080   check ("floor (-0) == -0", FUNC(floor) (minus_zero), minus_zero);
1081   check_isinfp ("floor (+inf) == +inf", FUNC(floor) (plus_infty));
1082   check_isinfn ("floor (-inf) == -inf", FUNC(floor) (minus_infty));
1083
1084   check ("floor (pi) == 3", FUNC(floor) (M_PI), 3.0);
1085   check ("floor (-pi) == -4", FUNC(floor) (-M_PI), -4.0);
1086 }
1087
1088
1089 static void
1090 hypot_test (void)
1091 {
1092   MATHTYPE a;
1093
1094   a = random_greater (0);
1095   check_isinfp_ext ("hypot (+inf, x) == +inf", FUNC(hypot) (plus_infty, a), a);
1096   check_isinfp_ext ("hypot (-inf, x) == +inf", FUNC(hypot) (minus_infty, a), a);
1097
1098   check_isnan ("hypot (NaN, NaN) == NaN", FUNC(hypot) (nan_value, nan_value));
1099
1100   a = FUNC(hypot) (12.4L, 0.7L);
1101   check ("hypot (x,y) == hypot (y,x)", FUNC(hypot) (0.7L, 12.4L), a);
1102   check ("hypot (x,y) == hypot (-x,y)", FUNC(hypot) (-12.4L, 0.7L), a);
1103   check ("hypot (x,y) == hypot (-y,x)", FUNC(hypot) (-0.7L, 12.4L), a);
1104   check ("hypot (x,y) == hypot (-x,-y)", FUNC(hypot) (-12.4L, -0.7L), a);
1105   check ("hypot (x,y) == hypot (-y,-x)", FUNC(hypot) (-0.7L, -12.4L), a);
1106   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-0.7L, 0), 0.7L);
1107   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (0.7L, 0), 0.7L);
1108   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-1.0L, 0), 1.0L);
1109   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (1.0L, 0), 1.0L);
1110   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-5.7e7L, 0), 5.7e7L);
1111   check ("hypot (x,0) == fabs (x)", FUNC(hypot) (5.7e7L, 0), 5.7e7L);
1112 }
1113
1114
1115 static void
1116 pow_test (void)
1117 {
1118   MATHTYPE x;
1119
1120   check ("pow (+0, +0) == 1", FUNC(pow) (0, 0), 1);
1121   check ("pow (+0, -0) == 1", FUNC(pow) (0, minus_zero), 1);
1122   check ("pow (-0, +0) == 1", FUNC(pow) (minus_zero, 0), 1);
1123   check ("pow (-0, -0) == 1", FUNC(pow) (minus_zero, minus_zero), 1);
1124
1125   check ("pow (+10, +0) == 1", FUNC(pow) (10, 0), 1);
1126   check ("pow (+10, -0) == 1", FUNC(pow) (10, minus_zero), 1);
1127   check ("pow (-10, +0) == 1", FUNC(pow) (-10, 0), 1);
1128   check ("pow (-10, -0) == 1", FUNC(pow) (-10, minus_zero), 1);
1129
1130   check ("pow (NaN, +0) == 1", FUNC(pow) (nan_value, 0), 1);
1131   check ("pow (NaN, -0) == 1", FUNC(pow) (nan_value, minus_zero), 1);
1132
1133   check_isinfp ("pow (+1.1, +inf) == +inf", FUNC(pow) (1.1, plus_infty));
1134   check_isinfp ("pow (+inf, +inf) == +inf", FUNC(pow) (plus_infty, plus_infty));
1135   check_isinfp ("pow (-1.1, +inf) == +inf", FUNC(pow) (-1.1, plus_infty));
1136   check_isinfp ("pow (-inf, +inf) == +inf", FUNC(pow) (minus_infty, plus_infty));
1137
1138   check ("pow (0.9, +inf) == +0", FUNC(pow) (0.9L, plus_infty), 0);
1139   check ("pow (1e-7, +inf) == +0", FUNC(pow) (1e-7L, plus_infty), 0);
1140   check ("pow (-0.9, +inf) == +0", FUNC(pow) (-0.9L, plus_infty), 0);
1141   check ("pow (-1e-7, +inf) == +0", FUNC(pow) (-1e-7L, plus_infty), 0);
1142
1143   check ("pow (+1.1, -inf) == 0", FUNC(pow) (1.1, minus_infty), 0);
1144   check ("pow (+inf, -inf) == 0", FUNC(pow) (plus_infty, minus_infty), 0);
1145   check ("pow (-1.1, -inf) == 0", FUNC(pow) (-1.1, minus_infty), 0);
1146   check ("pow (-inf, -inf) == 0", FUNC(pow) (minus_infty, minus_infty), 0);
1147
1148   check_isinfp ("pow (0.9, -inf) == +inf", FUNC(pow) (0.9L, minus_infty));
1149   check_isinfp ("pow (1e-7, -inf) == +inf", FUNC(pow) (1e-7L, minus_infty));
1150   check_isinfp ("pow (-0.9, -inf) == +inf", FUNC(pow) (-0.9L, minus_infty));
1151   check_isinfp ("pow (-1e-7, -inf) == +inf", FUNC(pow) (-1e-7L, minus_infty));
1152
1153   check_isinfp ("pow (+inf, 1e-7) == +inf", FUNC(pow) (plus_infty, 1e-7L));
1154   check_isinfp ("pow (+inf, 1) == +inf", FUNC(pow) (plus_infty, 1));
1155   check_isinfp ("pow (+inf, 1e7) == +inf", FUNC(pow) (plus_infty, 1e7L));
1156
1157   check ("pow (+inf, -1e-7) == 0", FUNC(pow) (plus_infty, -1e-7L), 0);
1158   check ("pow (+inf, -1) == 0", FUNC(pow) (plus_infty, -1), 0);
1159   check ("pow (+inf, -1e7) == 0", FUNC(pow) (plus_infty, -1e7L), 0);
1160
1161   check_isinfn ("pow (-inf, 1) == -inf", FUNC(pow) (minus_infty, 1));
1162   check_isinfn ("pow (-inf, 11) == -inf", FUNC(pow) (minus_infty, 11));
1163   check_isinfn ("pow (-inf, 1001) == -inf", FUNC(pow) (minus_infty, 1001));
1164
1165   check_isinfp ("pow (-inf, 2) == +inf", FUNC(pow) (minus_infty, 2));
1166   check_isinfp ("pow (-inf, 12) == +inf", FUNC(pow) (minus_infty, 12));
1167   check_isinfp ("pow (-inf, 1002) == +inf", FUNC(pow) (minus_infty, 1002));
1168   check_isinfp ("pow (-inf, 0.1) == +inf", FUNC(pow) (minus_infty, 0.1));
1169   check_isinfp ("pow (-inf, 1.1) == +inf", FUNC(pow) (minus_infty, 1.1));
1170   check_isinfp ("pow (-inf, 11.1) == +inf", FUNC(pow) (minus_infty, 11.1));
1171   check_isinfp ("pow (-inf, 1001.1) == +inf", FUNC(pow) (minus_infty, 1001.1));
1172
1173   check ("pow (-inf, -1) == -0", FUNC(pow) (minus_infty, -1), minus_zero);
1174   check ("pow (-inf, -11) == -0", FUNC(pow) (minus_infty, -11), minus_zero);
1175   check ("pow (-inf, -1001) == -0", FUNC(pow) (minus_infty, -1001), minus_zero);
1176
1177   check ("pow (-inf, -2) == +0", FUNC(pow) (minus_infty, -2), 0);
1178   check ("pow (-inf, -12) == +0", FUNC(pow) (minus_infty, -12), 0);
1179   check ("pow (-inf, -1002) == +0", FUNC(pow) (minus_infty, -1002), 0);
1180   check ("pow (-inf, -0.1) == +0", FUNC(pow) (minus_infty, -0.1), 0);
1181   check ("pow (-inf, -1.1) == +0", FUNC(pow) (minus_infty, -1.1), 0);
1182   check ("pow (-inf, -11.1) == +0", FUNC(pow) (minus_infty, -11.1), 0);
1183   check ("pow (-inf, -1001.1) == +0", FUNC(pow) (minus_infty, -1001.1), 0);
1184
1185   check_isnan ("pow (NaN, NaN) == NaN", FUNC(pow) (nan_value, nan_value));
1186   check_isnan ("pow (0, NaN) == NaN", FUNC(pow) (0, nan_value));
1187   check_isnan ("pow (1, NaN) == NaN", FUNC(pow) (1, nan_value));
1188   check_isnan ("pow (-1, NaN) == NaN", FUNC(pow) (-1, nan_value));
1189   check_isnan ("pow (NaN, 1) == NaN", FUNC(pow) (nan_value, 1));
1190   check_isnan ("pow (NaN, -1) == NaN", FUNC(pow) (nan_value, -1));
1191
1192   x = random_greater (0.0);
1193   check_isnan_ext ("pow (x, NaN) == NaN", FUNC(pow) (x, nan_value), x);
1194
1195   check_isnan_exc ("pow (+1, +inf) == NaN", FUNC(pow) (1, plus_infty),
1196                    INVALID_EXCEPTION);
1197   check_isnan_exc ("pow (-1, +inf) == NaN", FUNC(pow) (-1, plus_infty),
1198                    INVALID_EXCEPTION);
1199   check_isnan_exc ("pow (+1, -inf) == NaN", FUNC(pow) (1, minus_infty),
1200                    INVALID_EXCEPTION);
1201   check_isnan_exc ("pow (-1, -inf) == NaN", FUNC(pow) (-1, minus_infty),
1202                    INVALID_EXCEPTION);
1203
1204   check_isnan_exc ("pow (-0.1, 1.1) == NaN", FUNC(pow) (-0.1, 1.1),
1205                    INVALID_EXCEPTION);
1206   check_isnan_exc ("pow (-0.1, -1.1) == NaN", FUNC(pow) (-0.1, -1.1),
1207                    INVALID_EXCEPTION);
1208   check_isnan_exc ("pow (-10.1, 1.1) == NaN", FUNC(pow) (-10.1, 1.1),
1209                    INVALID_EXCEPTION);
1210   check_isnan_exc ("pow (-10.1, -1.1) == NaN", FUNC(pow) (-10.1, -1.1),
1211                    INVALID_EXCEPTION);
1212
1213   check_isinfp_exc ("pow (+0, -1) == +inf", FUNC(pow) (0, -1),
1214                     DIVIDE_BY_ZERO_EXCEPTION);
1215   check_isinfp_exc ("pow (+0, -11) == +inf", FUNC(pow) (0, -11),
1216                     DIVIDE_BY_ZERO_EXCEPTION);
1217   check_isinfn_exc ("pow (-0, -1) == -inf", FUNC(pow) (minus_zero, -1),
1218                     DIVIDE_BY_ZERO_EXCEPTION);
1219   check_isinfn_exc ("pow (-0, -11) == -inf", FUNC(pow) (minus_zero, -11),
1220                     DIVIDE_BY_ZERO_EXCEPTION);
1221
1222   check_isinfp_exc ("pow (+0, -2) == +inf", FUNC(pow) (0, -2),
1223                     DIVIDE_BY_ZERO_EXCEPTION);
1224   check_isinfp_exc ("pow (+0, -11.1) == +inf", FUNC(pow) (0, -11.1),
1225                     DIVIDE_BY_ZERO_EXCEPTION);
1226   check_isinfp_exc ("pow (-0, -2) == +inf", FUNC(pow) (minus_zero, -2),
1227                     DIVIDE_BY_ZERO_EXCEPTION);
1228   check_isinfp_exc ("pow (-0, -11.1) == +inf", FUNC(pow) (minus_zero, -11.1),
1229                     DIVIDE_BY_ZERO_EXCEPTION);
1230
1231   check ("pow (+0, 1) == +0", FUNC(pow) (0, 1), 0);
1232   check ("pow (+0, 11) == +0", FUNC(pow) (0, 11), 0);
1233   check ("pow (-0, 1) == -0", FUNC(pow) (minus_zero, 1), minus_zero);
1234   check ("pow (-0, 11) == -0", FUNC(pow) (minus_zero, 11), minus_zero);
1235
1236   check ("pow (+0, 2) == +0", FUNC(pow) (0, 2), 0);
1237   check ("pow (+0, 11.1) == +0", FUNC(pow) (0, 11.1), 0);
1238   check ("pow (-0, 2) == +0", FUNC(pow) (minus_zero, 2), 0);
1239   check ("pow (-0, 11.1) == +0", FUNC(pow) (minus_zero, 11.1), 0);
1240
1241   x = random_greater (1.0);
1242   check_isinfp_ext ("pow (x, +inf) == +inf for |x| > 1",
1243                     FUNC(pow) (x, plus_infty), x);
1244
1245   x = random_value (-1.0, 1.0);
1246   check_ext ("pow (x, +inf) == +0 for |x| < 1",
1247              FUNC(pow) (x, plus_infty), 0.0, x);
1248
1249   x = random_greater (1.0);
1250   check_ext ("pow (x, -inf) == +0 for |x| > 1",
1251              FUNC(pow) (x, minus_infty), 0.0, x);
1252
1253   x = random_value (-1.0, 1.0);
1254   check_isinfp_ext ("pow (x, -inf) == +inf for |x| < 1",
1255                     FUNC(pow) (x, minus_infty), x);
1256
1257   x = random_greater (0.0);
1258   check_isinfp_ext ("pow (+inf, y) == +inf for y > 0",
1259                     FUNC(pow) (plus_infty, x), x);
1260
1261   x = random_less (0.0);
1262   check_ext ("pow (+inf, y) == +0 for y < 0",
1263              FUNC(pow) (plus_infty, x), 0.0, x);
1264
1265   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
1266   check_isinfn_ext ("pow (-inf, y) == -inf for y an odd integer > 0",
1267                     FUNC(pow) (minus_infty, x), x);
1268
1269   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
1270   check_isinfp_ext ("pow (-inf, y) == +inf for y > 0 and not an odd integer",
1271                     FUNC(pow) (minus_infty, x), x);
1272
1273   x = -((rand () % 1000000) * 2.0 + 1); /* Get random odd integer < 0 */
1274   check_ext ("pow (-inf, y) == -0 for y an odd integer < 0",
1275              FUNC(pow) (minus_infty, x), minus_zero, x);
1276
1277   x = ((rand () % 1000000) + 1) * -2.0; /* Get random even integer < 0 */
1278   check_ext ("pow (-inf, y) == +0 for y < 0 and not an odd integer",
1279              FUNC(pow) (minus_infty, x), 0.0, x);
1280
1281   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
1282   check_ext ("pow (+0, y) == +0 for y an odd integer > 0",
1283              FUNC(pow) (0.0, x), 0.0, x);
1284   x = (rand () % 1000000) * 2.0 + 1;    /* Get random odd integer > 0 */
1285   check_ext ("pow (-0, y) == -0 for y an odd integer > 0",
1286              FUNC(pow) (minus_zero, x), minus_zero, x);
1287
1288   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
1289   check_ext ("pow (+0, y) == +0 for y > 0 and not an odd integer",
1290              FUNC(pow) (0.0, x), 0.0, x);
1291
1292   x = ((rand () % 1000000) + 1) * 2.0;  /* Get random even integer > 1 */
1293   check_ext ("pow (-0, y) == +0 for y > 0 and not an odd integer",
1294              FUNC(pow) (minus_zero, x), 0.0, x);
1295 }
1296
1297
1298 static void
1299 fdim_test (void)
1300 {
1301   check ("fdim (+0, +0) = +0", FUNC(fdim) (0, 0), 0);
1302   check ("fdim (9, 0) = 9", FUNC(fdim) (9, 0), 9);
1303   check ("fdim (0, 9) = 0", FUNC(fdim) (0, 9), 0);
1304   check ("fdim (-9, 0) = 9", FUNC(fdim) (-9, 0), 0);
1305   check ("fdim (0, -9) = 9", FUNC(fdim) (0, -9), 9);
1306
1307   check_isinfp ("fdim (+inf, 9) = +inf", FUNC(fdim) (plus_infty, 9));
1308   check_isinfp ("fdim (+inf, -9) = +inf", FUNC(fdim) (plus_infty, -9));
1309   check ("fdim (-inf, 9) = 0", FUNC(fdim) (minus_infty, 9), 0);
1310   check ("fdim (-inf, -9) = 0", FUNC(fdim) (minus_infty, -9), 0);
1311   check_isinfp ("fdim (+9, -inf) = +inf", FUNC(fdim) (9, minus_infty));
1312   check_isinfp ("fdim (-9, -inf) = +inf", FUNC(fdim) (-9, minus_infty));
1313   check ("fdim (9, inf) = 0", FUNC(fdim) (9, plus_infty), 0);
1314   check ("fdim (-9, inf) = 0", FUNC(fdim) (-9, plus_infty), 0);
1315
1316   check_isnan ("fdim (0, NaN) = NaN", FUNC(fdim) (0, nan_value));
1317   check_isnan ("fdim (9, NaN) = NaN", FUNC(fdim) (9, nan_value));
1318   check_isnan ("fdim (-9, NaN) = NaN", FUNC(fdim) (-9, nan_value));
1319   check_isnan ("fdim (NaN, 9) = NaN", FUNC(fdim) (nan_value, 9));
1320   check_isnan ("fdim (NaN, -9) = NaN", FUNC(fdim) (nan_value, -9));
1321   check_isnan ("fdim (+inf, NaN) = NaN", FUNC(fdim) (plus_infty, nan_value));
1322   check_isnan ("fdim (-inf, NaN) = NaN", FUNC(fdim) (minus_infty, nan_value));
1323   check_isnan ("fdim (NaN, +inf) = NaN", FUNC(fdim) (nan_value, plus_infty));
1324   check_isnan ("fdim (NaN, -inf) = NaN", FUNC(fdim) (nan_value, minus_infty));
1325   check_isnan ("fdim (NaN, NaN) = NaN", FUNC(fdim) (nan_value, nan_value));
1326 }
1327
1328
1329 static void
1330 fmin_test (void)
1331 {
1332   check ("fmin (+0, +0) = +0", FUNC(fmin) (0, 0), 0);
1333   check ("fmin (9, 0) = 0", FUNC(fmin) (9, 0), 0);
1334   check ("fmin (0, 9) = 0", FUNC(fmin) (0, 9), 0);
1335   check ("fmin (-9, 0) = -9", FUNC(fmin) (-9, 0), -9);
1336   check ("fmin (0, -9) = -9", FUNC(fmin) (0, -9), -9);
1337
1338   check ("fmin (+inf, 9) = 9", FUNC(fmin) (plus_infty, 9), 9);
1339   check ("fmin (9, +inf) = 9", FUNC(fmin) (9, plus_infty), 9);
1340   check ("fmin (+inf, -9) = -9", FUNC(fmin) (plus_infty, -9), -9);
1341   check ("fmin (-9, +inf) = -9", FUNC(fmin) (-9, plus_infty), -9);
1342   check_isinfn ("fmin (-inf, 9) = -inf", FUNC(fmin) (minus_infty, 9));
1343   check_isinfn ("fmin (-inf, -9) = -inf", FUNC(fmin) (minus_infty, -9));
1344   check_isinfn ("fmin (+9, -inf) = -inf", FUNC(fmin) (9, minus_infty));
1345   check_isinfn ("fmin (-9, -inf) = -inf", FUNC(fmin) (-9, minus_infty));
1346
1347   check ("fmin (0, NaN) = 0", FUNC(fmin) (0, nan_value), 0);
1348   check ("fmin (9, NaN) = 9", FUNC(fmin) (9, nan_value), 9);
1349   check ("fmin (-9, NaN) = 9", FUNC(fmin) (-9, nan_value), -9);
1350   check ("fmin (NaN, 0) = 0", FUNC(fmin) (nan_value, 0), 0);
1351   check ("fmin (NaN, 9) = NaN", FUNC(fmin) (nan_value, 9), 9);
1352   check ("fmin (NaN, -9) = NaN", FUNC(fmin) (nan_value, -9), -9);
1353   check_isinfp ("fmin (+inf, NaN) = +inf", FUNC(fmin) (plus_infty, nan_value));
1354   check_isinfn ("fmin (-inf, NaN) = -inf", FUNC(fmin) (minus_infty, nan_value));
1355   check_isinfp ("fmin (NaN, +inf) = +inf", FUNC(fmin) (nan_value, plus_infty));
1356   check_isinfn ("fmin (NaN, -inf) = -inf", FUNC(fmin) (nan_value, minus_infty));
1357   check_isnan ("fmin (NaN, NaN) = NaN", FUNC(fmin) (nan_value, nan_value));
1358 }
1359
1360
1361 static void
1362 fmax_test (void)
1363 {
1364   check ("fmax (+0, +0) = +0", FUNC(fmax) (0, 0), 0);
1365   check ("fmax (9, 0) = 9", FUNC(fmax) (9, 0), 9);
1366   check ("fmax (0, 9) = 9", FUNC(fmax) (0, 9), 9);
1367   check ("fmax (-9, 0) = 0", FUNC(fmax) (-9, 0), 0);
1368   check ("fmax (0, -9) = 0", FUNC(fmax) (0, -9), 0);
1369
1370   check_isinfp ("fmax (+inf, 9) = +inf", FUNC(fmax) (plus_infty, 9));
1371   check_isinfp ("fmax (9, +inf) = +inf", FUNC(fmax) (0, plus_infty));
1372   check_isinfp ("fmax (-9, +inf) = +inf", FUNC(fmax) (-9, plus_infty));
1373   check_isinfp ("fmax (+inf, -9) = +inf", FUNC(fmax) (plus_infty, -9));
1374   check ("fmax (-inf, 9) = 9", FUNC(fmax) (minus_infty, 9), 9);
1375   check ("fmax (-inf, -9) = -9", FUNC(fmax) (minus_infty, -9), -9);
1376   check ("fmax (+9, -inf) = 9", FUNC(fmax) (9, minus_infty), 9);
1377   check ("fmax (-9, -inf) = -9", FUNC(fmax) (-9, minus_infty), -9);
1378
1379   check ("fmax (0, NaN) = 0", FUNC(fmax) (0, nan_value), 0);
1380   check ("fmax (9, NaN) = 9", FUNC(fmax) (9, nan_value), 9);
1381   check ("fmax (-9, NaN) = 9", FUNC(fmax) (-9, nan_value), -9);
1382   check ("fmax (NaN, 0) = 0", FUNC(fmax) (nan_value, 0), 0);
1383   check ("fmax (NaN, 9) = NaN", FUNC(fmax) (nan_value, 9), 9);
1384   check ("fmax (NaN, -9) = NaN", FUNC(fmax) (nan_value, -9), -9);
1385   check_isinfp ("fmax (+inf, NaN) = +inf", FUNC(fmax) (plus_infty, nan_value));
1386   check_isinfn ("fmax (-inf, NaN) = -inf", FUNC(fmax) (minus_infty, nan_value));
1387   check_isinfp ("fmax (NaN, +inf) = +inf", FUNC(fmax) (nan_value, plus_infty));
1388   check_isinfn ("fmax (NaN, -inf) = -inf", FUNC(fmax) (nan_value, minus_infty));
1389   check_isnan ("fmax (NaN, NaN) = NaN", FUNC(fmax) (nan_value, nan_value));
1390 }
1391
1392
1393 static void
1394 nextafter_test (void)
1395 {
1396   MATHTYPE x;
1397
1398   check ("nextafter (+0, +0) = +0", FUNC(nextafter) (0, 0), 0);
1399   check ("nextafter (-0, +0) = +0", FUNC(nextafter) (minus_zero, 0), 0);
1400   check ("nextafter (+0, -0) = -0", FUNC(nextafter) (0, minus_zero),
1401          minus_zero);
1402   check ("nextafter (-0, -0) = -0", FUNC(nextafter) (minus_zero, minus_zero),
1403          minus_zero);
1404
1405   check ("nextafter (9, 9) = 9",  FUNC(nextafter) (9, 9), 9);
1406   check ("nextafter (-9, -9) = -9",  FUNC(nextafter) (-9, -9), -9);
1407   check_isinfp ("nextafter (+inf, +inf) = +inf",
1408                 FUNC(nextafter) (plus_infty, plus_infty));
1409   check_isinfn ("nextafter (-inf, -inf) = -inf",
1410                 FUNC(nextafter) (minus_infty, minus_infty));
1411
1412   x = rand () * 1.1;
1413   check_isnan ("nextafter (NaN, x) = NaN", FUNC(nextafter) (nan_value, x));
1414   check_isnan ("nextafter (x, NaN) = NaN", FUNC(nextafter) (x, nan_value));
1415   check_isnan ("nextafter (NaN, NaN) = NaN", FUNC(nextafter) (nan_value,
1416                                                               nan_value));
1417
1418   /* XXX We need the hexadecimal FP number representation here for further
1419      tests.  */
1420 }
1421
1422
1423 static void
1424 copysign_test (void)
1425 {
1426   check ("copysign (0, 4) = 0", FUNC(copysign) (0, 4), 0);
1427   check ("copysign (0, -4) = -0", FUNC(copysign) (0, -4), minus_zero);
1428   check ("copysign (-0, 4) = 0", FUNC(copysign) (minus_zero, 4), 0);
1429   check ("copysign (-0, -4) = -0", FUNC(copysign) (minus_zero, -4),
1430          minus_zero);
1431
1432   check_isinfp ("copysign (+inf, 0) = +inf", FUNC(copysign) (plus_infty, 0));
1433   check_isinfn ("copysign (+inf, -0) = -inf", FUNC(copysign) (plus_infty,
1434                                                               minus_zero));
1435   check_isinfp ("copysign (-inf, 0) = +inf", FUNC(copysign) (minus_infty, 0));
1436   check_isinfn ("copysign (-inf, -0) = -inf", FUNC(copysign) (minus_infty,
1437                                                               minus_zero));
1438
1439   check ("copysign (0, +inf) = 0", FUNC(copysign) (0, plus_infty), 0);
1440   check ("copysign (0, -inf) = -0", FUNC(copysign) (0, minus_zero),
1441          minus_zero);
1442   check ("copysign (-0, +inf) = 0", FUNC(copysign) (minus_zero, plus_infty),
1443          0);
1444   check ("copysign (-0, -inf) = -0", FUNC(copysign) (minus_zero, minus_zero),
1445          minus_zero);
1446
1447   /* XXX More correctly we would have to check the sign of the NaN.  */
1448   check_isnan ("copysign (+NaN, 0) = +NaN", FUNC(copysign) (nan_value, 0));
1449   check_isnan ("copysign (+NaN, -0) = -NaN", FUNC(copysign) (nan_value,
1450                                                              minus_zero));
1451   check_isnan ("copysign (-NaN, 0) = +NaN", FUNC(copysign) (-nan_value, 0));
1452   check_isnan ("copysign (-NaN, -0) = -NaN", FUNC(copysign) (-nan_value,
1453                                                              minus_zero));
1454 }
1455
1456
1457 static void
1458 trunc_test (void)
1459 {
1460   check ("trunc(0) = 0", FUNC(trunc) (0), 0);
1461   check ("trunc(-0) = -0", FUNC(trunc) (minus_zero), minus_zero);
1462   check ("trunc(0.625) = 0", FUNC(trunc) (0.625), 0);
1463   check ("trunc(-0.625) = -0", FUNC(trunc) (-0.625), minus_zero);
1464   check ("trunc(1) = 1", FUNC(trunc) (1), 1);
1465   check ("trunc(-1) = -1", FUNC(trunc) (-1), -1);
1466   check ("trunc(1.625) = 1", FUNC(trunc) (1.625), 1);
1467   check ("trunc(-1.625) = -1", FUNC(trunc) (-1.625), -1);
1468
1469   check ("trunc(1048580.625) = 1048580", FUNC(trunc) (1048580.625L),
1470          1048580L);
1471   check ("trunc(-1048580.625) = -1048580", FUNC(trunc) (-1048580.625L),
1472          -1048580L);
1473
1474   check ("trunc(8388610.125) = 8388610", FUNC(trunc) (8388610.125L),
1475          8388610.0L);
1476   check ("trunc(-8388610.125) = -8388610", FUNC(trunc) (-8388610.125L),
1477          -8388610.0L);
1478
1479   check ("trunc(4294967296.625) = 4294967296", FUNC(trunc) (4294967296.625L),
1480          4294967296.0L);
1481   check ("trunc(-4294967296.625) = -4294967296",
1482          FUNC(trunc) (-4294967296.625L), -4294967296.0L);
1483
1484   check_isinfp ("trunc(+inf) = +inf", FUNC(trunc) (plus_infty));
1485   check_isinfn ("trunc(-inf) = -inf", FUNC(trunc) (minus_infty));
1486   check_isnan ("trunc(NaN) = NaN", FUNC(trunc) (nan_value));
1487 }
1488
1489
1490 static void
1491 sqrt_test (void)
1492 {
1493   MATHTYPE x;
1494
1495
1496   /* XXX Tests fuer negative x are missing */
1497   check ("sqrt (0) == 0", FUNC(sqrt) (0), 0);
1498   check_isnan ("sqrt (NaN) == NaN", FUNC(sqrt) (nan_value));
1499   check_isinfp ("sqrt (+inf) == +inf", FUNC(sqrt) (plus_infty));
1500
1501   x = random_value (0, 10000);
1502   check_ext ("sqrt (x*x) == x", FUNC(sqrt) (x*x), x, x);
1503   check ("sqrt (4) == 2", FUNC(sqrt) (4), 2);
1504 }
1505
1506
1507 static void
1508 remquo_test (void)
1509 {
1510   int quo;
1511   MATHTYPE result;
1512
1513   result = FUNC(remquo) (1.625, 1.0, &quo);
1514   check ("remquo(1.625, 1.0, &x) == -0.375", result, -0.375);
1515   check ("remquo(1.625, 1.0, &x) puts 1 in x", quo, 1);
1516
1517   result = FUNC(remquo) (-1.625, 1.0, &quo);
1518   check ("remquo(-1.625, 1.0, &x) == 0.375", result, 0.375);
1519   check ("remquo(-1.625, 1.0, &x) puts -1 in x", quo, -1);
1520
1521   result = FUNC(remquo) (1.625, -1.0, &quo);
1522   check ("remquo(1.125, -1.0, &x) == 0.125", result, 0.125);
1523   check ("remquo(1.125, -1.0, &x) puts -1 in x", quo, -1);
1524
1525   result = FUNC(remquo) (-1.625, -1.0, &quo);
1526   check ("remquo(-1.125, -1.0, &x) == 0.125", result, 0.125);
1527   check ("remquo(-1.125, -1.0, &x) puts 1 in x", quo, 1);
1528 }
1529
1530
1531 static void
1532 cexp_test (void)
1533 {
1534   __complex__ MATHTYPE result;
1535
1536   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, plus_zero));
1537   check ("real(cexp(0 + 0i)) = 1", __real__ result, 1);
1538   check ("imag(cexp(0 + 0i)) = 0", __imag__ result, 0);
1539   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_zero));
1540   check ("real(cexp(-0 + 0i)) = 1", __real__ result, 1);
1541   check ("imag(cexp(-0 + 0i)) = 0", __imag__ result, 0);
1542   result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, minus_zero));
1543   check ("real(cexp(0 - 0i)) = 1", __real__ result, 1);
1544   check ("imag(cexp(0 - 0i)) = -0", __imag__ result, minus_zero);
1545   result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_zero));
1546   check ("real(cexp(-0 - 0i)) = 1", __real__ result, 1);
1547   check ("imag(cexp(-0 - 0i)) = -0", __imag__ result, minus_zero);
1548
1549   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_zero));
1550   check_isinfp ("real(cexp(+inf + 0i)) = +inf", __real__ result);
1551   check ("imag(cexp(+inf + 0i)) = 0", __imag__ result, 0);
1552   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_zero));
1553   check_isinfp ("real(cexp(+inf - 0i)) = +inf", __real__ result);
1554   check ("imag(cexp(+inf - 0i)) = -0", __imag__ result, minus_zero);
1555
1556   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_zero));
1557   check ("real(cexp(-inf + 0i)) = 0", __real__ result, 0);
1558   check ("imag(cexp(-inf + 0i)) = 0", __imag__ result, 0);
1559   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_zero));
1560   check ("real(cexp(-inf - 0i)) = 0", __real__ result, 0);
1561   check ("imag(cexp(-inf - 0i)) = -0", __imag__ result, minus_zero);
1562
1563   result = FUNC(cexp) (BUILD_COMPLEX (100.0, plus_infty));
1564   check_isnan ("real(cexp(x + i inf)) = NaN", __real__ result);
1565   check_isnan ("imag(cexp(x + i inf)) = NaN", __imag__ result);
1566   result = FUNC(cexp) (BUILD_COMPLEX (100.0, minus_infty));
1567   check_isnan ("real(cexp(x - i inf)) = NaN", __real__ result);
1568   check_isnan ("imag(cexp(x - i inf)) = NaN", __imag__ result);
1569
1570   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 2.0));
1571   check ("real(cexp(-inf + 2.0i)) = -0", __real__ result, minus_zero);
1572   check ("imag(cexp(-inf + 2.0i)) = 0", __imag__ result, 0);
1573   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 4.0));
1574   check ("real(cexp(-inf + 4.0i)) = -0", __real__ result, minus_zero);
1575   check ("imag(cexp(-inf + 4.0i)) = -0", __imag__ result, minus_zero);
1576
1577   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 2.0));
1578   check_isinfn ("real(cexp(+inf + 2.0i)) = -inf", __real__ result);
1579   check_isinfp ("imag(cexp(+inf + 2.0i)) = +inf", __imag__ result);
1580   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 4.0));
1581   check_isinfn ("real(cexp(+inf + 4.0i)) = -inf", __real__ result);
1582   check_isinfn ("imag(cexp(+inf + 4.0i)) = -inf", __imag__ result);
1583
1584   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_infty));
1585   check_isinfp ("real(cexp(+inf + i inf)) = +inf", __real__ result);
1586   check_isnan ("imag(cexp(+inf + i inf)) = NaN", __imag__ result);
1587   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_infty));
1588   check_isinfp ("real(cexp(+inf - i inf)) = +inf", __real__ result);
1589   check_isnan ("imag(cexp(+inf - i inf)) = NaN", __imag__ result);
1590
1591   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_infty));
1592   check ("real(cexp(-inf + i inf)) = 0", __real__ result, 0);
1593   check ("imag(cexp(-inf + i inf)) = 0", __imag__ result, 0);
1594   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_infty));
1595   check ("real(cexp(-inf - i inf)) = 0", __real__ result, 0);
1596   check ("imag(cexp(-inf - i inf)) = -0", __imag__ result, minus_zero);
1597
1598   result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, nan_value));
1599   check ("real(cexp(-inf + i NaN)) = 0", __real__ result, 0);
1600   check ("imag(cexp(-inf + i NaN)) = 0", fabs (__imag__ result), 0);
1601
1602   result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, nan_value));
1603   check_isinfp ("real(cexp(+inf + i NaN)) = +inf", __real__ result);
1604   check_isnan ("imag(cexp(+inf + i NaN)) = NaN", __imag__ result);
1605
1606   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0));
1607   check_isnan ("real(cexp(NaN + 1i)) = NaN", __real__ result);
1608   check_isnan ("imag(cexp(NaN + 1i)) = NaN", __imag__ result);
1609   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0));
1610   check_isnan ("real(cexp(NaN + i inf)) = NaN", __real__ result);
1611   check_isnan ("imag(cexp(NaN + i inf)) = NaN", __imag__ result);
1612   result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0));
1613   check_isnan ("real(cexp(NaN + i NaN)) = NaN", __real__ result);
1614   check_isnan ("imag(cexp(NaN + i NaN)) = NaN", __imag__ result);
1615
1616   result = FUNC(cexp) (BUILD_COMPLEX (0, nan_value));
1617   check_isnan ("real(cexp(0 + i NaN)) = NaN", __real__ result);
1618   check_isnan ("imag(cexp(0 + i NaN)) = NaN", __imag__ result);
1619   result = FUNC(cexp) (BUILD_COMPLEX (1, nan_value));
1620   check_isnan ("real(cexp(1 + i NaN)) = NaN", __real__ result);
1621   check_isnan ("imag(cexp(1 + i NaN)) = NaN", __imag__ result);
1622 }
1623
1624
1625 static void
1626 csinh_test (void)
1627 {
1628   __complex__ MATHTYPE result;
1629
1630   result = FUNC(csinh) (BUILD_COMPLEX (0.0, 0.0));
1631   check ("real(csinh(0 + 0i)) = 0", __real__ result, 0);
1632   check ("imag(csinh(0 + 0i)) = 0", __imag__ result, 0);
1633   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, 0.0));
1634   check ("real(csinh(-0 + 0i)) = -0", __real__ result, minus_zero);
1635   check ("imag(csinh(-0 + 0i)) = 0", __imag__ result, 0);
1636   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_zero));
1637   check ("real(csinh(0 - 0i)) = 0", __real__ result, 0);
1638   check ("imag(csinh(0 - 0i)) = -0", __imag__ result, minus_zero);
1639   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_zero));
1640   check ("real(csinh(-0 - 0i)) = -0", __real__ result, minus_zero);
1641   check ("imag(csinh(-0 - 0i)) = -0", __imag__ result, minus_zero);
1642
1643   result = FUNC(csinh) (BUILD_COMPLEX (0.0, plus_infty));
1644   check ("real(csinh(0 + i Inf)) = 0", FUNC(fabs) (__real__ result), 0);
1645   check_isnan ("imag(csinh(0 + i Inf)) = NaN", __imag__ result);
1646   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, plus_infty));
1647   check ("real(csinh(-0 + i Inf)) = -0", FUNC(fabs) (__real__ result), 0);
1648   check_isnan ("imag(csinh(-0 + i Inf)) = NaN", __imag__ result);
1649   result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_infty));
1650   check ("real(csinh(0 - i Inf)) = 0", FUNC(fabs) (__real__ result), 0);
1651   check_isnan ("imag(csinh(0 - i Inf)) = NaN", __imag__ result);
1652   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_infty));
1653   check ("real(csinh(-0 - i Inf)) = -0", FUNC(fabs) (__real__ result), 0);
1654   check_isnan ("imag(csinh(-0 - i Inf)) = NaN", __imag__ result);
1655
1656   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 0.0));
1657   check_isinfp ("real(csinh(+Inf + 0i)) = +Inf", __real__ result);
1658   check ("imag(csinh(+Inf + 0i)) = 0", __imag__ result, 0);
1659   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 0.0));
1660   check_isinfn ("real(csinh(-Inf + 0i)) = -Inf", __real__ result);
1661   check ("imag(csinh(-Inf + 0i)) = 0", __imag__ result, 0);
1662   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_zero));
1663   check_isinfp ("real(csinh(+Inf - 0i)) = +Inf", __real__ result);
1664   check ("imag(csinh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
1665   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_zero));
1666   check_isinfn ("real(csinh(-Inf - 0i)) = -Inf", __real__ result);
1667   check ("imag(csinh(-Inf - 0i)) = -0", __imag__ result, minus_zero);
1668
1669   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, plus_infty));
1670   check_isinfp ("real(csinh(+Inf + i Inf)) = +-Inf",
1671                 FUNC(fabs) (__real__ result));
1672   check_isnan ("imag(csinh(+Inf + i Inf)) = NaN", __imag__ result);
1673   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, plus_infty));
1674   check_isinfp ("real(csinh(-Inf + i Inf)) = +-Inf",
1675                 FUNC(fabs) (__real__ result));
1676   check_isnan ("imag(csinh(-Inf + i Inf)) = NaN", __imag__ result);
1677   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_infty));
1678   check_isinfp ("real(csinh(Inf - i Inf)) = +-Inf",
1679                 FUNC(fabs) (__real__ result));
1680   check_isnan ("imag(csinh(Inf - i Inf)) = NaN", __imag__ result);
1681   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_infty));
1682   check_isinfp ("real(csinh(-Inf - i Inf)) = -Inf",
1683                 FUNC(fabs) (__real__ result));
1684   check_isnan ("imag(csinh(-Inf - i Inf)) = NaN", __imag__ result);
1685
1686   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 4.625));
1687   check_isinfn ("real(csinh(+Inf + i4.625)) = -Inf", __real__ result);
1688   check_isinfn ("imag(csinh(+Inf + i4.625)) = -Inf", __imag__ result);
1689   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 4.625));
1690   check_isinfp ("real(csinh(-Inf + i4.625)) = +Inf", __real__ result);
1691   check_isinfn ("imag(csinh(-Inf + i4.625)) = -Inf", __imag__ result);
1692   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, -4.625));
1693   check_isinfn ("real(csinh(+Inf - i4.625)) = -Inf", __real__ result);
1694   check_isinfp ("imag(csinh(+Inf - i4.625)) = +Inf", __imag__ result);
1695   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, -4.625));
1696   check_isinfp ("real(csinh(-Inf - i4.625)) = +Inf", __real__ result);
1697   check_isinfp ("imag(csinh(-Inf - i4.625)) = +Inf", __imag__ result);
1698
1699   result = FUNC(csinh) (BUILD_COMPLEX (6.75, plus_infty));
1700   check_isnan ("real(csinh(6.75 + i Inf)) = NaN", __real__ result);
1701   check_isnan ("imag(csinh(6.75 + i Inf)) = NaN", __imag__ result);
1702   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, plus_infty));
1703   check_isnan ("real(csinh(-6.75 + i Inf)) = NaN", __real__ result);
1704   check_isnan ("imag(csinh(-6.75 + i Inf)) = NaN", __imag__ result);
1705   result = FUNC(csinh) (BUILD_COMPLEX (6.75, minus_infty));
1706   check_isnan ("real(csinh(6.75 - i Inf)) = NaN", __real__ result);
1707   check_isnan ("imag(csinh(6.75 - i Inf)) = NaN", __imag__ result);
1708   result = FUNC(csinh) (BUILD_COMPLEX (-6.75, minus_infty));
1709   check_isnan ("real(csinh(-6.75 - i Inf)) = NaN", __real__ result);
1710   check_isnan ("imag(csinh(-6.75 - i Inf)) = NaN", __imag__ result);
1711
1712   result = FUNC(csinh) (BUILD_COMPLEX (0.0, nan_value));
1713   check ("real(csinh(0 + i NaN)) = 0", FUNC(fabs) (__real__ result), 0);
1714   check_isnan ("imag(csinh(0 + i NaN)) = NaN", __imag__ result);
1715   result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, nan_value));
1716   check ("real(csinh(-0 + i NaN)) = -0", FUNC(fabs) (__real__ result), 0);
1717   check_isnan ("imag(csinh(-0 + i NaN)) = NaN", __imag__ result);
1718
1719   result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, nan_value));
1720   check_isinfp ("real(csinh(+Inf + i NaN)) = +-Inf",
1721                 FUNC(fabs) (__real__ result));
1722   check_isnan ("imag(csinh(+Inf + i NaN)) = NaN", __imag__ result);
1723   result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, nan_value));
1724   check_isinfp ("real(csinh(-Inf + i NaN)) = +-Inf",
1725                 FUNC(fabs) (__real__ result));
1726   check_isnan ("imag(csinh(-0 + i NaN)) = NaN", __imag__ result);
1727
1728   result = FUNC(csinh) (BUILD_COMPLEX (9.0, nan_value));
1729   check_isnan ("real(csinh(9.0 + i NaN)) = NaN", __real__ result);
1730   check_isnan ("imag(csinh(9.0 + i NaN)) = NaN", __imag__ result);
1731   result = FUNC(csinh) (BUILD_COMPLEX (-9.0, nan_value));
1732   check_isnan ("real(csinh(-9.0 + i NaN)) = NaN", __real__ result);
1733   check_isnan ("imag(csinh(-9.0 + i NaN)) = NaN", __imag__ result);
1734
1735   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 0.0));
1736   check_isnan ("real(csinh(NaN + i0)) = NaN", __real__ result);
1737   check ("imag(csinh(NaN + i0)) = NaN", __imag__ result, 0.0);
1738   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_zero));
1739   check_isnan ("real(csinh(NaN - i0)) = NaN", __real__ result);
1740   check ("imag(csinh(NaN - i0)) = NaN", __imag__ result, minus_zero);
1741
1742   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 10.0));
1743   check_isnan ("real(csinh(NaN + i10)) = NaN", __real__ result);
1744   check_isnan ("imag(csinh(NaN + i10)) = NaN", __imag__ result);
1745   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, -10.0));
1746   check_isnan ("real(csinh(NaN - i10)) = NaN", __real__ result);
1747   check_isnan ("imag(csinh(NaN - i10)) = NaN", __imag__ result);
1748
1749   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, plus_infty));
1750   check_isnan ("real(csinh(NaN + i Inf)) = NaN", __real__ result);
1751   check_isnan ("imag(csinh(NaN + i Inf)) = NaN", __imag__ result);
1752   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_infty));
1753   check_isnan ("real(csinh(NaN - i Inf)) = NaN", __real__ result);
1754   check_isnan ("imag(csinh(NaN - i Inf)) = NaN", __imag__ result);
1755
1756   result = FUNC(csinh) (BUILD_COMPLEX (nan_value, nan_value));
1757   check_isnan ("real(csinh(NaN + i NaN)) = NaN", __real__ result);
1758   check_isnan ("imag(csinh(NaN + i NaN)) = NaN", __imag__ result);
1759 }
1760
1761
1762 static void
1763 ccosh_test (void)
1764 {
1765   __complex__ MATHTYPE result;
1766
1767   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, 0.0));
1768   check ("real(ccosh(0 + 0i)) = 0", __real__ result, 1.0);
1769   check ("imag(ccosh(0 + 0i)) = 0", __imag__ result, 0);
1770   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, 0.0));
1771   check ("real(ccosh(-0 + 0i)) = -0", __real__ result, 1.0);
1772   check ("imag(ccosh(-0 + 0i)) = 0", __imag__ result, 0);
1773   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_zero));
1774   check ("real(ccosh(0 - 0i)) = 0", __real__ result, 1.0);
1775   check ("imag(ccosh(0 - 0i)) = -0", __imag__ result, minus_zero);
1776   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_zero));
1777   check ("real(ccosh(-0 - 0i)) = -0", __real__ result, 1.0);
1778   check ("imag(ccosh(-0 - 0i)) = -0", __imag__ result, minus_zero);
1779
1780   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, plus_infty));
1781   check_isnan ("real(ccosh(0 + i Inf)) = NaN", __real__ result);
1782   check ("imag(ccosh(0 + i Inf)) = +-0", FUNC(fabs) (__imag__ result), 0);
1783   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, plus_infty));
1784   check_isnan ("real(ccosh(-0 + i Inf)) = NaN", __real__ result);
1785   check ("imag(ccosh(-0 + i Inf)) = -0", FUNC(fabs) (__imag__ result), 0);
1786   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_infty));
1787   check_isnan ("real(ccosh(0 - i Inf)) = NaN", __real__ result);
1788   check ("imag(ccosh(0 - i Inf)) = 0", FUNC(fabs) (__imag__ result), 0);
1789   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_infty));
1790   check_isnan ("real(ccosh(-0 - i Inf)) = NaN", __real__ result);
1791   check ("imag(ccosh(-0 - i Inf)) = -0", FUNC(fabs) (__imag__ result), 0);
1792
1793   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 0.0));
1794   check_isinfp ("real(ccosh(+Inf + 0i)) = +Inf", __real__ result);
1795   check ("imag(ccosh(+Inf + 0i)) = 0", __imag__ result, 0);
1796   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 0.0));
1797   check_isinfp ("real(ccosh(-Inf + 0i)) = +Inf", __real__ result);
1798   check ("imag(ccosh(-Inf + 0i)) = 0", __imag__ result, 0);
1799   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_zero));
1800   check_isinfp ("real(ccosh(+Inf - 0i)) = +Inf", __real__ result);
1801   check ("imag(ccosh(+Inf - 0i)) = -0", __imag__ result, minus_zero);
1802   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_zero));
1803   check_isinfp ("real(ccosh(-Inf - 0i)) = +Inf", __real__ result);
1804   check ("imag(ccosh(-Inf - 0i)) = -0", __imag__ result, minus_zero);
1805
1806   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, plus_infty));
1807   check_isinfp ("real(ccosh(+Inf + i Inf)) = +Inf", __real__ result);
1808   check_isnan ("imag(ccosh(+Inf + i Inf)) = NaN", __imag__ result);
1809   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, plus_infty));
1810   check_isinfp ("real(ccosh(-Inf + i Inf)) = +Inf", __real__ result);
1811   check_isnan ("imag(ccosh(-Inf + i Inf)) = NaN", __imag__ result);
1812   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_infty));
1813   check_isinfp ("real(ccosh(Inf - i Inf)) = +Inf", __real__ result);
1814   check_isnan ("imag(ccosh(Inf - i Inf)) = NaN", __imag__ result);
1815   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_infty));
1816   check_isinfp ("real(ccosh(-Inf - i Inf)) = +Inf", __real__ result);
1817   check_isnan ("imag(ccosh(-Inf - i Inf)) = NaN", __imag__ result);
1818
1819   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 4.625));
1820   check_isinfn ("real(ccosh(+Inf + i4.625)) = -Inf", __real__ result);
1821   check_isinfn ("imag(ccosh(+Inf + i4.625)) = -Inf", __imag__ result);
1822   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 4.625));
1823   check_isinfn ("real(ccosh(-Inf + i4.625)) = -Inf", __real__ result);
1824   check_isinfn ("imag(ccosh(-Inf + i4.625)) = -Inf", __imag__ result);
1825   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, -4.625));
1826   check_isinfn ("real(ccosh(+Inf - i4.625)) = -Inf", __real__ result);
1827   check_isinfp ("imag(ccosh(+Inf - i4.625)) = +Inf", __imag__ result);
1828   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, -4.625));
1829   check_isinfn ("real(ccosh(-Inf - i4.625)) = -Inf", __real__ result);
1830   check_isinfp ("imag(ccosh(-Inf - i4.625)) = +Inf", __imag__ result);
1831
1832   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, plus_infty));
1833   check_isnan ("real(ccosh(6.75 + i Inf)) = NaN", __real__ result);
1834   check_isnan ("imag(ccosh(6.75 + i Inf)) = NaN", __imag__ result);
1835   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, plus_infty));
1836   check_isnan ("real(ccosh(-6.75 + i Inf)) = NaN", __real__ result);
1837   check_isnan ("imag(ccosh(-6.75 + i Inf)) = NaN", __imag__ result);
1838   result = FUNC(ccosh) (BUILD_COMPLEX (6.75, minus_infty));
1839   check_isnan ("real(ccosh(6.75 - i Inf)) = NaN", __real__ result);
1840   check_isnan ("imag(ccosh(6.75 - i Inf)) = NaN", __imag__ result);
1841   result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, minus_infty));
1842   check_isnan ("real(ccosh(-6.75 - i Inf)) = NaN", __real__ result);
1843   check_isnan ("imag(ccosh(-6.75 - i Inf)) = NaN", __imag__ result);
1844
1845   result = FUNC(ccosh) (BUILD_COMPLEX (0.0, nan_value));
1846   check_isnan ("real(ccosh(0 + i NaN)) = NaN", __real__ result);
1847   check ("imag(ccosh(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
1848   result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, nan_value));
1849   check_isnan ("real(ccosh(-0 + i NaN)) = NaN", __real__ result);
1850   check ("imag(ccosh(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
1851
1852   result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, nan_value));
1853   check_isinfp ("real(ccosh(+Inf + i NaN)) = +Inf", __real__ result);
1854   check_isnan ("imag(ccosh(+Inf + i NaN)) = NaN", __imag__ result);
1855   result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, nan_value));
1856   check_isinfp ("real(ccosh(-Inf + i NaN)) = +Inf", __real__ result);
1857   check_isnan ("imag(ccosh(-0 + i NaN)) = NaN", __imag__ result);
1858
1859   result = FUNC(ccosh) (BUILD_COMPLEX (9.0, nan_value));
1860   check_isnan ("real(ccosh(9.0 + i NaN)) = NaN", __real__ result);
1861   check_isnan ("imag(ccosh(9.0 + i NaN)) = NaN", __imag__ result);
1862   result = FUNC(ccosh) (BUILD_COMPLEX (-9.0, nan_value));
1863   check_isnan ("real(ccosh(-9.0 + i NaN)) = NaN", __real__ result);
1864   check_isnan ("imag(ccosh(-9.0 + i NaN)) = NaN", __imag__ result);
1865
1866   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 0.0));
1867   check_isnan ("real(ccosh(NaN + i0)) = NaN", __real__ result);
1868   check ("imag(ccosh(NaN + i0)) = NaN", __imag__ result, 0.0);
1869   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_zero));
1870   check_isnan ("real(ccosh(NaN - i0)) = NaN", __real__ result);
1871   check ("imag(ccosh(NaN - i0)) = NaN", __imag__ result, minus_zero);
1872
1873   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 10.0));
1874   check_isnan ("real(ccosh(NaN + i10)) = NaN", __real__ result);
1875   check_isnan ("imag(ccosh(NaN + i10)) = NaN", __imag__ result);
1876   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, -10.0));
1877   check_isnan ("real(ccosh(NaN - i10)) = NaN", __real__ result);
1878   check_isnan ("imag(ccosh(NaN - i10)) = NaN", __imag__ result);
1879
1880   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, plus_infty));
1881   check_isnan ("real(ccosh(NaN + i Inf)) = NaN", __real__ result);
1882   check_isnan ("imag(ccosh(NaN + i Inf)) = NaN", __imag__ result);
1883   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_infty));
1884   check_isnan ("real(ccosh(NaN - i Inf)) = NaN", __real__ result);
1885   check_isnan ("imag(ccosh(NaN - i Inf)) = NaN", __imag__ result);
1886
1887   result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, nan_value));
1888   check_isnan ("real(ccosh(NaN + i NaN)) = NaN", __real__ result);
1889   check_isnan ("imag(ccosh(NaN + i NaN)) = NaN", __imag__ result);
1890 }
1891
1892
1893 #if 0
1894 /* Enable these tests as soon as the functions are available.  */
1895 static void
1896 cacos_test (void)
1897 {
1898   __complex__ MATHTYPE result;
1899
1900   result = FUNC(cacos) (BUILD_COMPLEX (0, 0));
1901   check ("real(cacos(0 + i0)) = pi/2", __real__ result, M_PI_2);
1902   check ("imag(cacos(0 + i0)) = -0", __imag__ result, minus_zero);
1903   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, 0));
1904   check ("real(cacos(-0 + i0)) = pi/2", __real__ result, M_PI_2);
1905   check ("imag(cacos(-0 + i0)) = -0", __imag__ result, minus_zero);
1906   result = FUNC(cacos) (BUILD_COMPLEX (0, minus_zero));
1907   check ("real(cacos(0 - i0)) = pi/2", __real__ result, M_PI_2);
1908   check ("imag(cacos(0 - i0)) = 0", __imag__ result, 0);
1909   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, minus_zero));
1910   check ("real(cacos(-0 - i0)) = pi/2", __real__ result, M_PI_2);
1911   check ("imag(cacos(-0 - i0)) = 0", __imag__ result, 0);
1912
1913   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, plus_infty));
1914   check ("real(cacos(-Inf + i Inf)) = 3*pi/4", __real__ result, M_PI - M_PI_4);
1915   check_isinfn ("imag(cacos(-Inf + i Inf)) = -Inf", __imag__ result);
1916   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_infty));
1917   check ("real(cacos(-Inf - i Inf)) = 3*pi/4", __real__ result, M_PI - M_PI_4);
1918   check_isinfp ("imag(cacos(-Inf - i Inf)) = +Inf", __imag__ result);
1919
1920   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, plus_infty));
1921   check ("real(cacos(+Inf + i Inf)) = pi/4", __real__ result, M_PI_4);
1922   check_isinfn ("imag(cacos(+Inf + i Inf)) = -Inf", __imag__ result);
1923   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_infty));
1924   check ("real(cacos(+Inf - i Inf)) = pi/4", __real__ result, M_PI_4);
1925   check_isinfp ("imag(cacos(+Inf - i Inf)) = +Inf", __imag__ result);
1926
1927   result = FUNC(cacos) (BUILD_COMPLEX (-10.0, plus_infty));
1928   check ("real(cacos(-10.0 + i Inf)) = pi/2", __real__ result, M_PI_2);
1929   check_isinfn ("imag(cacos(-10.0 + i Inf)) = -Inf", __imag__ result);
1930   result = FUNC(cacos) (BUILD_COMPLEX (-10.0, minus_infty));
1931   check ("real(cacos(-10.0 - i Inf)) = pi/2", __real__ result, M_PI_2);
1932   check_isinfp ("imag(cacos(-10.0 - i Inf)) = +Inf", __imag__ result);
1933   result = FUNC(cacos) (BUILD_COMPLEX (0, plus_infty));
1934   check ("real(cacos(0 + i Inf)) = pi/2", __real__ result, M_PI_2);
1935   check_isinfn ("imag(cacos(0 + i Inf)) = -Inf", __imag__ result);
1936   result = FUNC(cacos) (BUILD_COMPLEX (0, minus_infty));
1937   check ("real(cacos(0 - i Inf)) = pi/2", __real__ result, M_PI_2);
1938   check_isinfp ("imag(cacos(0 - i Inf)) = +Inf", __imag__ result);
1939   result = FUNC(cacos) (BUILD_COMPLEX (0.1, plus_infty));
1940   check ("real(cacos(0.1 + i Inf)) = pi/2", __real__ result, M_PI_2);
1941   check_isinfn ("imag(cacos(0.1 + i Inf)) = -Inf", __imag__ result);
1942   result = FUNC(cacos) (BUILD_COMPLEX (0.1, minus_infty));
1943   check ("real(cacos(0.1 - i Inf)) = pi/2", __real__ result, M_PI_2);
1944   check_isinfp ("imag(cacos(0.1 - i Inf)) = +Inf", __imag__ result);
1945
1946   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, 0));
1947   check ("real(cacos(-Inf + i0)) = pi", __real__ result, M_PI);
1948   check_isinfn ("imag(cacos(-Inf + i0)) = -Inf", __imag__ result);
1949   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_zero));
1950   check ("real(cacos(-Inf - i0)) = pi", __real__ result, M_PI);
1951   check_isinfp ("imag(cacos(-Inf - i0)) = +Inf", __imag__ result);
1952   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, 100));
1953   check ("real(cacos(-Inf + i100)) = pi", __real__ result, M_PI);
1954   check_isinfn ("imag(cacos(-Inf + i100)) = -Inf", __imag__ result);
1955   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, -100));
1956   check ("real(cacos(-Inf - i100)) = pi", __real__ result, M_PI);
1957   check_isinfp ("imag(cacos(-Inf - i100)) = +Inf", __imag__ result);
1958
1959   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, 0));
1960   check ("real(cacos(+Inf + i0)) = 0", __real__ result, 0);
1961   check_isinfn ("imag(cacos(+Inf + i0)) = -Inf", __imag__ result);
1962   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_zero));
1963   check ("real(cacos(+Inf - i0)) = 0", __real__ result, 0);
1964   check_isinfp ("imag(cacos(+Inf - i0)) = +Inf", __imag__ result);
1965   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, 0.5));
1966   check ("real(cacos(+Inf + i0.5)) = 0", __real__ result, 0);
1967   check_isinfn ("imag(cacos(+Inf + i0.5)) = -Inf", __imag__ result);
1968   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, -0.5));
1969   check ("real(cacos(+Inf - i0.5)) = 0", __real__ result, 0);
1970   check_isinfp ("imag(cacos(+Inf - i0.5)) = +Inf", __imag__ result);
1971
1972   result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, nan_value));
1973   check_isnan ("real(cacos(+Inf + i NaN)) = NaN", __real__ result);
1974   check_isinfp ("imag(cacos(+Inf + i NaN)) = +-Inf",
1975                 FUNC(fabs) (__imag__ result));
1976   result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, nan_value));
1977   check_isnan ("real(cacos(-Inf + i NaN)) = NaN", __real__ result);
1978   check_isinfp ("imag(cacos(-Inf + i NaN)) = +-Inf",
1979                 FUNC(fabs) (__imag__ result));
1980
1981   result = FUNC(cacos) (BUILD_COMPLEX (0, nan_value));
1982   check ("real(cacos(0 + i NaN)) = pi/2", __real__ result, M_PI_2);
1983   check_isnan ("imag(cacos(0 + i NaN)) = NaN", __imag__ result);
1984   result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, nan_value));
1985   check ("real(cacos(-0 + i NaN)) = pi/2", __real__ result, M_PI_2);
1986   check_isnan ("imag(cacos(-0 + i NaN)) = NaN", __imag__ result);
1987
1988   result = FUNC(cacos) (BUILD_COMPLEX (nan_value, plus_infty));
1989   check_isnan ("real(cacos(NaN + i Inf)) = NaN", __real__ result);
1990   check_isinfn ("imag(cacos(NaN + i Inf)) = -Inf", __imag__ result);
1991   result = FUNC(cacos) (BUILD_COMPLEX (nan_value, minus_infty));
1992   check_isnan ("real(cacos(NaN - i Inf)) = NaN", __real__ result);
1993   check_isinfp ("imag(cacos(NaN - i Inf)) = +Inf", __imag__ result);
1994
1995   result = FUNC(cacos) (BUILD_COMPLEX (10.5, nan_value));
1996   check_isnan ("real(cacos(10.5 + i NaN)) = NaN", __real__ result);
1997   check_isnan ("imag(cacos(10.5 + i NaN)) = NaN", __imag__ result);
1998   result = FUNC(cacos) (BUILD_COMPLEX (-10.5, nan_value));
1999   check_isnan ("real(cacos(-10.5 + i NaN)) = NaN", __real__ result);
2000   check_isnan ("imag(cacos(-10.5 + i NaN)) = NaN", __imag__ result);
2001
2002   result = FUNC(cacos) (BUILD_COMPLEX (nan_value, 0.75));
2003   check_isnan ("real(cacos(NaN + i0.75)) = NaN", __real__ result);
2004   check_isnan ("imag(cacos(NaN + i0.75)) = NaN", __imag__ result);
2005   result = FUNC(cacos) (BUILD_COMPLEX (-10.5, nan_value));
2006   check_isnan ("real(cacos(NaN - i0.75)) = NaN", __real__ result);
2007   check_isnan ("imag(cacos(NaN - i0.75)) = NaN", __imag__ result);
2008
2009   result = FUNC(cacos) (BUILD_COMPLEX (nan_value, nan_value));
2010   check_isnan ("real(cacos(NaN + i NaN)) = NaN", __real__ result);
2011   check_isnan ("imag(cacos(NaN + i NaN)) = NaN", __imag__ result);
2012 }
2013
2014
2015 static void
2016 cacosh_test (void)
2017 {
2018   __complex__ MATHTYPE result;
2019
2020   result = FUNC(cacosh) (BUILD_COMPLEX (0, 0));
2021   check ("real(cacosh(0 + i0)) = 0", __real__ result, 0);
2022   check ("imag(cacosh(0 + i0)) = pi/2", __imag__ result, M_PI_2);
2023   result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, 0));
2024   check ("real(cacosh(-0 + i0)) = 0", __real__ result, 0);
2025   check ("imag(cacosh(-0 + i0)) = pi/2", __imag__ result, M_PI_2);
2026   result = FUNC(cacosh) (BUILD_COMPLEX (0, minus_zero));
2027   check ("real(cacosh(0 - i0)) = 0", __real__ result, 0);
2028   check ("imag(cacosh(0 - i0)) = -pi/2", __imag__ result, -M_PI_2);
2029   result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, minus_zero));
2030   check ("real(cacosh(-0 - i0)) = 0", __real__ result, 0);
2031   check ("imag(cacosh(-0 - i0)) = -pi/2", __imag__ result, -M_PI_2);
2032
2033   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, plus_infty));
2034   check_isinfp ("real(cacosh(-Inf + i Inf)) = +Inf", __real__ result);
2035   check ("imag(cacosh(-Inf + i Inf)) = 3*pi/4", __imag__ result,
2036          M_PI - M_PI_4);
2037   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, minus_infty));
2038   check_isinfp ("real(cacosh(-Inf - i Inf)) = +Inf", __real__ result);
2039   check ("imag(cacosh(-Inf - i Inf)) = -3*pi/4", __imag__ result,
2040          M_PI_4 - M_PI);
2041
2042   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, plus_infty));
2043   check_isinfp ("real(cacosh(+Inf + i Inf)) = +Inf", __real__ result);
2044   check ("imag(cacosh(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4);
2045   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, minus_infty));
2046   check_isinfp ("real(cacosh(+Inf - i Inf)) = +Inf", __real__ result);
2047   check ("imag(cacosh(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4);
2048
2049   result = FUNC(cacosh) (BUILD_COMPLEX (-10.0, plus_infty));
2050   check_isinfp ("real(cacosh(-10.0 + i Inf)) = +Inf", __real__ result);
2051   check ("imag(cacosh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2052   result = FUNC(cacosh) (BUILD_COMPLEX (-10.0, minus_infty));
2053   check_isinfp ("real(cacosh(-10.0 - i Inf)) = +Inf", __real__ result);
2054   check ("imag(cacosh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2055   result = FUNC(cacosh) (BUILD_COMPLEX (0, plus_infty));
2056   check_isinfp ("real(cacosh(0 + i Inf)) = +Inf", __real__ result);
2057   check ("imag(cacosh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2058   result = FUNC(cacosh) (BUILD_COMPLEX (0, minus_infty));
2059   check_isinfp ("real(cacosh(0 - i Inf)) = +Inf", __real__ result);
2060   check ("imag(cacosh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2061   result = FUNC(cacosh) (BUILD_COMPLEX (0.1, plus_infty));
2062   check_isinfp ("real(cacosh(0.1 + i Inf)) = +Inf", __real__ result);
2063   check ("imag(cacosh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2064   result = FUNC(cacosh) (BUILD_COMPLEX (0.1, minus_infty));
2065   check_isinfp ("real(cacosh(0.1 - i Inf)) = +Inf", __real__ result);
2066   check ("imag(cacosh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2067
2068   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, 0));
2069   check_isinfp ("real(cacosh(-Inf + i0)) = +Inf", __real__ result);
2070   check ("imag(cacosh(-Inf + i0)) = pi", __imag__ result, M_PI);
2071   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, minus_zero));
2072   check_isinfp ("real(cacosh(-Inf - i0)) = +Inf", __real__ result);
2073   check ("imag(cacosh(-Inf - i0)) = -pi", __imag__ result, -M_PI);
2074   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, 100));
2075   check_isinfp ("real(cacosh(-Inf + i100)) = +Inf", __real__ result);
2076   check ("imag(cacosh(-Inf + i100)) = pi", __imag__ result, M_PI);
2077   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, -100));
2078   check_isinfp ("real(cacosh(-Inf - i100)) = +Inf", __real__ result);
2079   check ("imag(cacosh(-Inf - i100)) = -pi", __imag__ result, -M_PI);
2080
2081   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, 0));
2082   check_isinfp ("real(cacosh(+Inf + i0)) = +Inf", __real__ result);
2083   check ("imag(cacosh(+Inf + i0)) = 0", __imag__ result, 0);
2084   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, minus_zero));
2085   check_isinfp ("real(cacosh(+Inf - i0)) = +Inf", __real__ result);
2086   check ("imag(cacosh(+Inf - i0)) = -0", __imag__ result, minus_zero);
2087   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, 0.5));
2088   check_isinfp ("real(cacosh(+Inf + i0.5)) = +Inf", __real__ result);
2089   check ("imag(cacosh(+Inf + i0.5)) = 0", __imag__ result, 0);
2090   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, -0.5));
2091   check_isinfp ("real(cacosh(+Inf - i0.5)) = +Inf", __real__ result);
2092   check ("imag(cacosh(+Inf - i0.5)) = -0", __imag__ result, minus_zero);
2093
2094   result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, nan_value));
2095   check_isinfp ("real(cacosh(+Inf + i NaN)) = +Inf", __real__ result);
2096   check_isnan ("imag(cacosh(+Inf + i NaN)) = NaN", __imag__ result);
2097   result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, nan_value));
2098   check_isinfp ("real(cacosh(-Inf + i NaN)) = +Inf", __real__ result);
2099   check_isnan ("imag(cacosh(-Inf + i NaN)) = NaN", __imag__ result);
2100
2101   result = FUNC(cacosh) (BUILD_COMPLEX (0, nan_value));
2102   check_isnan ("real(cacosh(0 + i NaN)) = NaN", __real__ result);
2103   check_isnan ("imag(cacosh(0 + i NaN)) = NaN", __imag__ result);
2104   result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, nan_value));
2105   check_isnan ("real(cacosh(-0 + i NaN)) = NaN", __real__ result);
2106   check_isnan ("imag(cacosh(-0 + i NaN)) = NaN", __imag__ result);
2107
2108   result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, plus_infty));
2109   check_isinfp ("real(cacosh(NaN + i Inf)) = +Inf", __real__ result);
2110   check_isnan ("imag(cacosh(NaN + i Inf)) = NaN", __imag__ result);
2111   result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, minus_infty));
2112   check_isinfp ("real(cacosh(NaN - i Inf)) = +Inf", __real__ result);
2113   check_isnan ("imag(cacosh(NaN - i Inf)) = NaN", __imag__ result);
2114
2115   result = FUNC(cacosh) (BUILD_COMPLEX (10.5, nan_value));
2116   check_isnan ("real(cacosh(10.5 + i NaN)) = NaN", __real__ result);
2117   check_isnan ("imag(cacosh(10.5 + i NaN)) = NaN", __imag__ result);
2118   result = FUNC(cacosh) (BUILD_COMPLEX (-10.5, nan_value));
2119   check_isnan ("real(cacosh(-10.5 + i NaN)) = NaN", __real__ result);
2120   check_isnan ("imag(cacosh(-10.5 + i NaN)) = NaN", __imag__ result);
2121
2122   result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, 0.75));
2123   check_isnan ("real(cacosh(NaN + i0.75)) = NaN", __real__ result);
2124   check_isnan ("imag(cacosh(NaN + i0.75)) = NaN", __imag__ result);
2125   result = FUNC(cacosh) (BUILD_COMPLEX (-10.5, nan_value));
2126   check_isnan ("real(cacosh(NaN - i0.75)) = NaN", __real__ result);
2127   check_isnan ("imag(cacosh(NaN - i0.75)) = NaN", __imag__ result);
2128
2129   result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, nan_value));
2130   check_isnan ("real(cacosh(NaN + i NaN)) = NaN", __real__ result);
2131   check_isnan ("imag(cacosh(NaN + i NaN)) = NaN", __imag__ result);
2132 }
2133
2134
2135 static void
2136 casinh_test (void)
2137 {
2138   __complex__ MATHTYPE result;
2139
2140   result = FUNC(casinh) (BUILD_COMPLEX (0, 0));
2141   check ("real(casinh(0 + i0)) = 0", __real__ result, 0);
2142   check ("imag(casinh(0 + i0)) = 0", __imag__ result, 0);
2143   result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, 0));
2144   check ("real(casinh(-0 + i0)) = -0", __real__ result, minus_zero);
2145   check ("imag(casinh(-0 + i0)) = 0", __imag__ result, 0);
2146   result = FUNC(casinh) (BUILD_COMPLEX (0, minus_zero));
2147   check ("real(casinh(0 - i0)) = 0", __real__ result, 0);
2148   check ("imag(casinh(0 - i0)) = -0", __imag__ result, minus_zero);
2149   result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, minus_zero));
2150   check ("real(casinh(-0 - i0)) = -0", __real__ result, minus_zero);
2151   check ("imag(casinh(-0 - i0)) = -0", __imag__ result, minus_zero);
2152
2153   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, plus_infty));
2154   check_isinfp ("real(casinh(+Inf + i Inf)) = +Inf", __real__ result);
2155   check ("imag(casinh(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4);
2156   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, minus_infty));
2157   check_isinfp ("real(casinh(+Inf - i Inf)) = +Inf", __real__ result);
2158   check ("imag(casinh(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4);
2159   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, plus_infty));
2160   check_isinfn ("real(casinh(-Inf + i Inf)) = -Inf", __real__ result);
2161   check ("imag(casinh(-Inf + i Inf)) = pi/4", __imag__ result, M_PI_4);
2162   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, minus_infty));
2163   check_isinfn ("real(casinh(-Inf - i Inf)) = -Inf", __real__ result);
2164   check ("imag(casinh(-Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4);
2165
2166   result = FUNC(casinh) (BUILD_COMPLEX (-10.0, plus_infty));
2167   check_isinfn ("real(casinh(-10.0 + i Inf)) = -Inf", __real__ result);
2168   check ("imag(casinh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2169   result = FUNC(casinh) (BUILD_COMPLEX (-10.0, minus_infty));
2170   check_isinfn ("real(casinh(-10.0 - i Inf)) = -Inf", __real__ result);
2171   check ("imag(casinh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2172   result = FUNC(casinh) (BUILD_COMPLEX (0, plus_infty));
2173   check_isinfp ("real(casinh(0 + i Inf)) = +Inf", __real__ result);
2174   check ("imag(casinh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2175   result = FUNC(casinh) (BUILD_COMPLEX (0, minus_infty));
2176   check_isinfp ("real(casinh(0 - i Inf)) = +Inf", __real__ result);
2177   check ("imag(casinh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2178   result = FUNC(casinh) (BUILD_COMPLEX (0.1, plus_infty));
2179   check_isinfp ("real(casinh(0.1 + i Inf)) = +Inf", __real__ result);
2180   check ("imag(casinh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2181   result = FUNC(casinh) (BUILD_COMPLEX (0.1, minus_infty));
2182   check_isinfp ("real(casinh(0.1 - i Inf)) = +Inf", __real__ result);
2183   check ("imag(casinh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2184
2185   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, 0));
2186   check_isinfn ("real(casinh(-Inf + i0)) = -Inf", __real__ result);
2187   check ("imag(casinh(-Inf + i0)) = 0", __imag__ result, 0);
2188   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, minus_zero));
2189   check_isinfn ("real(casinh(-Inf - i0)) = -Inf", __real__ result);
2190   check ("imag(casinh(-Inf - i0)) = -0", __imag__ result, minus_zero);
2191   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, 100));
2192   check_isinfn ("real(casinh(-Inf + i100)) = -Inf", __real__ result);
2193   check ("imag(casinh(-Inf + i100)) = 0", __imag__ result, 0);
2194   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, -100));
2195   check_isinfn ("real(casinh(-Inf - i100)) = -Inf", __real__ result);
2196   check ("imag(casinh(-Inf - i100)) = -0", __imag__ result, minus_zero);
2197
2198   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, 0));
2199   check_isinfp ("real(casinh(+Inf + i0)) = +Inf", __real__ result);
2200   check ("imag(casinh(+Inf + i0)) = 0", __imag__ result, 0);
2201   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, minus_zero));
2202   check_isinfp ("real(casinh(+Inf - i0)) = +Inf", __real__ result);
2203   check ("imag(casinh(+Inf - i0)) = -0", __imag__ result, minus_zero);
2204   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, 0.5));
2205   check_isinfp ("real(casinh(+Inf + i0.5)) = +Inf", __real__ result);
2206   check ("imag(casinh(+Inf + i0.5)) = 0", __imag__ result, 0);
2207   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, -0.5));
2208   check_isinfp ("real(casinh(+Inf - i0.5)) = +Inf", __real__ result);
2209   check ("imag(casinh(+Inf - i0.5)) = -0", __imag__ result, minus_zero);
2210
2211   result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, nan_value));
2212   check_isinfp ("real(casinh(+Inf + i NaN)) = +Inf", __real__ result);
2213   check_isnan ("imag(casinh(+Inf + i NaN)) = NaN", __imag__ result);
2214   result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, nan_value));
2215   check_isinfn ("real(casinh(-Inf + i NaN)) = -Inf", __real__ result);
2216   check_isnan ("imag(casinh(-Inf + i NaN)) = NaN", __imag__ result);
2217
2218   result = FUNC(casinh) (BUILD_COMPLEX (nan_value, 0));
2219   check_isnan ("real(casinh(NaN + i0)) = NaN", __real__ result);
2220   check ("imag(casinh(NaN + i0)) = 0", __imag__ resul, 0);
2221   result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, nan_value));
2222   check_isnan ("real(casinh(NaN - i0)) = NaN", __real__ result);
2223   check ("imag(casinh(NaN - i0)) = -0", __imag__ result, minus_zero);
2224
2225   result = FUNC(casinh) (BUILD_COMPLEX (nan_value, plus_infty));
2226   check_isinfp ("real(casinh(NaN + i Inf)) = +Inf",
2227                 FUNC(fabs) (__real__ result));
2228   check_isnan ("imag(casinh(NaN + i Inf)) = NaN", __imag__ result);
2229   result = FUNC(casinh) (BUILD_COMPLEX (nan_value, minus_infty));
2230   check_isinfp ("real(casinh(NaN - i Inf)) = +Inf",
2231                 FUNC(fabs) (__real__ result));
2232   check_isnan ("imag(casinh(NaN - i Inf)) = NaN", __imag__ result);
2233
2234   result = FUNC(casinh) (BUILD_COMPLEX (10.5, nan_value));
2235   check_isnan ("real(casinh(10.5 + i NaN)) = NaN", __real__ result);
2236   check_isnan ("imag(casinh(10.5 + i NaN)) = NaN", __imag__ result);
2237   result = FUNC(casinh) (BUILD_COMPLEX (-10.5, nan_value));
2238   check_isnan ("real(casinh(-10.5 + i NaN)) = NaN", __real__ result);
2239   check_isnan ("imag(casinh(-10.5 + i NaN)) = NaN", __imag__ result);
2240
2241   result = FUNC(casinh) (BUILD_COMPLEX (nan_value, 0.75));
2242   check_isnan ("real(casinh(NaN + i0.75)) = NaN", __real__ result);
2243   check_isnan ("imag(casinh(NaN + i0.75)) = NaN", __imag__ result);
2244   result = FUNC(casinh) (BUILD_COMPLEX (-10.5, nan_value));
2245   check_isnan ("real(casinh(NaN - i0.75)) = NaN", __real__ result);
2246   check_isnan ("imag(casinh(NaN - i0.75)) = NaN", __imag__ result);
2247
2248   result = FUNC(casinh) (BUILD_COMPLEX (nan_value, nan_value));
2249   check_isnan ("real(casinh(NaN + i NaN)) = NaN", __real__ result);
2250   check_isnan ("imag(casinh(NaN + i NaN)) = NaN", __imag__ result);
2251 }
2252
2253
2254 static void
2255 catanh_test (void)
2256 {
2257   __complex__ MATHTYPE result;
2258
2259   result = FUNC(catanh) (BUILD_COMPLEX (0, 0));
2260   check ("real(catanh(0 + i0)) = 0", __real__ result, 0);
2261   check ("imag(catanh(0 + i0)) = 0", __imag__ result, 0);
2262   result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, 0));
2263   check ("real(catanh(-0 + i0)) = -0", __real__ result, minus_zero);
2264   check ("imag(catanh(-0 + i0)) = 0", __imag__ result, 0);
2265   result = FUNC(catanh) (BUILD_COMPLEX (0, minus_zero));
2266   check ("real(catanh(0 - i0)) = 0", __real__ result, 0);
2267   check ("imag(catanh(0 - i0)) = -0", __imag__ result, minus_zero);
2268   result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, minus_zero));
2269   check ("real(catanh(-0 - i0)) = -0", __real__ result, minus_zero);
2270   check ("imag(catanh(-0 - i0)) = -0", __imag__ result, minus_zero);
2271
2272   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, plus_infty));
2273   check ("real(catanh(+Inf + i Inf)) = 0", __real__ result, 0);
2274   check ("imag(catanh(+Inf + i Inf)) = pi/2", __imag__ result, M_PI_2);
2275   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, minus_infty));
2276   check ("real(catanh(+Inf - i Inf)) = 0", __real__ result, 0);
2277   check ("imag(catanh(+Inf - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2278   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, plus_infty));
2279   check ("real(catanh(-Inf + i Inf)) = -0", __real__ result, minus_zero);
2280   check ("imag(catanh(-Inf + i Inf)) = pi/2", __imag__ result, M_PI_2);
2281   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, minus_infty));
2282   check ("real(catanh(-Inf - i Inf)) = -0", __real__ result, minus_zero);
2283   check ("imag(catanh(-Inf - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2284
2285   result = FUNC(catanh) (BUILD_COMPLEX (-10.0, plus_infty));
2286   check ("real(catanh(-10.0 + i Inf)) = -0", __real__ result, -minus_zero);
2287   check ("imag(catanh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2288   result = FUNC(catanh) (BUILD_COMPLEX (-10.0, minus_infty));
2289   check ("real(catanh(-10.0 - i Inf)) = -0", __real__ result, minus_infty);
2290   check ("imag(catanh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2291   result = FUNC(catanh) (BUILD_COMPLEX (0, plus_infty));
2292   check ("real(catanh(0 + i Inf)) = 0", __real__ result, 0);
2293   check ("imag(catanh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2294   result = FUNC(catanh) (BUILD_COMPLEX (0, minus_infty));
2295   check ("real(catanh(0 - i Inf)) = 0", __real__ result, 0);
2296   check ("imag(catanh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2297   result = FUNC(catanh) (BUILD_COMPLEX (0.1, plus_infty));
2298   check ("real(catanh(0.1 + i Inf)) = 0", __real__ result, 0);
2299   check ("imag(catanh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2300   result = FUNC(catanh) (BUILD_COMPLEX (0.1, minus_infty));
2301   check ("real(catanh(0.1 - i Inf)) = 0", __real__ result, 0);
2302   check ("imag(catanh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2303
2304   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, 0));
2305   check ("real(catanh(-Inf + i0)) = -0", __real__ result, minus_zero);
2306   check ("imag(catanh(-Inf + i0)) = pi/2", __imag__ result, M_PI_2);
2307   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, minus_zero));
2308   check ("real(catanh(-Inf - i0)) = -0", __real__ result, minus_zero);
2309   check ("imag(catanh(-Inf - i0)) = -pi/2", __imag__ result, -M_PI_2);
2310   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, 100));
2311   check ("real(catanh(-Inf + i100)) = -0", __real__ result, minus_zero);
2312   check ("imag(catanh(-Inf + i100)) = pi/2", __imag__ result, M_PI_2);
2313   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, -100));
2314   check ("real(catanh(-Inf - i100)) = -0", __real__ result, minus_zero);
2315   check ("imag(catanh(-Inf - i100)) = -pi/2", __imag__ result, -M_PI_2);
2316
2317   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, 0));
2318   check ("real(catanh(+Inf + i0)) = 0", __real__ result, 0);
2319   check ("imag(catanh(+Inf + i0)) = pi/2", __imag__ result, M_PI_2);
2320   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, minus_zero));
2321   check ("real(catanh(+Inf - i0)) = 0", __real__ result, 0);
2322   check ("imag(catanh(+Inf - i0)) = -pi/2", __imag__ result, -M_PI_2);
2323   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, 0.5));
2324   check ("real(catanh(+Inf + i0.5)) = 0", __real__ result, 0);
2325   check ("imag(catanh(+Inf + i0.5)) = pi/2", __imag__ result, M_PI_2);
2326   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, -0.5));
2327   check ("real(catanh(+Inf - i0.5)) = 0", __real__ result, 0);
2328   check ("imag(catanh(+Inf - i0.5)) = -pi/2", __imag__ result, -M_PI_2);
2329
2330   result = FUNC(catanh) (BUILD_COMPLEX (0, nan_value));
2331   check ("real(catanh(0 + i NaN)) = 0", __real__ result, 0);
2332   check_isnan ("imag(catanh(+Inf + i NaN)) = NaN", __imag__ result);
2333   result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, nan_value));
2334   check ("real(catanh(-0 + i NaN)) = -0", __real__ result, minus_zero);
2335   check_isnan ("imag(catanh(-Inf + i NaN)) = NaN", __imag__ result);
2336
2337   result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, nan_value));
2338   check ("real(catanh(+Inf + i NaN)) = 0", __real__ result, 0);
2339   check_isnan ("imag(catanh(+Inf + i NaN)) = NaN", __imag__ result);
2340   result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, nan_value));
2341   check ("real(catanh(-Inf + i NaN)) = -0", __real__ result, minus_zero);
2342   check_isnan ("imag(catanh(-Inf + i NaN)) = NaN", __imag__ result);
2343
2344   result = FUNC(catanh) (BUILD_COMPLEX (nan_value, 0));
2345   check_isnan ("real(catanh(NaN + i0)) = NaN", __real__ result);
2346   check_isnan ("imag(catanh(NaN + i0)) = NaN", __imag__ resul);
2347   result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, nan_value));
2348   check_isnan ("real(catanh(NaN - i0)) = NaN", __real__ result);
2349   check_isnan ("imag(catanh(NaN - i0)) = NaN", __imag__ result);
2350
2351   result = FUNC(catanh) (BUILD_COMPLEX (nan_value, plus_infty));
2352   check ("real(catanh(NaN + i Inf)) = +-0", FUNC(fabs) (__real__ result), 0);
2353   check ("imag(catanh(NaN + i Inf)) = pi/2", __imag__ result, M_PI_2);
2354   result = FUNC(catanh) (BUILD_COMPLEX (nan_value, minus_infty));
2355   check ("real(catanh(NaN - i Inf)) = +-0", FUNC(fabs) (__real__ result), 0);
2356   check ("imag(catanh(NaN - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2357
2358   result = FUNC(catanh) (BUILD_COMPLEX (10.5, nan_value));
2359   check_isnan ("real(catanh(10.5 + i NaN)) = NaN", __real__ result);
2360   check_isnan ("imag(catanh(10.5 + i NaN)) = NaN", __imag__ result);
2361   result = FUNC(catanh) (BUILD_COMPLEX (-10.5, nan_value));
2362   check_isnan ("real(catanh(-10.5 + i NaN)) = NaN", __real__ result);
2363   check_isnan ("imag(catanh(-10.5 + i NaN)) = NaN", __imag__ result);
2364
2365   result = FUNC(catanh) (BUILD_COMPLEX (nan_value, 0.75));
2366   check_isnan ("real(catanh(NaN + i0.75)) = NaN", __real__ result);
2367   check_isnan ("imag(catanh(NaN + i0.75)) = NaN", __imag__ result);
2368   result = FUNC(catanh) (BUILD_COMPLEX (-10.5, nan_value));
2369   check_isnan ("real(catanh(NaN - i0.75)) = NaN", __real__ result);
2370   check_isnan ("imag(catanh(NaN - i0.75)) = NaN", __imag__ result);
2371
2372   result = FUNC(catanh) (BUILD_COMPLEX (nan_value, nan_value));
2373   check_isnan ("real(catanh(NaN + i NaN)) = NaN", __real__ result);
2374   check_isnan ("imag(catanh(NaN + i NaN)) = NaN", __imag__ result);
2375 }
2376
2377
2378 static void
2379 ctanh_test (void)
2380 {
2381   __complex__ MATHTYPE result;
2382
2383   result = FUNC(ctanh) (BUILD_COMPLEX (0, 0));
2384   check ("real(ctanh(0 + i0)) = 0", __real__ result, 0);
2385   check ("imag(ctanh(0 + i0)) = 0", __imag__ result, 0);
2386   result = FUNC(ctanh) (BUILD_COMPLEX (0, minus_zero));
2387   check ("real(ctanh(0 - i0)) = 0", __real__ result, 0);
2388   check ("imag(ctanh(0 - i0)) = -0", __imag__ result, minus_zero);
2389   result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, 0));
2390   check ("real(ctanh(-0 + i0)) = -0", __real__ result, minus_zero);
2391   check ("imag(ctanh(-0 + i0)) = -0", __imag__ result, 0);
2392   result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, minus_zero));
2393   check ("real(ctanh(-0 - i0)) = -0", __real__ result, minus_zero);
2394   check ("imag(ctanh(-0 - i0)) = -0", __imag__ result, minus_zero);
2395
2396   result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, 0));
2397   check ("real(ctanh(+Inf + i0)) = 1", __real__ result, 1);
2398   check ("imag(ctanh(+Inf + i0)) = 0", __imag__ result, 0);
2399   result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, 1));
2400   check ("real(ctanh(+Inf + i1)) = 1", __real__ result, 1);
2401   check ("imag(ctanh(+Inf + i1)) = 0", __imag__ result, 0);
2402   result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, minus_zero));
2403   check ("real(ctanh(+Inf - i0)) = 1", __real__ result, 1);
2404   check ("imag(ctanh(+Inf - i0)) = -0", __imag__ result, minus_zero);
2405   result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, -1));
2406   check ("real(ctanh(+Inf - i1)) = 1", __real__ result, 1);
2407   check ("imag(ctanh(+Inf - i1)) = -0", __imag__ result, minus_zero);
2408   result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, 0));
2409   check ("real(ctanh(-Inf + i0)) = -1", __real__ result, -1);
2410   check ("imag(ctanh(-Inf + i0)) = 0", __imag__ result, 0);
2411   result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, 1));
2412   check ("real(ctanh(-Inf + i1)) = -1", __real__ result, -1);
2413   check ("imag(ctanh(-Inf + i1)) = 0", __imag__ result, 0);
2414   result = FUNC(ctanh) (BUILD_COMPLEX (pminus_infty, minus_zero));
2415   check ("real(ctanh(-Inf - i0)) = -1", __real__ result, -1);
2416   check ("imag(ctanh(-Inf - i0)) = -0", __imag__ result, minus_zero);
2417   result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, -1));
2418   check ("real(ctanh(-Inf - i1)) = -1", __real__ result, -1);
2419   check ("imag(ctanh(-Inf - i1)) = -0", __imag__ result, minus_zero);
2420
2421   result = FUNC(ctanh) (BUILD_COMPLEX (0, plus_infty));
2422   check_isnan ("real(ctanh(0 + i Inf)) = NaN", __real__ result);
2423   check_isnan ("imag(ctanh(0 + i Inf)) = NaN", __imag__ result);
2424   result = FUNC(ctanh) (BUILD_COMPLEX (2, plus_infty));
2425   check_isnan ("real(ctanh(2 + i Inf)) = NaN", __real__ result);
2426   check_isnan ("imag(ctanh(2 + i Inf)) = NaN", __imag__ result);
2427   result = FUNC(ctanh) (BUILD_COMPLEX (0, minus_infty));
2428   check_isnan ("real(ctanh(0 - i Inf)) = NaN", __real__ result);
2429   check_isnan ("imag(ctanh(0 - i Inf)) = NaN", __imag__ result);
2430   result = FUNC(ctanh) (BUILD_COMPLEX (2, minus_infty));
2431   check_isnan ("real(ctanh(2 - i Inf)) = NaN", __real__ result);
2432   check_isnan ("imag(ctanh(2 - i Inf)) = NaN", __imag__ result);
2433   result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, plus_infty));
2434   check_isnan ("real(ctanh(-0 + i Inf)) = NaN", __real__ result);
2435   check_isnan ("imag(ctanh(-0 + i Inf)) = NaN", __imag__ result);
2436   result = FUNC(ctanh) (BUILD_COMPLEX (-2, plus_infty));
2437   check_isnan ("real(ctanh(-2 + i Inf)) = NaN", __real__ result);
2438   check_isnan ("imag(ctanh(-2 + i Inf)) = NaN", __imag__ result);
2439   result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, minus_infty));
2440   check_isnan ("real(ctanh(-0 - i Inf)) = NaN", __real__ result);
2441   check_isnan ("imag(ctanh(-0 - i Inf)) = NaN", __imag__ result);
2442   result = FUNC(ctanh) (BUILD_COMPLEX (-2, minus_infty));
2443   check_isnan ("real(ctanh(-2 - i Inf)) = NaN", __real__ result);
2444   check_isnan ("imag(ctanh(-2 - i Inf)) = NaN", __imag__ result);
2445
2446   result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, nan_value));
2447   check ("real(ctanh(+Inf + i NaN)) = 1", __real__ result, 1);
2448   check ("imag(ctanh(+Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
2449   result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, nan_value));
2450   check ("real(ctanh(-Inf + i NaN)) = -1", __real__ result, -1);
2451   check ("imag(ctanh(-Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0);
2452
2453   result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, 0));
2454   check_isnan ("real(ctanh(NaN + i0)) = NaN", __real__ result);
2455   check ("imag(ctanh(NaN + i0)) = 0", __imag__ result, 0);
2456   result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, minus_infty));
2457   check_isnan ("real(ctanh(NaN - i0)) = NaN", __real__ result);
2458   check ("imag(ctanh(NaN - i0)) = -0", __imag__ result, minus_infty);
2459
2460   result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, 0.5));
2461   check_isnan ("real(ctanh(NaN + i0.5)) = NaN", __real__ result);
2462   check_isnan ("imag(ctanh(NaN + i0.5)) = NaN", __imag__ result);
2463   result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, -4.5));
2464   check_isnan ("real(ctanh(NaN - i4.5)) = NaN", __real__ result);
2465   check_isnan ("imag(ctanh(NaN - i4.5)) = NaN", __imag__ result);
2466
2467   result = FUNC(ctanh) (BUILD_COMPLEX (0, nan_value));
2468   check_isnan ("real(ctanh(0 + i NaN)) = NaN", __real__ result);
2469   check_isnan ("imag(ctanh(0 + i NaN)) = NaN", __imag__ result);
2470   result = FUNC(ctanh) (BUILD_COMPLEX (5, nan_value));
2471   check_isnan ("real(ctanh(5 + i NaN)) = NaN", __real__ result);
2472   check_isnan ("imag(ctanh(5 + i NaN)) = NaN", __imag__ result);
2473   result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, nan_value));
2474   check_isnan ("real(ctanh(-0 + i NaN)) = NaN", __real__ result);
2475   check_isnan ("imag(ctanh(-0 + i NaN)) = NaN", __imag__ result);
2476   result = FUNC(ctanh) (BUILD_COMPLEX (-0.25, nan_value));
2477   check_isnan ("real(ctanh(-0.25 + i NaN)) = NaN", __real__ result);
2478   check_isnan ("imag(ctanh(-0.25 + i NaN)) = NaN", __imag__ result);
2479
2480   result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, nan_value));
2481   check_isnan ("real(ctanh(NaN + i NaN)) = NaN", __real__ result);
2482   check_isnan ("imag(ctanh(NaN + i NaN)) = NaN", __imag__ result);
2483 }
2484
2485
2486 static void
2487 clog_test (void)
2488 {
2489   __complex__ MATHTYPE result;
2490
2491   result = FUNC(clog) (BUILD_COMPLEX (minus_zero, 0));
2492   check_isinfn ("real(clog(-0 + i0)) = -Inf", __real__ result);
2493   check ("imag(clog(-0 + i0)) = pi", __imag__ result, M_PI);
2494   result = FUNC(clog) (BUILD_COMPLEX (minus_zero, minus_zero));
2495   check_isinfn ("real(clog(-0 - i0)) = -Inf", __real__ result);
2496   check ("imag(clog(-0 - i0)) = -pi", __imag__ result, -M_PI);
2497
2498   result = FUNC(clog) (BUILD_COMPLEX (0, 0));
2499   check_isinfn ("real(clog(0 + i0)) = -Inf", __real__ result);
2500   check ("imag(clog(0 + i0)) = 0", __imag__ result, 0);
2501   result = FUNC(clog) (BUILD_COMPLEX (0, minus_zero));
2502   check_isinfn ("real(clog(0 - i0)) = -Inf", __real__ result);
2503   check ("imag(clog(0 - i0)) = -0", __imag__ result, -minus_zero);
2504
2505   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, plus_infty));
2506   check_isinfp ("real(clog(-Inf + i Inf)) = +Inf", __real__ result);
2507   check ("imag(clog(-Inf + i Inf)) = 3*pi/4", __imag__ result, M_PI - M_PI_4);
2508   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, minus_infty));
2509   check_isinfp ("real(clog(-Inf - i Inf)) = +Inf", __real__ result);
2510   check ("imag(clog(-Inf - i Inf)) = -3*pi/4", __imag__ result, M_PI_4 - M_PI);
2511
2512   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, plus_infty));
2513   check_isinfp ("real(clog(+Inf + i Inf)) = +Inf", __real__ result);
2514   check ("imag(clog(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4);
2515   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_infty));
2516   check_isinfp ("real(clog(+Inf - i Inf)) = +Inf", __real__ result);
2517   check ("imag(clog(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4);
2518
2519   result = FUNC(clog) (BUILD_COMPLEX (0, plus_infty));
2520   check_isinfp ("real(clog(0 + i Inf)) = +Inf", __real__ result);
2521   check ("imag(clog(0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2522   result = FUNC(clog) (BUILD_COMPLEX (3, plus_infty));
2523   check_isinfp ("real(clog(3 + i Inf)) = +Inf", __real__ result);
2524   check ("imag(clog(3 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2525   result = FUNC(clog) (BUILD_COMPLEX (minus_zero, plus_infty));
2526   check_isinfp ("real(clog(-0 + i Inf)) = +Inf", __real__ result);
2527   check ("imag(clog(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2528   result = FUNC(clog) (BUILD_COMPLEX (-3, plus_infty));
2529   check_isinfp ("real(clog(-3 + i Inf)) = +Inf", __real__ result);
2530   check ("imag(clog(-3 + i Inf)) = pi/2", __imag__ result, M_PI_2);
2531   result = FUNC(clog) (BUILD_COMPLEX (0, minus_infty));
2532   check_isinfp ("real(clog(0 - i Inf)) = +Inf", __real__ result);
2533   check ("imag(clog(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2534   result = FUNC(clog) (BUILD_COMPLEX (3, minus_infty));
2535   check_isinfp ("real(clog(3 - i Inf)) = +Inf", __real__ result);
2536   check ("imag(clog(3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2537   result = FUNC(clog) (BUILD_COMPLEX (minus_zero, minus_infty));
2538   check_isinfp ("real(clog(-0 - i Inf)) = +Inf", __real__ result);
2539   check ("imag(clog(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2540   result = FUNC(clog) (BUILD_COMPLEX (-3, minus_infty));
2541   check_isinfp ("real(clog(-3 - i Inf)) = +Inf", __real__ result);
2542   check ("imag(clog(-3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2);
2543
2544   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, 0));
2545   check_isinfp ("real(clog(-Inf + i0)) = +Inf", __real__ result);
2546   check ("imag(clog(-Inf + i0)) = pi", __imag__ result, M_PI);
2547   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, 1));
2548   check_isinfp ("real(clog(-Inf + i1)) = +Inf", __real__ result);
2549   check ("imag(clog(-Inf + i1)) = pi", __imag__ result, M_PI);
2550   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, minus_zero));
2551   check_isinfp ("real(clog(-Inf - i0)) = +Inf", __real__ result);
2552   check ("imag(clog(-Inf - i0)) = -pi", __imag__ result, -M_PI);
2553   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, -1));
2554   check_isinfp ("real(clog(-Inf - i1)) = +Inf", __real__ result);
2555   check ("imag(clog(-Inf - i1)) = -pi", __imag__ result, -M_PI);
2556
2557   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, 0));
2558   check_isinfp ("real(clog(+Inf + i0)) = +Inf", __real__ result);
2559   check ("imag(clog(+Inf + i0)) = 0", __imag__ result, 0);
2560   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, 1));
2561   check_isinfp ("real(clog(+Inf + i1)) = +Inf", __real__ result);
2562   check ("imag(clog(+Inf + i1)) = 0", __imag__ result, 0);
2563   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_zero));
2564   check_isinfp ("real(clog(+Inf - i0)) = +Inf", __real__ result);
2565   check ("imag(clog(+Inf - i0)) = -0", __imag__ result, -0);
2566   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, -1));
2567   check_isinfp ("real(clog(+Inf - i1)) = +Inf", __real__ result);
2568   check ("imag(clog(+Inf - i1)) = -0", __imag__ result, -0);
2569
2570   result = FUNC(clog) (BUILD_COMPLEX (plus_infty, nan_value));
2571   check_isinfp ("real(clog(+Inf + i NaN)) = +Inf", __real__ result);
2572   check_isnan ("imag(clog(+Inf + i NaN)) = NaN", __imag__ result);
2573   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, nan_value));
2574   check_isinfp ("real(clog(-Inf + i NaN)) = +Inf", __real__ result);
2575   check_isnan ("imag(clog(-Inf + i NaN)) = NaN", __imag__ result);
2576
2577   result = FUNC(clog) (BUILD_COMPLEX (nan_value, plus_infty));
2578   check_isinfp ("real(clog(NaN + i Inf)) = +Inf", __real__ result);
2579   check_isnan ("imag(clog(NaN + i Inf)) = NaN", __imag__ result);
2580   result = FUNC(clog) (BUILD_COMPLEX (minus_infty, nan_value));
2581   check_isinfp ("real(clog(NaN - i Inf)) = +Inf", __real__ result);
2582   check_isnan ("imag(clog(NaN - i Inf)) = NaN", __imag__ result);
2583
2584   result = FUNC(clog) (BUILD_COMPLEX (0, nan_value));
2585   check_isnan ("real(clog(0 + i NaN)) = NaN", __real__ result);
2586   check_isnan ("imag(clog(0 + i NaN)) = NaN", __imag__ result);
2587   result = FUNC(clog) (BUILD_COMPLEX (3, nan_value));
2588   check_isnan ("real(clog(3 + i NaN)) = NaN", __real__ result);
2589   check_isnan ("imag(clog(3 + i NaN)) = NaN", __imag__ result);
2590   result = FUNC(clog) (BUILD_COMPLEX (minus_zero, nan_value));
2591   check_isnan ("real(clog(-0 + i NaN)) = NaN", __real__ result);
2592   check_isnan ("imag(clog(-0 + i NaN)) = NaN", __imag__ result);
2593   result = FUNC(clog) (BUILD_COMPLEX (-3, nan_value));
2594   check_isnan ("real(clog(-3 + i NaN)) = NaN", __real__ result);
2595   check_isnan ("imag(clog(-3 + i NaN)) = NaN", __imag__ result);
2596
2597   result = FUNC(clog) (BUILD_COMPLEX (nan_value, 0));
2598   check_isnan ("real(clog(NaN + i0)) = NaN", __real__ result);
2599   check_isnan ("imag(clog(NaN + i0)) = NaN", __imag__ result);
2600   result = FUNC(clog) (BUILD_COMPLEX (nan_value, 5));
2601   check_isnan ("real(clog(NaN + i5)) = NaN", __real__ result);
2602   check_isnan ("imag(clog(NaN + i5)) = NaN", __imag__ result);
2603   result = FUNC(clog) (BUILD_COMPLEX (nan_value, minus_zero));
2604   check_isnan ("real(clog(NaN - i0)) = NaN", __real__ result);
2605   check_isnan ("imag(clog(NaN - i0)) = NaN", __imag__ result);
2606   result = FUNC(clog) (BUILD_COMPLEX (nan_value, -5));
2607   check_isnan ("real(clog(NaN - i5)) = NaN", __real__ result);
2608   check_isnan ("imag(clog(NaN - i5)) = NaN", __imag__ result);
2609
2610   result = FUNC(clog) (BUILD_COMPLEX (nan_value, nan_value));
2611   check_isnan ("real(clog(NaN + i NaN)) = NaN", __real__ result);
2612   check_isnan ("imag(clog(NaN + i NaN)) = NaN", __imag__ result);
2613 }
2614
2615
2616 static void
2617 csqrt_test (void)
2618 {
2619   __complex__ MATHTYPE result;
2620
2621   result = FUNC(csqrt) (BUILD_COMPLEX (0, 0));
2622   check ("real(csqrt(0 + i0)) = 0", __real__ result, 0);
2623   check ("imag(csqrt(0 + i0)) = 0", __imag__ result, 0);
2624   result = FUNC(csqrt) (BUILD_COMPLEX (0, minus_zero));
2625   check ("real(csqrt(0 - i0)) = 0", __real__ result, 0);
2626   check ("imag(csqrt(0 - i0)) = -0", __imag__ result, minus_zero);
2627   result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, 0));
2628   check ("real(csqrt(-0 + i0)) = 0", __real__ result, 0);
2629   check ("imag(csqrt(-0 + i0)) = 0", __imag__ result, 0);
2630   result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, minus_zero));
2631   check ("real(csqrt(-0 - i0)) = 0", __real__ result, 0);
2632   check ("imag(csqrt(-0 - i0)) = -0", __imag__ result, minus_zero);
2633
2634   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, 0));
2635   check ("real(csqrt(-Inf + i0)) = 0", __real__ result, 0);
2636   check_isinfp ("imag(csqrt(-Inf + i0)) = +Inf", __imag__ result);
2637   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, 6));
2638   check ("real(csqrt(-Inf + i6)) = 0", __real__ result, 0);
2639   check_isinfp ("imag(csqrt(-Inf + i6)) = +Inf", __imag__ result);
2640   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, minus_zero));
2641   check ("real(csqrt(-Inf - i0)) = 0", __real__ result, 0);
2642   check_isinfn ("imag(csqrt(-Inf - i0)) = -Inf", __imag__ result);
2643   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, -6));
2644   check ("real(csqrt(-Inf - i6)) = 0", __real__ result, 0);
2645   check_isinfn ("imag(csqrt(-Inf - i6)) = -Inf", __imag__ result);
2646
2647   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, 0));
2648   check_isinfp ("real(csqrt(+Inf + i0)) = +Inf", __real__ result);
2649   check ("imag(csqrt(-Inf + i0)) = 0", __imag__ result, 0);
2650   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, 6));
2651   check_isinfp ("real(csqrt(+Inf + i6)) = +Inf", __real__ result);
2652   check ("imag(csqrt(-Inf + i6)) = 0", __imag__ result, 0);
2653   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, minus_zero));
2654   check_isinfp ("real(csqrt(+Inf - i0)) = +Inf", __real__ result);
2655   check ("imag(csqrt(-Inf - i0)) = -0", __imag__ result, minus_zero);
2656   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, -6));
2657   check_isinfp ("real(csqrt(+Inf - i6)) = +Inf", __real__ result);
2658   check ("imag(csqrt(-Inf - i6)) = -0", __imag__ result, minus_zero);
2659
2660   result = FUNC(csqrt) (BUILD_COMPLEX (0, plus_infty));
2661   check_isinfp ("real(csqrt(0 + i Inf)) = +Inf", __real__ result);
2662   check_isinfp ("imag(csqrt(0 + i Inf)) = +Inf", __imag__ result);
2663   result = FUNC(csqrt) (BUILD_COMPLEX (4, plus_infty));
2664   check_isinfp ("real(csqrt(4 + i Inf)) = +Inf", __real__ result);
2665   check_isinfp ("imag(csqrt(4 + i Inf)) = +Inf", __imag__ result);
2666   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, plus_infty));
2667   check_isinfp ("real(csqrt(+Inf + i Inf)) = +Inf", __real__ result);
2668   check_isinfp ("imag(csqrt(+Inf + i Inf)) = +Inf", __imag__ result);
2669   result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, plus_infty));
2670   check_isinfp ("real(csqrt(-0 + i Inf)) = +Inf", __real__ result);
2671   check_isinfp ("imag(csqrt(-0 + i Inf)) = +Inf", __imag__ result);
2672   result = FUNC(csqrt) (BUILD_COMPLEX (-4, plus_infty));
2673   check_isinfp ("real(csqrt(-4 + i Inf)) = +Inf", __real__ result);
2674   check_isinfp ("imag(csqrt(-4 + i Inf)) = +Inf", __imag__ result);
2675   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, plus_infty));
2676   check_isinfp ("real(csqrt(-Inf + i Inf)) = +Inf", __real__ result);
2677   check_isinfp ("imag(csqrt(-Inf + i Inf)) = +Inf", __imag__ result);
2678   result = FUNC(csqrt) (BUILD_COMPLEX (0, minus_infty));
2679   check_isinfp ("real(csqrt(0 - i Inf)) = +Inf", __real__ result);
2680   check_isinfn ("imag(csqrt(0 - i Inf)) = -Inf", __imag__ result);
2681   result = FUNC(csqrt) (BUILD_COMPLEX (4, minus_infty));
2682   check_isinfp ("real(csqrt(4 - i Inf)) = +Inf", __real__ result);
2683   check_isinfn ("imag(csqrt(4 - i Inf)) = -Inf", __imag__ result);
2684   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, minus_infty));
2685   check_isinfp ("real(csqrt(+Inf - i Inf)) = +Inf", __real__ result);
2686   check_isinfn ("imag(csqrt(+Inf - i Inf)) = -Inf", __imag__ result);
2687   result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, minus_infty));
2688   check_isinfp ("real(csqrt(-0 - i Inf)) = +Inf", __real__ result);
2689   check_isinfn ("imag(csqrt(-0 - i Inf)) = -Inf", __imag__ result);
2690   result = FUNC(csqrt) (BUILD_COMPLEX (-4, minus_infty));
2691   check_isinfp ("real(csqrt(-4 - i Inf)) = +Inf", __real__ result);
2692   check_isinfn ("imag(csqrt(-4 - i Inf)) = -Inf", __imag__ result);
2693   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, minus_infty));
2694   check_isinfp ("real(csqrt(-Inf - i Inf)) = +Inf", __real__ result);
2695   check_isinfn ("imag(csqrt(-Inf - i Inf)) = -Inf", __imag__ result);
2696
2697   result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, nan_value));
2698   check_isnan ("real(csqrt(-Inf + i NaN)) = NaN", __real__ result);
2699   check_isinfp ("imag(csqrt(-Inf + i NaN)) = +-Inf",
2700                 FUNC(fabs) (__imag__ result));
2701
2702   result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, nan_value));
2703   check_isinfp ("real(csqrt(+Inf + i NaN)) = +Inf", __real__ result);
2704   check_isnan ("imag(csqrt(+Inf + i NaN)) = NaN", __imag__ result);
2705
2706   result = FUNC(csqrt) (BUILD_COMPLEX (0, nan_value));
2707   check_isnan ("real(csqrt(0 + i NaN)) = NaN", __real__ result);
2708   check_isnan ("imag(csqrt(0 + i NaN)) = NaN", __imag__ result);
2709   result = FUNC(csqrt) (BUILD_COMPLEX (1, nan_value));
2710   check_isnan ("real(csqrt(1 + i NaN)) = NaN", __real__ result);
2711   check_isnan ("imag(csqrt(1 + i NaN)) = NaN", __imag__ result);
2712   result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, nan_value));
2713   check_isnan ("real(csqrt(-0 + i NaN)) = NaN", __real__ result);
2714   check_isnan ("imag(csqrt(-0 + i NaN)) = NaN", __imag__ result);
2715   result = FUNC(csqrt) (BUILD_COMPLEX (-1, nan_value));
2716   check_isnan ("real(csqrt(-1 + i NaN)) = NaN", __real__ result);
2717   check_isnan ("imag(csqrt(-1 + i NaN)) = NaN", __imag__ result);
2718
2719   result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, 0));
2720   check_isnan ("real(csqrt(NaN + i0)) = NaN", __real__ result);
2721   check_isnan ("imag(csqrt(NaN + i0)) = NaN", __imag__ result);
2722   result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, 8));
2723   check_isnan ("real(csqrt(NaN + i8)) = NaN", __real__ result);
2724   check_isnan ("imag(csqrt(NaN + i8)) = NaN", __imag__ result);
2725   result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, minus_zero));
2726   check_isnan ("real(csqrt(NaN - i0)) = NaN", __real__ result);
2727   check_isnan ("imag(csqrt(NaN - i0)) = NaN", __imag__ result);
2728   result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, -8));
2729   check_isnan ("real(csqrt(NaN - i8)) = NaN", __real__ result);
2730   check_isnan ("imag(csqrt(NaN - i8)) = NaN", __imag__ result);
2731
2732   result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, nan_value));
2733   check_isnan ("real(csqrt(NaN + i NaN)) = NaN", __real__ result);
2734   check_isnan ("imag(csqrt(NaN + i NaN)) = NaN", __imag__ result);
2735 }
2736 #endif
2737
2738
2739 static void
2740 inverse_func_pair_test (const char *test_name,
2741                         mathfunc f1, mathfunc inverse,
2742                         MATHTYPE x, MATHTYPE epsilon)
2743 {
2744   MATHTYPE a, b, difference;
2745   int result;
2746
2747   a = f1 (x);
2748   (void) &a;
2749   b = inverse (a);
2750   (void) &b;
2751
2752   result = check_equal (b, x, epsilon, &difference);
2753   output_result (test_name, result,
2754                  b, x, difference, PRINT, PRINT);
2755 }
2756
2757
2758 static void
2759 inverse_functions (void)
2760 {
2761   inverse_func_pair_test ("asin(sin(x)) == x",
2762                         FUNC(sin), FUNC(asin), 1.0, CHOOSE (2e-18L, 0, 1e-7L));
2763   inverse_func_pair_test ("sin(asin(x)) == x",
2764                           FUNC(asin), FUNC(sin), 1.0, 0.0);
2765
2766   inverse_func_pair_test ("acos(cos(x)) == x",
2767                        FUNC(cos), FUNC(acos), 1.0, CHOOSE (4e-18L, 1e-15L, 0));
2768   inverse_func_pair_test ("cos(acos(x)) == x",
2769                           FUNC(acos), FUNC(cos), 1.0, 0.0);
2770   inverse_func_pair_test ("atan(tan(x)) == x",
2771                           FUNC(tan), FUNC(atan), 1.0, CHOOSE (2e-18L, 0, 0));
2772   inverse_func_pair_test ("tan(atan(x)) == x",
2773                        FUNC(atan), FUNC(tan), 1.0, CHOOSE (2e-18L, 1e-15L, 0));
2774
2775   inverse_func_pair_test ("asinh(sinh(x)) == x",
2776                      FUNC(sinh), FUNC(asinh), 1.0, CHOOSE (1e-18L, 0, 1e-7));
2777   inverse_func_pair_test ("sinh(asinh(x)) == x",
2778                           FUNC(asinh), FUNC(sinh), 1.0, CHOOSE (2e-18L, 0, 0));
2779
2780   inverse_func_pair_test ("acosh(cosh(x)) == x",
2781                 FUNC(cosh), FUNC(acosh), 1.0, CHOOSE (1e-18L, 1e-15L, 0));
2782   inverse_func_pair_test ("cosh(acosh(x)) == x",
2783                           FUNC(acosh), FUNC(cosh), 1.0, 0.0);
2784
2785   inverse_func_pair_test ("atanh(tanh(x)) == x",
2786                      FUNC(tanh), FUNC(atanh), 1.0, CHOOSE (1e-18L, 1e-15L, 0));
2787   inverse_func_pair_test ("tanh(atanh(x)) == x",
2788                           FUNC(atanh), FUNC(tanh), 1.0, 0.0);
2789
2790 }
2791
2792 /* Test sin and cos with the identity: sin(x)^2 + cos(x)^2 = 1.  */
2793 static void
2794 identities1_test (MATHTYPE x, MATHTYPE epsilon)
2795 {
2796   MATHTYPE res1, res2, res3, diff;
2797   int result;
2798
2799   res1 = FUNC(sin) (x);
2800   (void) &res1;
2801   res2 = FUNC(cos) (x);
2802   (void) &res2;
2803   res3 = res1 * res1 + res2 * res2;
2804   (void) &res3;
2805
2806   result = check_equal (res3, 1.0, epsilon, &diff);
2807   output_result_ext ("sin^2 + cos^2 == 1", result,
2808                      res3, 1.0, diff, x, PRINT, PRINT);
2809 }
2810
2811
2812 /* Test sin, cos, tan with the following relation: tan = sin/cos.  */
2813 static void
2814 identities2_test (MATHTYPE x, MATHTYPE epsilon)
2815 {
2816   MATHTYPE res1, res2, res3, res4, diff;
2817   int result;
2818
2819   res1 = FUNC(sin) (x);
2820   (void) &res1;
2821   res2 = FUNC(cos) (x);
2822   (void) &res2;
2823   res3 = FUNC(tan) (x);
2824   (void) &res3;
2825   res4 = res1 / res2;
2826   (void) &res4;
2827
2828   result = check_equal (res4, res3, epsilon, &diff);
2829   output_result_ext ("sin/cos == tan", result,
2830                      res4, res3, diff, x, PRINT, PRINT);
2831 }
2832
2833
2834 /* Test cosh and sinh with the identity cosh^2 - sinh^2 = 1.  */
2835 static void
2836 identities3_test (MATHTYPE x, MATHTYPE epsilon)
2837 {
2838   MATHTYPE res1, res2, res3, diff;
2839   int result;
2840
2841   res1 = FUNC(sinh) (x);
2842   (void) &res1;
2843   res2 = FUNC(cosh) (x);
2844   (void) &res2;
2845   res3 = res2 * res2 - res1 * res1;
2846   (void) &res3;
2847
2848   result = check_equal (res3, 1.0, epsilon, &diff);
2849   output_result_ext ("cosh^2 - sinh^2 == 1", result,
2850                      res3, 1.0, diff, x, PRINT, PRINT);
2851 }
2852
2853
2854 static void
2855 identities (void)
2856 {
2857   identities1_test (0.2L, CHOOSE (1e-18L, 0, 2e-7));
2858   identities1_test (0.9L, CHOOSE (1e-18L, 0, 0));
2859   identities1_test (0, 0);
2860   identities1_test (-1, CHOOSE (1e-18L, 0, 1e-7));
2861
2862   identities2_test (0.2L, CHOOSE (0, 1e-16, 0));
2863   identities2_test (0.9L, CHOOSE (0, 1e-15, 0));
2864   identities2_test (0, 0);
2865   identities2_test (-1, CHOOSE (1e-18L, 1e-15, 0));
2866
2867   identities3_test (0.2L, CHOOSE (1e-18L, 0, 1e-7));
2868   identities3_test (0.9L, CHOOSE (1e-18L, 1e-15, 1e-6));
2869   identities3_test (0, CHOOSE (0, 0, 1e-6));
2870   identities3_test (-1, CHOOSE (1e-18L, 0, 1e-6));
2871 }
2872
2873
2874 /*
2875    Let's test that basic arithmetic is working
2876    tests: Infinity and NaN
2877  */
2878 static void
2879 basic_tests (void)
2880 {
2881   /* variables are declared volatile to forbid some compiler
2882      optimizations */
2883   volatile MATHTYPE Inf_var, NaN_var, zero_var, one_var;
2884   MATHTYPE x1, x2;
2885
2886   zero_var = 0.0;
2887   one_var = 1.0;
2888   NaN_var = nan_value;
2889   Inf_var = one_var / zero_var;
2890
2891   (void) &zero_var;
2892   (void) &one_var;
2893   (void) &NaN_var;
2894   (void) &Inf_var;
2895
2896   check_isinfp ("isinf (inf) == +1", Inf_var);
2897   check_isinfn ("isinf (-inf) == -1", -Inf_var);
2898   check_bool ("!isinf (1)", !(FUNC(isinf) (one_var)));
2899   check_bool ("!isinf (NaN)", !(FUNC(isinf) (NaN_var)));
2900
2901   check_isnan ("isnan (NaN)", NaN_var);
2902   check_isnan ("isnan (-NaN)", -NaN_var);
2903   check_bool ("!isnan (1)", !(FUNC(isnan) (one_var)));
2904   check_bool ("!isnan (inf)", !(FUNC(isnan) (Inf_var)));
2905
2906   check_bool ("inf == inf", Inf_var == Inf_var);
2907   check_bool ("-inf == -inf", -Inf_var == -Inf_var);
2908   check_bool ("inf != -inf", Inf_var != -Inf_var);
2909   check_bool ("NaN != NaN", NaN_var != NaN_var);
2910
2911   /*
2912      the same tests but this time with NAN from <nan.h>
2913      NAN is a double const
2914    */
2915   check_bool ("isnan (NAN)", isnan (NAN));
2916   check_bool ("isnan (-NAN)", isnan (-NAN));
2917   check_bool ("!isinf (NAN)", !(isinf (NAN)));
2918   check_bool ("!isinf (-NAN)", !(isinf (-NAN)));
2919   check_bool ("NAN != NAN", NAN != NAN);
2920
2921   /*
2922      And again with the value returned by the `nan' function.
2923    */
2924   check_bool ("isnan (NAN)", isnan (FUNC(nan) ("")));
2925   check_bool ("isnan (-NAN)", isnan (-FUNC(nan) ("")));
2926   check_bool ("!isinf (NAN)", !(isinf (FUNC(nan) (""))));
2927   check_bool ("!isinf (-NAN)", !(isinf (-FUNC(nan) (""))));
2928   check_bool ("NAN != NAN", FUNC(nan) ("") != FUNC(nan) (""));
2929
2930   /* test if EPSILON is ok */
2931   x1 = MATHCONST (1.0);
2932   x2 = x1 + CHOOSE (LDBL_EPSILON, DBL_EPSILON, FLT_EPSILON);
2933   check_bool ("1 != 1+EPSILON", x1 != x2);
2934
2935   x1 = MATHCONST (1.0);
2936   x2 = x1 - CHOOSE (LDBL_EPSILON, DBL_EPSILON, FLT_EPSILON);
2937   check_bool ("1 != 1-EPSILON", x1 != x2);
2938
2939   /* test if HUGE_VALx is ok */
2940   x1 = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF);
2941   check_bool ("isinf (HUGE_VALx) == +1", ISINF (x1) == +1);
2942   x1 = -CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF);
2943   check_bool ("isinf (-HUGE_VALx) == -1", ISINF (x1) == -1);
2944
2945 }
2946
2947
2948 static void
2949 initialize (void)
2950 {
2951   fpstack_test ("start *init*");
2952   plus_zero = 0.0;
2953   nan_value = plus_zero / plus_zero;    /* Suppress GCC warning */
2954
2955   minus_zero = FUNC (copysign) (0.0, -1.0);
2956   plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF);
2957   minus_infty = -CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF);
2958
2959   (void) &plus_zero;
2960   (void) &nan_value;
2961   (void) &minus_zero;
2962   (void) &plus_infty;
2963   (void) &minus_infty;
2964
2965   /* Test to make sure we start correctly.  */
2966   fpstack_test ("end *init*");
2967 }
2968
2969
2970 static struct option long_options[] =
2971 {
2972   {"verbose", optional_argument, NULL, 'v'},
2973   {"silent", no_argument, NULL, 's'},
2974   {0, 0, 0, 0}
2975 };
2976
2977
2978 static void
2979 parse_options (int argc, char *argv[])
2980 {
2981   int c;
2982   int option_index;
2983
2984   verbose = 1;
2985
2986   while (1)
2987     {
2988       c = getopt_long (argc, argv, "v::s",
2989                        long_options, &option_index);
2990
2991       /* Detect the end of the options. */
2992       if (c == -1)
2993         break;
2994
2995       switch (c)
2996         {
2997         case 'v':
2998           if (optarg)
2999             verbose = (unsigned int) strtoul (optarg, NULL, 0);
3000           else
3001             verbose = 3;
3002           break;
3003         case 's':
3004           verbose = 0;
3005         default:
3006           break;
3007         }
3008     }
3009 }
3010
3011
3012 int
3013 main (int argc, char *argv[])
3014 {
3015   parse_options (argc, argv);
3016
3017   initialize ();
3018   printf (TEST_MSG);
3019   basic_tests ();
3020
3021   acos_test ();
3022   acosh_test ();
3023   asin_test ();
3024   asinh_test ();
3025   atan_test ();
3026   atanh_test ();
3027   atan2_test ();
3028   cbrt_test ();
3029   ceil_test ();
3030   cos_test ();
3031   cosh_test ();
3032   exp_test ();
3033   exp2_test ();
3034   expm1_test ();
3035   frexp_test ();
3036   ilogb_test ();
3037   ldexp_test ();
3038   log_test ();
3039   log10_test ();
3040   log1p_test ();
3041   log2_test ();
3042   logb_test ();
3043   modf_test ();
3044   scalb_test ();
3045   scalbn_test ();
3046   sin_test ();
3047   sinh_test ();
3048   tan_test ();
3049   tanh_test ();
3050   fabs_test ();
3051   floor_test ();
3052   fpclassify_test ();
3053   hypot_test ();
3054   pow_test ();
3055   fdim_test ();
3056   fmin_test ();
3057   fmax_test ();
3058   nextafter_test ();
3059   copysign_test ();
3060   sqrt_test ();
3061   trunc_test ();
3062 #if 0
3063   /* XXX I'm not sure what is the correct result.  */
3064   remquo_test ();
3065 #endif
3066   cexp_test ();
3067   csinh_test ();
3068   ccosh_test ();
3069
3070   identities ();
3071   inverse_functions ();
3072
3073   if (noErrors)
3074     {
3075       printf ("\n%d errors occured.\n", noErrors);
3076       exit (1);
3077     }
3078   printf ("\n All tests passed sucessfully.\n");
3079   exit (0);
3080 }